+ + UTRGAN + +
+ +# Model Introduction + +UTRGAN is a generative and optimization framework for 5′ UTR design. It can generate candidate 5′ UTR sequences and predict and rank them according to gene expression, Mean Ribosome Load (MRL), and Translation Efficiency (TE). + +The Hugging Face model package already contains the data and pretrained weights required for the basic workflow, so no additional model files need to be downloaded during inference. + +# Model Description + +UTRGAN consists of multiple cooperating models: + +- **WGAN-GP Generator:** Generates candidate 5′ UTR sequences of up to 128 nt from a 40-dimensional random latent vector; +- **WGAN-GP Critic:** Used during generative-model training; +- **Xpresso:** Predicts gene-expression-related scores; +- **FramePool:** Predicts Mean Ribosome Load (MRL); +- **MTtrans:** Predicts Translation Efficiency (TE); +- **G4Boost:** Performs G4-related classification and regression analyses. + +WGAN, Xpresso, and FramePool use TensorFlow/Keras, while MTtrans uses PyTorch. + +To maintain compatibility with the legacy H5 model files released by the original projects, Legacy Keras is used when loading the corresponding models. + +# Use Cases + +| Use Case | Description | +| :---: | :--- | +| 5′ UTR candidate generation | Generate 5′ UTR candidate sequences in batches using the official pretrained WGAN. | +| MRL prediction and ranking | Use FramePool to calculate MRL scores and rank candidate sequences. | +| TE prediction and ranking | Use MTtrans to calculate TE scores and rank candidate sequences. | +| MRL/TE-directed optimization | Freeze the pretrained models and optimize the latent noise to improve the target score. | +| Gene-expression optimization | Combine UTRGAN with Xpresso to evaluate gene-expression-related properties of candidate sequences. | +| WGAN-GP training | Validate or retrain the generative model using the included UTRdb2 dataset. | + +# Usage + +## 1. OneCode + +You can use the OneCode online environment for an intelligent one-click AI4S programming experience: + +[Try OneCode for AI4S Programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home) + +## 2. Manual Installation + +**Hardware Requirements** + +- CPU inference is supported; +- A OneScience-supported DCU environment is recommended for batch generation, ranking, and training; +- TensorFlow and PyTorch access the same DCU through their compatible accelerator interfaces; +- Full training time depends on the number of candidate sequences, batch size, and device performance. + +### Download the Model Package + +Install the Hugging Face command-line tool and download the model repository: + +```bash +python -m pip install -U huggingface_hub + +hf download OneScience-Group/UTRGAN --local-dir ./UTRGAN +cd UTRGAN +``` + +### Install the Runtime Environment + +Create and activate a Python 3.11 environment, and then install the OneScience bioscience base environment: + +```bash +conda create -n utrgan python=3.11 -y +conda activate utrgan + +pip install onescience[bio-dcu] +``` + +Then install the additional or replacement dependencies specified in `requirements.txt`: + +```bash +python -m pip install --no-deps -r requirements.txt +``` + +> **Note:** This model adaptation uses **DTK 26.04**. The corresponding TensorFlow runtime has also been upgraded to **TensorFlow 2.18**. + +Check the frameworks and available devices: + +```bash +python - <<'PY' +import tensorflow as tf +import torch + +print("TensorFlow:", tf.__version__) +print("TensorFlow devices:", tf.config.list_physical_devices("GPU")) +print("PyTorch:", torch.__version__) +print("HIP:", torch.version.hip) +print("DCU available:", torch.cuda.is_available()) +PY +``` + +### Weights and Data Preparation + +The Hugging Face model package already contains the resources required for basic generation, prediction, ranking, and training validation: + +| Resource | Location | Purpose | +| --- | --- | --- | +| UTRdb2 | `conf/data/utrdb2.csv` | WGAN-GP training data | +| Motif data | `conf/data/motifs.csv` | Motif statistics and optimization analysis | +| WGAN Generator | `weight/checkpoint_3000.h5` | Generate candidate 5′ UTR sequences | +| FramePool | `weight/utr_model_combined_residual_new.h5` | MRL prediction | +| Xpresso | `weight/humanMedian_trainepoch.11-0.426.h5` | Gene-expression-related prediction | +| Xpresso | `weight/GM12878_trainepoch.06-0.5062.h5` | GM12878 expression-related prediction | +| Xpresso | `weight/K562_trainepoch.11-0.4917.h5` | K562 expression-related prediction | +| MTtrans | `weight/mttrans/RL_hard_share_MTL/3R/schedule_MTL-model_best_cv1.pth` | TE prediction | +| G4Boost | `weight/G4Boost_classifier.json` | G4 classification | +| G4Boost | `weight/G4Boost_regressor.json` | G4 regression | + +After applying the filtering and deduplication logic used by the official training scripts, UTRdb2 contains approximately 33,250 sequences with lengths between 65 and 128 nt. + +The basic workflow does not require additional dataset downloads or precomputed features. + +### Optional Dependencies + +`requirements.txt` includes XGBoost, ViennaRNA, logomaker, ruptures, and cliffs-delta for G4-related and downstream analysis scripts. + +NUPACK is used only by optional MFE preprocessing scripts. + +Because NUPACK 4 must be obtained and installed separately according to the licensing and installation requirements of its publisher, it is not automatically installed through standard PyPI dependencies in this model package. + +NUPACK is not required for: + +- Basic inference; +- MRL ranking; +- TE ranking; +- WGAN-GP training. + +### Quick Inference + +Use the official pretrained WGAN to generate candidate sequences and rank them independently by MRL and TE. + +**Purpose:** Generate 5′ UTR candidates in batches on DCU and output separate MRL and TE ranking results. + +```bash +python scripts/predict.py \ + --device dcu \ + --device-id 0 \ + --num-candidates 1024 \ + --batch-size 128 \ + --seed 33 \ + --output-dir outputs/pretrained_batch_ranking +``` + +The results are saved to: + +```text +outputs/pretrained_batch_ranking/ +├── all_candidates_scores.csv +├── ranked_by_mrl.csv +├── ranked_by_te.csv +├── generator_probabilities.npy +└── summary.json +``` + +The output files contain: + +- `all_candidates_scores.csv`: all candidate sequences together with their MRL and TE prediction scores; +- `ranked_by_mrl.csv`: candidates ranked from highest to lowest MRL score; +- `ranked_by_te.csv`: candidates ranked from highest to lowest TE score; +- `is_duplicate`: indicates whether a generated sequence is duplicated; +- MRL and TE are measured on different scales and their raw scores should not be directly added together. + +### MRL-Directed Optimization + +**Purpose:** Freeze the WGAN and FramePool models and optimize the latent noise to increase the predicted MRL score of generated candidates. + +```bash +python scripts/optimize_te_mrl.py \ + -gpu 0 \ + -task mrl \ + -bs 64 \ + -s 10 \ + --output-dir outputs/optimization_mrl +``` + +During this process, the WGAN and FramePool model weights remain frozen. Only the latent noise is updated. + +### TE-Directed Optimization + +**Purpose:** Freeze the WGAN and MTtrans models and optimize the latent noise to increase the predicted TE score of generated candidates. + +```bash +python scripts/optimize_te_mrl.py \ + -gpu 0 \ + -task te \ + -bs 64 \ + -s 10 \ + --output-dir outputs/optimization_te +``` + +During this process, the WGAN and MTtrans model weights remain frozen. + +Therefore, this workflow is latent-space optimization rather than fine-tuning of the pretrained models. + +### Training + +UTRGAN supports WGAN-GP training. + +The trainable components in this workflow are: + +- Generator; +- Critic. + +Xpresso, FramePool, and MTtrans do not participate in this training entry point. + +To run one epoch using the complete data-processing pipeline and the UTRdb2 dataset included in the repository: + +```bash +python scripts/train.py \ + -gpu 0 \ + -bs 64 \ + -lr 5 \ + -mxl 128 \ + -dim 40 \ + --epochs 1 \ + --output-dir outputs/train_1epoch +``` + +According to the upstream README, `-lr 5` corresponds to a learning rate of: + +```text +1e-5 +``` + +The adapted training entry point adds the `--epochs` argument and corrects the learning-rate expression in the upstream script so that it is consistent with the documented definition. + +To run the full upstream training configuration, use the complete UTRdb2 training dataset for 4000 epochs: + +```bash +python scripts/train.py \ + -gpu 0 \ + -bs 64 \ + -lr 5 \ + -mxl 128 \ + -dim 40 \ + --epochs 4000 \ + --output-dir outputs/train_full +``` + +This retrains the WGAN-GP Generator and Critic. + +Full training can require substantial runtime. Training progress should be evaluated according to available accelerator resources and training logs. + +Generated checkpoints are saved in the specified output directory and do not overwrite the official pretrained weights under: + +```text +weight/ +``` + +# OneScience Official Resources + +| Platform | OneScience Main Repository | Skills Repository | +| --- | --- | --- | +| Gitee | [OneScience](https://gitee.com/onescience-ai/onescience) | [OneSkills](https://gitee.com/onescience-ai/oneskills) | +| GitHub | [OneScience](https://github.com/onescience-ai/OneScience) | [OneSkills](https://github.com/onescience-ai/oneskills) | + +# Citation and License + +- Upstream implementation: https://github.com/ciceklab/UTRGAN +- Xpresso: https://github.com/vagarwal87/Xpresso +- FramePool: https://github.com/Karollus/5UTR +- MTtrans: https://github.com/holab-hku/MTtrans +- The upstream UTRGAN project is distributed under the [CC BY-NC-SA 2.0](https://creativecommons.org/licenses/by-nc-sa/2.0/) license and is intended for academic and non-commercial use. Commercial use requires permission from the upstream authors. +- Third-party models, datasets, pretrained weights, and software components remain subject to their respective original licenses and terms of use. +- The DCU adaptation in this repository continues to use the same CC BY-NC-SA 2.0 license. \ No newline at end of file diff --git a/conf/analysis/G4.ipynb b/conf/analysis/G4.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..101c54eaf4d57ee7b1d8c029699bca81038380b4 --- /dev/null +++ b/conf/analysis/G4.ipynb @@ -0,0 +1,451 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#!/usr/bin/env python\n", + "\n", + "import re\n", + "import sys\n", + "import string\n", + "import argparse\n", + "import operator\n", + "import pandas as pd\n", + "import xgboost as xgb\n", + "import numpy as np\n", + "\n", + "VERSION='0.1.0'\n", + "\n", + "parser = argparse.ArgumentParser(description=\"\"\"\n", + "\n", + "DESCRIPTION\n", + "\n", + "EXAMPLE:\n", + "\n", + " \"\"\", formatter_class= argparse.RawTextHelpFormatter)\n", + "\n", + "parser.add_argument('--fasta', '-f',\n", + " type= str,\n", + " help='''Input fasta file to search. Use '-' to read the file from stdin.\n", + " \n", + " ''',default='./seq.fasta',\n", + " required= True)\n", + "\n", + "parser.add_argument('--classifier',\n", + " required= False,\n", + " default= 'G4Boost_classifier.json',\n", + " help='''Use specified classifier (G4Boost_classifier.sav)\n", + " ''')\n", + "parser.add_argument('--regressor',\n", + " required= False,\n", + " default= 'G4Boost_regressor.json',\n", + " help='''Use specified classifier (G4Boost_regressor.sav)\n", + " ''')\n", + "parser.add_argument('--maxloop', '-N',\n", + " type= int,\n", + " required= False,\n", + " default= 12,\n", + " help='''Maximum length of the loop. Default is to report up to 12nt.\n", + " ''')\n", + "parser.add_argument('--minloop', '-n',\n", + " type= int,\n", + " required= False,\n", + " default= 1,\n", + " help='''Minimum length of the loop. Default is to report up to 1nt.\n", + " ''')\n", + "parser.add_argument('--maxG', '-G',\n", + " type= int,\n", + " required= False,\n", + " default= 7,\n", + " help='''Maximum number of consecutive G bases within a G-stem. Default is to report up to 7 Gs.\n", + " ''')\n", + "parser.add_argument('--minG', '-g',\n", + " type= int,\n", + " required= False,\n", + " default= 2,\n", + " help='''Maximum number of consecutive G bases within a G-stem. Default is to report up to 1 Gs.\n", + " ''')\n", + "parser.add_argument('--loops', '-l',\n", + " type= int,\n", + " required= False,\n", + " default= 11,\n", + " help='''Maximum number of flexible loops separating the G-stems. Default is to report up to 11 Gs.\n", + " ''')\n", + "\n", + "parser.add_argument('--noreverse',\n", + " action= 'store_true',\n", + " help='''Do not search the reverse complement of the input fasta.\n", + " ''')\n", + "\n", + "parser.add_argument('--quiet', '-q',\n", + " action= 'store_true',\n", + " help='''Do not print progress report (i.e. sequence names as they are scanned). \n", + " ''')\n", + "\n", + "parser.add_argument('--version', '-v', action='version', version='%(prog)s ' + VERSION)\n", + "args = parser.parse_args()\n", + "\n", + "\n", + "\" ------------------------------[ Functions ]--------------------------------- \"\n", + "\n", + "def sort_table(table, cols):\n", + " for col in reversed(cols):\n", + " table = sorted(table, key=operator.itemgetter(col))\n", + " return(table)\n", + "\n", + "\n", + "def chrom_name(header):\n", + " if not header.startswith('>'):\n", + "# raise Exception('FASTA header does not start with \">\":\\n%s' % header)\n", + " return 'noID'\n", + " chr= re.sub('^>\\s*', '', header)\n", + " chr= re.sub('\\s.*', '', chr)\n", + " return chr\n", + "\n", + "def revcomp(seq):\n", + " complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A', 'U': 'A', 'N': 'N'}\n", + " return \"\".join(complement.get(base, base) for base in reversed(seq))\n", + "\n", + "\n", + "def findall(seq, search):\n", + " count=-1\n", + " loc= 0\n", + " newloc=0\n", + " while newloc > -1:\n", + " newloc=seq[loc:].find(search)\n", + " loc=loc+newloc+1\n", + " count+=1\n", + " return count\n", + "\n", + "def initialize_dataFrame():\n", + " header=[\"seq\", \"seq_length\", \"g4motif\", 'maxgbase', 'maxgstem', \"length\", \"maxlbase\", \"minlbase\", \"G\", \"C\", \"GG\", \"CC\"]\n", + " data_dict={}\n", + " for h in header:\n", + " data_dict[h]=[]\n", + " return data_dict\n", + "\n", + "def topology(reg, seq):\n", + " split_seq=re.split(reg, seq)\n", + " if len(split_seq[-1])==0: gstem_base=split_seq[-2]\n", + " else: gstem_base=split_seq[-1]\n", + " g=len(gstem_base)\n", + " loops=[len(sp_seq)-g for sp_seq in split_seq]\n", + " loops=[lbase for lbase in loops if lbase>0]\n", + " maxlbase=max(loops)\n", + " minlbase=min(loops)\n", + " test=gstem_base\n", + " for sp_seq in split_seq:\n", + " if len(sp_seq)>g:\n", + " test+=sp_seq[g:].lower()\n", + " test+=gstem_base\n", + " return [test, len(test), len(loops)+1, g, maxlbase, minlbase]\n", + "\n", + "def update_dataFrame(features, reg, seq, ref):\n", + " [test, length, maxgstem, maxgbase, maxlbase, minlbase] = topology(reg, seq)\n", + " features['g4motif'].append(test)\n", + " features['length'].append(length)\n", + " features['seq_length'].append(len(ref))\n", + " features['maxgstem'].append(maxgstem)\n", + " features['maxgbase'].append(maxgbase)\n", + " features['maxlbase'].append(maxlbase)\n", + " features['minlbase'].append(minlbase)\n", + " features['G'].append(int(findall(ref,'G')*100/len(ref)))\n", + " features['GG'].append(int(findall(ref,'GG')*100/len(ref)))\n", + " features['C'].append(int(findall(ref,'C')*100/len(ref)))\n", + " features['CC'].append(int(findall(ref,'CC')*100/len(ref)))\n", + " return features\n", + "\n", + "\n", + "def findmotifs(reg, seq, start):\n", + " gquad_list=[]\n", + " for m in re.finditer(reg, seq):\n", + " seq= m.group(0)\n", + " quad_id= chrom + '_' + str(m.start()+start) + '_' + str(m.end()+start)\n", + " gquad_list.append([chrom, m.start()+start, m.end()+start, quad_id, len(m.group(0)), '+', seq])\n", + " return gquad_list\n", + "# -----------------------------------------------------------------------------\n", + "\n", + "\n", + "if args.fasta != '-':\n", + " ref_seq_fh= open(args.fasta)\n", + " output= args.fasta+'.gff'\n", + "else:\n", + " ref_seq_fh= sys.stdin\n", + " output='G4Boost_quadruplexes.gff'\n", + "\n", + "# ref_seq=[]\n", + "# line= ref_seq_fh.readline()\n", + "# if chrom != 'noID': line= ref_seq_fh.readline()\n", + "# else: chrom = line.strip()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import re\n", + "import sys\n", + "import string\n", + "import argparse\n", + "import operator\n", + "import pandas as pd\n", + "import xgboost as xgb\n", + "import numpy as np\n", + "\n", + "def predict(seqs,):\n", + " gquad_list= []\n", + "# eof= False\n", + "\n", + "\n", + "\n", + "#if args.fasta != '-': output= args.fasta+'.gff'\n", + "#else: output = 'G4Boost_quadruplexes.gff'\n", + "#out=open(output, 'w')\n", + "\n", + "\n", + " sys.stderr.write('Starting stability prediction!\\n\\n')\n", + " regressor = xgb.XGBRegressor()\n", + " classifier = xgb.XGBClassifier()\n", + " regressor.load_model(args.regressor)\n", + " classifier.load_model(args.classifier)\n", + " preds = []\n", + " all_features = []\n", + " for i in range(len(seqs)):\n", + " chrom = str(i)\n", + " gb=range(args.minG, args.maxG+1)[::-1]\n", + " gs=range(3, args.loops+1)[::-1]\n", + " longest = (args.maxG + args.maxloop) * args.loops + args.maxG\n", + " features=initialize_dataFrame()\n", + " ref_seq = seqs[i]\n", + " # ref_seq= ''.join(ref_seq)\n", + " ref_seq=ref_seq.upper().replace('U', 'T')\n", + " rev_ref_seq=revcomp(ref_seq)\n", + " seqlen= len(ref_seq)\n", + " for g in gb:\n", + " for s in gs:\n", + " gstem_base=''\n", + " for i in range(g): gstem_base+=\"G\"\n", + " reg=\"\"\n", + " for i in range(s): reg+='([gG]{%d}\\w{%d,%d})' % (g , args.minloop, args.maxloop)\n", + " reg+='([gG]{%d})' % (g)\n", + " for m in re.finditer(reg, ref_seq):\n", + " seq= m.group(0)\n", + " start=m.start()\n", + " end=m.end()\n", + " if len(ref_seq) > longest: ref = seq\n", + " else: ref = ref_seq\n", + " quad_id= chrom + '_' + str(m.start()) + '_' + str(m.end())\n", + " gquad_list.append([chrom, start, end, quad_id, len(seq), '+', seq])\n", + " if seq not in features['g4motif']:\n", + " features = update_dataFrame(features, reg, seq, ref)\n", + " features['seq'].append(chrom)\n", + " temp=''\n", + " for i in range(start,end): temp+='N'\n", + " ref_seq=ref_seq[:start]+temp+ref_seq[end:]\n", + " if args.noreverse is False:\n", + " for m in re.finditer(reg, rev_ref_seq):\n", + " seq= m.group(0)\n", + " start=m.start()\n", + " end=m.end()\n", + " if len(rev_ref_seq) > longest: ref = seq\n", + " else: ref = rev_ref_seq\n", + " quad_id= chrom + '_' + str(m.start()) + '_' + str(m.end())\n", + " gquad_list.append([chrom, seqlen-end, seqlen-start, quad_id, len(seq), '-', seq])\n", + " if seq not in features['g4motif']:\n", + " features = update_dataFrame(features, reg, seq, ref)\n", + " features['seq'].append(chrom)\n", + " temp=''\n", + " for i in range(start,end): temp+='N'\n", + " rev_ref_seq=rev_ref_seq[:start]+temp+rev_ref_seq[end:]\n", + " gquad_sorted= sort_table(gquad_list, (1,2,3))\n", + " gquad_list= []\n", + " for xline in gquad_sorted:\n", + " xline= '\\t'.join([str(x) for x in xline])\n", + " with open(output, 'a') as out: out.write(xline+'\\n')\n", + "\n", + "\n", + " #---------------\n", + "\n", + "\n", + "\n", + "\n", + " selected=[\"seq_length\", \"length\", \"maxgstem\" ,\"maxgbase\", \"maxlbase\", \"minlbase\", \"G\", \"C\", \"GG\", \"CC\"]\n", + " # print(features)\n", + " # del features['G-quartet']\n", + " # del features['loops']\n", + " features=pd.DataFrame.from_dict(features)\n", + " X_test = features[selected]\n", + "\n", + " X_test.columns = [\"length\", \"len\", \"maxgstem\", \"maxgbase\", \"maxlbase\", \"minlbase\", \"G\", \"C\", \"GG\", \"CC\"]\n", + "\n", + " # print(X_test)\n", + "\n", + "\n", + " # X_test=xgb.DMatrix(X_test)\n", + " g4_pred=classifier.predict(X_test)\n", + " if len(g4_pred) < 1:\n", + " preds.append(0)\n", + " else:\n", + " g4_pred_proba=classifier.predict_proba(X_test)[:, 1]\n", + " mfe_pred = regressor.predict(X_test)\n", + " if np.max(g4_pred_proba) < 0.5:\n", + " preds.append(0)\n", + " else:\n", + " preds.append(1)\n", + " # features['g4_pred']=g4_pred\n", + " # features['g4_prob']=g4_pred_proba\n", + " # features['mfe_pred']=mfe_pred\n", + " # features['maxgstem']=[l-1 for l in features['maxgstem']]\n", + "\n", + " # if args.fasta != '-': output= args.fasta+'.g4scores.csv'\n", + " # else: output = 'G4Boost_quadruplexes.g4.csv'\n", + " # features.to_csv(output,sep='\\t',index=False)\n", + "\n", + "\n", + " # print(float(np.sum(preds))/len(preds))\n", + " return preds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from Bio import SeqIO\n", + "import pandas as pd\n", + "import sys\n", + "\n", + "# read generated\n", + "lines = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/1024_10000_init.fasta','fasta'):\n", + " lines.append(str(record.seq))\n", + "\n", + "mut_inits = []\n", + "for i in range(len(lines)):\n", + " mut_inits.append(lines[i].replace('\\n','')[:50])\n", + "\n", + "\n", + "# read optimus\n", + "optimus = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/optimus_fasta.fasta','fasta'):\n", + " optimus.append(str(record.seq))\n", + "\n", + "\n", + "# read generated\n", + "inits = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/1024_10000_init.fasta','fasta'):\n", + " inits.append(str(record.seq))\n", + "\n", + "opts = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/1024_10000_opt.fasta','fasta'):\n", + " opts.append(str(record.seq))\n", + "\n", + "\n", + "# read natural:\n", + "df = pd.read_csv('./../UTRGAN/data/utrdb2.csv')\n", + "df = df['seq'].to_numpy()\n", + "nats = []\n", + "for i in range(len(df)):\n", + " if len(df[i])< 129 and len(df[i]) > 64:\n", + " nats.append(df[i].replace('T','U'))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Starting stability prediction!\n", + "\n", + "/var/anaconda3/envs/tf25/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:44:31] WARNING: /croot/xgboost-split_1713972711803/work/cpp_src/src/learner.cc:873: Found JSON model saved before XGBoost 1.6, please save the model using current version again. The support for old JSON model will be discontinued in XGBoost 2.3.\n", + " warnings.warn(smsg, UserWarning)\n", + "/var/anaconda3/envs/tf25/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:44:32] WARNING: /croot/xgboost-split_1713972711803/work/cpp_src/src/learner.cc:873: Found JSON model saved before XGBoost 1.6, please save the model using current version again. The support for old JSON model will be discontinued in XGBoost 2.3.\n", + " warnings.warn(smsg, UserWarning)\n", + "Starting stability prediction!\n", + "\n", + "/var/anaconda3/envs/tf25/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:54:47] WARNING: /croot/xgboost-split_1713972711803/work/cpp_src/src/learner.cc:873: Found JSON model saved before XGBoost 1.6, please save the model using current version again. The support for old JSON model will be discontinued in XGBoost 2.3.\n", + " warnings.warn(smsg, UserWarning)\n", + "Starting stability prediction!\n", + "\n", + "/var/anaconda3/envs/tf25/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:55:05] WARNING: /croot/xgboost-split_1713972711803/work/cpp_src/src/learner.cc:873: Found JSON model saved before XGBoost 1.6, please save the model using current version again. The support for old JSON model will be discontinued in XGBoost 2.3.\n", + " warnings.warn(smsg, UserWarning)\n", + "Starting stability prediction!\n", + "\n", + "/var/anaconda3/envs/tf25/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:55:24] WARNING: /croot/xgboost-split_1713972711803/work/cpp_src/src/learner.cc:873: Found JSON model saved before XGBoost 1.6, please save the model using current version again. The support for old JSON model will be discontinued in XGBoost 2.3.\n", + " warnings.warn(smsg, UserWarning)\n", + "Starting stability prediction!\n", + "\n", + "/var/anaconda3/envs/tf25/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:55:33] WARNING: /croot/xgboost-split_1713972711803/work/cpp_src/src/learner.cc:873: Found JSON model saved before XGBoost 1.6, please save the model using current version again. The support for old JSON model will be discontinued in XGBoost 2.3.\n", + " warnings.warn(smsg, UserWarning)\n" + ] + } + ], + "source": [ + "nat_pred = predict(nats)\n", + "init_pred = predict(inits)\n", + "opt_pred = predict(opts)\n", + "optimus_pred = predict(optimus)\n", + "mut_init_pred = predict(mut_inits)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "236.76727819548873\n", + "209\n", + "199\n", + "16\n", + "162\n" + ] + } + ], + "source": [ + "print(np.sum(nat_pred)/len(nat_pred)*1024.)\n", + "print(np.sum(init_pred))\n", + "print(np.sum(opt_pred))\n", + "print(np.sum(optimus_pred))\n", + "print(np.sum(mut_init_pred))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tf25", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/conf/analysis/align/mut_inits.npy b/conf/analysis/align/mut_inits.npy new file mode 100644 index 0000000000000000000000000000000000000000..0a238d3a471012f01e040fd36870c8015b5354f9 --- /dev/null +++ b/conf/analysis/align/mut_inits.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b4defe5aaf89c16f10cea7e90f3037e896bbbb4b572afdaebac1438a412aa726 +size 8320 diff --git a/conf/analysis/align/seq_init.npy b/conf/analysis/align/seq_init.npy new file mode 100644 index 0000000000000000000000000000000000000000..36ff620cf43a77864ef780e0d4b9ddaaa838c433 --- /dev/null +++ b/conf/analysis/align/seq_init.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:efaa32e7cbf675db8218633a8fab7fc73c4f050ac6ee2fe36edace02353c1326 +size 640 diff --git a/conf/analysis/align/seq_mutated.npy b/conf/analysis/align/seq_mutated.npy new file mode 100644 index 0000000000000000000000000000000000000000..537010964e66140f7d949fe463f00a16d2fd0769 --- /dev/null +++ b/conf/analysis/align/seq_mutated.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e4d39a4eb211f507b4c13a765408cb5e988a69c65dd79ce492cb7a64237a04b +size 8320 diff --git a/conf/analysis/align/seq_opt.npy b/conf/analysis/align/seq_opt.npy new file mode 100644 index 0000000000000000000000000000000000000000..63eadf90e6c5aa5dd180ba69ca065b5b7d8edbdb --- /dev/null +++ b/conf/analysis/align/seq_opt.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd28b83a5c3d4a43e4bfc0173ea6322a7760e1bb5947803a6f0f8ac9aa1ea03d +size 640 diff --git a/conf/analysis/files/gen_4mer_new.npy b/conf/analysis/files/gen_4mer_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..d02af58404c97cd42fd66caee27d5bcf2348f6bf --- /dev/null +++ b/conf/analysis/files/gen_4mer_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3019b9b6e6494f58f219d36e32057046b6562ce91163e90b90543798af958edb +size 4224 diff --git a/conf/analysis/files/gen_ham_new.npy b/conf/analysis/files/gen_ham_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..59317f9bc29ef461ecadd36d5ac59b90367138df --- /dev/null +++ b/conf/analysis/files/gen_ham_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:863ff673d30298635c6c9811045748dbdc0c41c784365bf93823cbb5205a1d52 +size 16512 diff --git a/conf/analysis/files/opt_4mer_new.npy b/conf/analysis/files/opt_4mer_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..e800f238acba018f94cacde81133f36318e1739c --- /dev/null +++ b/conf/analysis/files/opt_4mer_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cad973fbfcec1714669b0eb77ca9e88eb172bf49ac13a174c7ffda9835fe7139 +size 8320 diff --git a/conf/analysis/files/opt_ham_new.npy b/conf/analysis/files/opt_ham_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..31702522943a7f4394c47507272e7a0bff986db7 --- /dev/null +++ b/conf/analysis/files/opt_ham_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4bb77a899716eaf15d8a849558195574d86b0ef672ec544a9f67b5da4c0849f +size 8320 diff --git a/conf/analysis/files/rand_4mer_new.npy b/conf/analysis/files/rand_4mer_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..0688bf567c33169ced09273432eb92318572b819 --- /dev/null +++ b/conf/analysis/files/rand_4mer_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:567b6ec5148cff4676f246450656cf821e8614181a197897b7503b8b13f30153 +size 4224 diff --git a/conf/analysis/files/rand_ham_new.npy b/conf/analysis/files/rand_ham_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..029a5777af0e01c7dc77ccdf60d885a2516d85cb --- /dev/null +++ b/conf/analysis/files/rand_ham_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b682a172394378c81d433766374f0cac005591113476b50340faff18606f9079 +size 16512 diff --git a/conf/analysis/files/real_4mer_new.npy b/conf/analysis/files/real_4mer_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..88d8543a2b55aec9a598fe4a2189d7ce5eb3dac6 --- /dev/null +++ b/conf/analysis/files/real_4mer_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba1484b28c87d4145476af7e31e6b0d4bd17d29c38fc0bddf598e25f28ebc2b9 +size 4224 diff --git a/conf/analysis/files/real_ham_new.npy b/conf/analysis/files/real_ham_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..4c717ab354f62ed1d30a07f324d1e9088ea19150 --- /dev/null +++ b/conf/analysis/files/real_ham_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e4a0c44f28a53700e74655d71303158df9c3491fa2fb91cdb2bc8f8ec067bc1e +size 16512 diff --git a/conf/analysis/files/te_gens.npy b/conf/analysis/files/te_gens.npy new file mode 100644 index 0000000000000000000000000000000000000000..658217a11de8126ce82775a0bfb78fb925d8d155 --- /dev/null +++ b/conf/analysis/files/te_gens.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5123558dca0ee55109001effc674d49a24a4e9ac6ad4414312b4c963cb7c75c5 +size 8320 diff --git a/conf/analysis/files/te_optimized.npy b/conf/analysis/files/te_optimized.npy new file mode 100644 index 0000000000000000000000000000000000000000..e7f7dd3748f897525e40fb53bd1d3d6d4c9f034b --- /dev/null +++ b/conf/analysis/files/te_optimized.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:965402fd8be6ae2b52f6247524dc5987fe34f098482a73be0b02ff9e37764cfa +size 4224 diff --git a/conf/analysis/files/te_optimus.npy b/conf/analysis/files/te_optimus.npy new file mode 100644 index 0000000000000000000000000000000000000000..7d2fc0c70eaa326a36d7b16318b2b1612813ddce --- /dev/null +++ b/conf/analysis/files/te_optimus.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6af8f80b7dd9b17ada1e83234e19a105321b5b3f3fb1e79ef99ac1e14a0469a +size 4224 diff --git a/conf/analysis/files/te_rands.npy b/conf/analysis/files/te_rands.npy new file mode 100644 index 0000000000000000000000000000000000000000..633cd804453711355675b6fcc84f2a0c31ee146d --- /dev/null +++ b/conf/analysis/files/te_rands.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9afb713954378a127aa7d223bbd2d7c2547d5a4f4faaf5cd0fd68f4f6de7808e +size 8320 diff --git a/conf/analysis/files/te_reals.npy b/conf/analysis/files/te_reals.npy new file mode 100644 index 0000000000000000000000000000000000000000..eb63484d54549bb4256cdee3047ea99aa7f8b7af --- /dev/null +++ b/conf/analysis/files/te_reals.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:185aadd3b234d3735d198ea1a0adc1b741396c6b09b62cab9054000d5b88f1ed +size 133128 diff --git a/conf/analysis/mrl_te_opt.py b/conf/analysis/mrl_te_opt.py new file mode 100644 index 0000000000000000000000000000000000000000..a7f87d7bf94d1c06e4541c9e273f9c9a2cdd6169 --- /dev/null +++ b/conf/analysis/mrl_te_opt.py @@ -0,0 +1,186 @@ +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import seaborn as sns +import argparse + +sns.set() +sns.set_style('ticks') + +colors = ["#3c5068", "#acbab6", "#dcd3cd", "#d4a6a6"] + +params = {'legend.fontsize': 32, + 'figure.figsize': (32, 10), + 'axes.labelsize': 34, + 'axes.titlesize':34, + 'xtick.labelsize':34, + 'ytick.labelsize':24} + +#POSTER +params = {'legend.fontsize': 50, + 'figure.figsize': (54, 18), + 'axes.labelsize': 60, + 'axes.titlesize':60, + 'xtick.labelsize':60, + 'ytick.labelsize':36} + +plt.rcParams.update(params) + + +np.random.seed(25) + + +DISPLAY_DIFF = True + +K = 100 + +PREFIX = '' + +# MRL, TE + +TYPE = 'MRL' + +DISPLAY_DIFF = True + +if TYPE == 'REGULAR': + PREFIX = 'outputs/' +elif TYPE == 'MIXED': + PREFIX = 'outputs_mixed/' +elif TYPE == 'GC_CONTROLED': + PREFIX = 'outputs/gc_' + +if DISPLAY_DIFF: + TYPE = 'MMRL' + TITLE = "A" + + init = [] + with open(f'./../src/mrl_te_optimization/outputs/init_mrl_FMRL.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + + opt = [] + with open(f'./../src/mrl_te_optimization/outputs/opt_mrl_FMRL.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + + + init = np.array(init) + opt = np.array(opt) + + diffs = (opt - init)/init + + print("FramePool MRL optimization:") + print(f"Average Opt: {np.average(opt)}") + print(f"Average Init: {np.average(init)}") + print(f"Max Opt: {np.max(opt)}") + print(f"Max Init: {np.max(init)}") + print(f"Max Increase (wrt Init) : {np.max(opt/init)}") + print(f"Average Increase (wrt Init) : {np.mean(opt/init)}") + print(f"Average Percent Increase (wrt Init): {np.average(diffs)}") + + indices = np.argsort(opt)[::-1] + + init_large = [] + init_small = [] + opt_large = [] + opt_small = [] + + for i in range(len(indices)): + if diffs[indices[i]] >= 0: + init_small.append(init[indices[i]]) + init_large.append(0) + opt_small.append(0) + opt_large.append(opt[indices[i]]) + else: + init_large.append(init[indices[i]]) + init_small.append(0) + opt_large.append(0) + opt_small.append(opt[indices[i]]) + + width = 1.0/(len(indices)) + bins = [(i+1) * width for i in range(len(indices))] + + ns = [i * width for i in range(len(indices))] + fig, axs = plt.subplots(1,2) + + axs[0].bar(x=ns, bottom=0, width=width, height=opt_large, color=colors[0], edgecolor="white") + axs[0].bar(x=ns, bottom=0, width=width, height=opt_small, color=colors[0], edgecolor="white") + axs[0].bar(x=ns, bottom=0, width=width, height=init_small, color=colors[3], edgecolor="white") + axs[0].bar(x=ns, bottom=0, width=width, height=init_large, color=colors[3], edgecolor="white") + + axs[0].set_title(TITLE,loc='left',weight='bold',fontsize=64) + axs[0].set_xticks([]) + + TYPE = "FMRL" + TITLE = "B" + + init = [] + + with open(f'./../src/mrl_te_optimization/outputs/init_mrl_TE.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + + opt = [] + with open(f'./../src/mrl_te_optimization/outputs/opt_mrl_TE.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + + + init = np.power(10,init) + init = np.array(init) + opt = np.power(10,opt) + opt = np.array(opt) + + diffs = (opt - init)/init + + print("MTtrans 3R TE optimization:") + print(f"Average Opt: {np.average(opt)}") + print(f"Average Init: {np.average(init)}") + print(f"Max Opt: {np.max(opt)}") + print(f"Max Init: {np.max(init)}") + print(f"Max Increase (wrt Init) : {np.max(opt/init)}") + print(f"Average Increase (wrt Init) : {np.mean(opt/init)}") + print(f"Max Increase (wrt Natural) : {np.max(opt/np.power(10,-0.63))}") + print(f"Average Percent Increase (wrt Init): {np.average(diffs)}") + + indices = np.argsort(opt)[::-1] + + init_large = [] + init_small = [] + opt_large = [] + opt_small = [] + + for i in range(len(indices)): + if diffs[indices[i]] >= 0: + init_small.append(init[indices[i]]) + init_large.append(0) + opt_small.append(0) + opt_large.append(opt[indices[i]]) + else: + init_large.append(init[indices[i]]) + init_small.append(0) + opt_large.append(0) + opt_small.append(opt[indices[i]]) + + axs[1].bar(x=ns, bottom=0, width=width, height=opt_large, color=colors[0], edgecolor="white") + axs[1].bar(x=ns, bottom=0, width=width, height=opt_small, color=colors[0], edgecolor="white") + axs[1].bar(x=ns, bottom=0, width=width, height=init_small, color=colors[3], edgecolor="white") + axs[1].bar(x=ns, bottom=0, width=width, height=init_large, color=colors[3], edgecolor="white") + axs[1].set_title(TITLE,loc='left',weight='bold',fontsize=64) + axs[1].set_xticks([]) + + orange_patch = mpatches.Patch(color=colors[3], label='Initial') + blue_patch = mpatches.Patch(color=colors[0], label='Optimized') + fig.legend(handles=[orange_patch,blue_patch],loc='upper right') + + axs[0].set_ylabel('Predicted MRL') + axs[1].set_ylabel('Predicted TE') + + axs[0].set_xlabel('UTR Samples') + axs[1].set_xlabel('UTR Samples') + + fig.tight_layout() + + plt.savefig(f'./plots/mrl_te_all.png') + + diff --git a/conf/analysis/opt_check.py b/conf/analysis/opt_check.py new file mode 100644 index 0000000000000000000000000000000000000000..793e050912d38ab5be53dc7710288234824e139e --- /dev/null +++ b/conf/analysis/opt_check.py @@ -0,0 +1,262 @@ +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import seaborn as sns +import os +import argparse +sns.set() +sns.set_style('ticks') + + +params = {'legend.fontsize': 50, + 'figure.figsize': (54, 27), + 'axes.labelsize': 60, + 'axes.titlesize':60, + 'xtick.labelsize':60, + 'ytick.labelsize':36} + + +plt.rcParams.update(params) + +os.environ["CUDA_VISIBLE_DEVICES"] = '2' + +fig, axs = plt.subplots(2,3) + +colors = ["#3c5068", "#acbab6", "#dcd3cd", "#d4a6a6"] + +init = [] +with open(f'./../src/mrl_te_optimization/outputs/init_mrl_TE.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + +opt = [] +with open(f'./../src/mrl_te_optimization/outputs/opt_mrl_TE.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + +init = np.array(init) +opt = np.array(opt) + +init = np.power(10,init) +opt = np.power(10,opt) + +SORT_INIT = False + +if SORT_INIT: + + min_init_indices = np.argsort(init) + init = init[min_init_indices[:min(int(len(init)),100)]] + opt = opt[min_init_indices[:min(int(len(opt)),100)]] +else: + init = init[:min(int(len(init)),100)] + opt = opt[:min(int(len(opt)),100)] + +diffs = [(opt[i]-init[i]) for i in range(len(init))] + +count = 0 +for i in range(len(diffs)): + if diffs[i] < 0: + count += 1 + +print(count) + +print(np.average(init)) +print(np.average(opt)) +print(np.max(diffs/init)) +print(np.average(diffs/init)) + +indices_sorted = np.argsort(diffs)[::-1] + +diffs = np.sort(diffs)[::-1] + +new_inits = [] + +for i in range(len(diffs)): + new_inits.append(init[indices_sorted[i]]) + +N = min(100, len(diffs)) + +step = 1.0/N + +new_n = [i * step for i in range(N)] + +width = step + +plt.rcParams.update({'font.size': 12}) + + +print(len(diffs)) + +axs[0,1].bar(x=new_n, bottom=0, width=width, height=diffs,color=colors[0]) +axs[0,1].set_xticks([]) +axs[0,1].set_ylabel('TE Change') +axs[0,1].set_title('B',weight='bold',fontsize=60,loc='left') + +axs[1,1].bar(x=new_n, bottom=0, width=width, height=new_inits,color=colors[3]) +axs[1,1].set_xticks([]) +axs[1,1].set_xlabel('UTR Samples') +axs[1,1].set_ylabel('Initial TE') +axs[1,1].set_title('E',weight='bold',fontsize=60,loc='left') + +init = [] +with open('./../src/exp_optimization/outputs/mul_init_exps.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + +opt = [] +with open('./../src/exp_optimization/outputs/mul_opt_exps.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + +init = np.array(init) +opt = np.array(opt) + +init = np.power(10,init) +opt = np.power(10,opt) + +print(np.average(init)) +print(np.average(opt)) + +SORT_INIT = True + +if SORT_INIT: + + min_init_indices = np.argsort(init) + init = init[min_init_indices[:min(int(len(init)),100)]] + opt = opt[min_init_indices[:min(int(len(opt)),100)]] +else: + init = init[:min(int(len(init)),100)] + opt = opt[:min(int(len(opt)),100)] + +diffs = [(opt[i]-init[i]) for i in range(len(init))] + +count = 0 +for i in range(len(diffs)): + if diffs[i] < 0: + count += 1 + +print(count) + +print(np.mean(diffs/init)) +# print(diffs) + +indices_sorted = np.argsort(diffs)[::-1] + +print(f"Average Opt: {np.average(opt)}") +print(f"Average Init: {np.average(init)}") +print(f"Max Opt: {np.max(opt)}") +print(f"Max Init: {np.max(init)}") +print(f"Max Increase (wrt Init) : {np.max(opt/init)}") +print(f"Average Increase (wrt Init) : {np.mean(opt/init)}") +print(f"Max Increase (wrt Natural) : {np.max(opt/np.power(10,-0.63))}") + +diffs = (opt - init)/init +print(f"Average Percent Increase (wrt Init): {np.average(diffs)}") + +print(np.max(diffs/init)) + +new_inits = [] + +for i in range(len(diffs)): + new_inits.append(init[indices_sorted[i]]) + +N = min(100, len(diffs)) + +step = 1.0/N + +new_n = [i * step for i in range(N)] + +width = step + +axs[0,0].bar(x=new_n, bottom=0, width=width, height=diffs,color=colors[0]) +axs[0,0].set_xticks([]) +# axs[0,0].set_xlabel('UTR Samples') +axs[0,0].set_ylabel('Log TPM Expression Change') +axs[0,0].set_title('A',weight='bold',fontsize=60,loc='left') + +axs[1,0].bar(x=new_n, bottom=0, width=width, height=init,color=colors[3]) +axs[1,0].set_xticks([]) +axs[1,0].set_xlabel('UTR Samples') +axs[1,0].set_ylabel('Initial TPM Expression') +axs[1,0].set_title('D',weight='bold',fontsize=60,loc='left') + +######## MRL + +init = [] +with open(f'/home/sina/UTR/optimization/mrl/init_mrl_FMRL.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + +opt = [] +with open(f'/home/sina/UTR/optimization/mrl/opt_mrl_FMRL.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + +init = np.array(init) +opt = np.array(opt) + + +SORT_INIT = False + +if SORT_INIT: + + min_init_indices = np.argsort(init) + init = init[min_init_indices[:min(int(len(init)),100)]] + opt = opt[min_init_indices[:min(int(len(opt)),100)]] +else: + init = init[:min(int(len(init)),100)] + opt = opt[:min(int(len(opt)),100)] + +diffs = [(opt[i]-init[i]) for i in range(len(init))] + +count = 0 +for i in range(len(diffs)): + if diffs[i] < 0: + count += 1 + +print(count) + +print(np.average(init)) +print(np.average(opt)) +print(np.max(diffs/init)) +print(np.average(diffs/init)) + +indices_sorted = np.argsort(diffs)[::-1] + +diffs = np.sort(diffs)[::-1] + +new_inits = [] + +for i in range(len(diffs)): + new_inits.append(init[indices_sorted[i]]) + +N = min(100, len(diffs)) + +step = 1.0/N + +new_n = [i * step for i in range(N)] + +width = step + +plt.rcParams.update({'font.size': 12}) + + +print(len(diffs)) + +axs[0,2].bar(x=new_n, bottom=0, width=width, height=diffs,color=colors[0]) +axs[0,2].set_xticks([]) +axs[0,2].set_ylabel('MRL Change') +axs[0,2].set_title('C',weight='bold',fontsize=60,loc='left') + +axs[1,2].bar(x=new_n, bottom=0, width=width, height=new_inits,color=colors[3]) +axs[1,2].set_xticks([]) +axs[1,2].set_xlabel('UTR Samples') +axs[1,2].set_ylabel('Initial MRL') +axs[1,2].set_title('F',weight='bold',fontsize=60,loc='left') + +############# + + +fig.tight_layout() + +plt.savefig('./plots/opt_init_comparison.png') \ No newline at end of file diff --git a/conf/analysis/per_gene_features.py b/conf/analysis/per_gene_features.py new file mode 100644 index 0000000000000000000000000000000000000000..5850b544263e02592e6db3781a7dcebdb7b607f7 --- /dev/null +++ b/conf/analysis/per_gene_features.py @@ -0,0 +1,196 @@ +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +import RNA +from scipy.stats import ttest_ind, mannwhitneyu +from scipy.stats import norm +import os +from matplotlib.patches import Patch +from itertools import product + + +np.random.seed(1337) + + +colors = ["#3c5068", "#acbab6", "#dcd3cd", "#d4a6a6"] +customPalette = {'Initial': colors[0], 'Optimized': colors[3]} + +# Constants +BATCH_SIZE = 2048 +K = 4 + + +params = { + 'legend.fontsize': 40, + 'figure.figsize': (120, 80), + 'axes.labelsize': 120, + 'axes.titlesize': 120, + 'xtick.labelsize': 100, + 'ytick.labelsize': 100 +} +plt.rcParams.update(params) +sns.set() +sns.set_style('ticks') + +def get_gc_content_many(sequences): + gc_contents = [] + for seq in sequences: + gc_count = seq.count('G') + seq.count('C') + gc_contents.append(gc_count / len(seq) if len(seq) > 0 else 0) + return np.array(gc_contents) + +def get_lengths(sequences): + return np.array([len(seq) for seq in sequences]) + + +def get_kmer_frequency(sequences, k=4): + # Generate all possible k-mers + bases = ['A', 'C', 'G', 'T'] + kmers = [''.join(p) for p in product(bases, repeat=k)] + + mean_frequencies = [] + for seq in sequences: + if len(seq) < k: + mean_frequencies.append(0) + continue + # Count occurrences of each k-mer + kmer_counts = {kmer: 0 for kmer in kmers} + for i in range(len(seq) - k + 1): + kmer = seq[i:i+k] + if kmer in kmer_counts: + kmer_counts[kmer] += 1 + # Normalize by number of possible k-mer positions + total_positions = len(seq) - k + 1 + frequencies = [count / total_positions for count in kmer_counts.values() if total_positions > 0] + # Compute mean frequency + mean_freq = np.mean(frequencies) if frequencies else 0 + mean_frequencies.append(mean_freq) + return np.array(mean_frequencies) + + + + +def generate_synthetic_data(num_samples=100): + bases = ['A', 'C', 'G', 'T'] + + sequences = [''.join(np.random.choice(bases, np.random.randint(50, 151))) for _ in range(num_samples)] + return sequences + +# Function to read sequences from .txt file +def read_sequences(file_path): + if os.path.exists(file_path): + with open(file_path, 'r') as f: + sequences = [line.strip() for line in f if line.strip()] + return sequences + else: + print(f"File {file_path} not found, generating synthetic data.") + return generate_synthetic_data(100) + +def analyze_utr_features(file_pairs): + + all_data = [] + + # Process each gene (set of initial and optimized files) + for idx, (initial_path, optimized_path, gene_name) in enumerate(file_pairs, 1): + + initial_seqs = read_sequences(initial_path) + optimized_seqs = read_sequences(optimized_path) + + # Compute features + # Minimum Free Energy (MFE) + initial_mfe = [RNA.fold(seq)[1] for seq in initial_seqs] + optimized_mfe = [RNA.fold(seq)[1] for seq in optimized_seqs] + + # G/C Content + initial_gc = get_gc_content_many(initial_seqs) + optimized_gc = get_gc_content_many(optimized_seqs) + + # Sequence Length + initial_length = get_lengths(initial_seqs) + optimized_length = get_lengths(optimized_seqs) + + # 4-mer Frequency + initial_kmer = 1000*get_kmer_frequency(initial_seqs, k=K) + optimized_kmer = 1000*get_kmer_frequency(optimized_seqs, k=K) + + + + for seq_type, mfe, gc, length, kmer in [ + ('Initial', initial_mfe, initial_gc, initial_length, initial_kmer), + ('Optimized', optimized_mfe, optimized_gc, optimized_length, optimized_kmer) + ]: + for m, g, l, k in zip(mfe, gc, length, kmer): + all_data.append({ + 'Gene': gene_name, + 'Type': seq_type, + 'MFE': m, + 'GC Content': g, + 'Length': l, + '4-mer Frequency': k + }) + + + + df = pd.DataFrame(all_data) + + + fig, axs = plt.subplots(2, 2, figsize=(100, 70)) + + legend_handles = [ + Patch(color=customPalette['Initial'], label='Initial'), + Patch(color=customPalette['Optimized'], label='Optimized') + ] + + # MFE + sns.boxplot(x='Gene', y='MFE', hue='Type', data=df, ax=axs[0, 0], palette=customPalette) + axs[0, 0].get_legend().remove() + axs[0, 0].legend(handles=legend_handles, loc='lower right', fontsize=70, title='Type', title_fontsize=70) + axs[0, 0].set_ylabel("Minimum Free Energy", fontsize=120) + axs[0, 0].set_xlabel("", fontsize=120) + axs[0, 0].set_title('A', weight='bold', fontsize=100, loc='left') + axs[0, 0].tick_params(axis='both', labelsize=100) + + # G/C Content + sns.boxplot(x='Gene', y='GC Content', hue='Type', data=df, ax=axs[0, 1], palette=customPalette) + axs[0, 1].get_legend().remove() + axs[0, 1].legend(handles=legend_handles, loc='lower right', fontsize=70, title='Type', title_fontsize=70) + axs[0, 1].set_ylabel("G/C Content", fontsize=120) + axs[0, 1].set_xlabel("", fontsize=120) + axs[0, 1].set_title('B', weight='bold', fontsize=100, loc='left') + axs[0, 1].tick_params(axis='both', labelsize=100) + + # Length + sns.boxplot(x='Gene', y='Length', hue='Type', data=df, ax=axs[1, 0], palette=customPalette) + axs[1, 0].get_legend().remove() + axs[1, 0].legend(handles=legend_handles, loc='lower right', fontsize=70, title='Type', title_fontsize=70) + axs[1, 0].set_ylabel("Sequence Length", fontsize=120) + axs[1, 0].set_xlabel("", fontsize=120) + axs[1, 0].set_title('C', weight='bold', fontsize=100, loc='left') + axs[1, 0].tick_params(axis='both', labelsize=100) + + # 4-mer Frequency + sns.boxplot(x='Gene', y='4-mer Frequency', hue='Type', data=df, ax=axs[1, 1], palette=customPalette) + axs[1, 1].get_legend().remove() + axs[1, 1].legend(handles=legend_handles, loc='lower right', fontsize=70, title='Type', title_fontsize=70) + axs[1, 1].set_ylabel("Mean 4-mer Frequency", fontsize=120) + axs[1, 1].set_xlabel("", fontsize=120) + axs[1, 1].set_title('D', weight='bold', fontsize=100, loc='left') + axs[1, 1].tick_params(axis='both', labelsize=100) + + + fig.tight_layout(pad=2, rect=[0, 0, 1, 1]) # Adjust for suptitle + + + plt.savefig('./plots/utr_features_boxplots_with_kmer_bottom_right_legends_custom_fonts.png') + plt.close() + + +file_pairs = [ + ('./src/exp_optimization/outputs/gc_best_seqs_IFNG.txt', '/src/exp_optimization/outputs/gc_init_seqs_IFNG.txt', 'IFNG'), + ('/src/exp_optimization/outputs/gc_best_seqs_TLR6.txt', '/src/exp_optimization/outputs/gc_init_seqs_TLR6.txt', 'TLR6'), + ('/src/exp_optimization/outputs/gc_best_seqs_TNF.txt', '/src/exp_optimization/outputs/gc_init_seqs_TNF.txt', 'TNF'), + ('/src/exp_optimization/outputs/gc_best_seqs_TP53.txt', '/src/exp_optimization/outputs/gc_init_seqs_TP53.txt', 'TP53') +] + +analyze_utr_features(file_pairs) \ No newline at end of file diff --git a/conf/analysis/plot_4x4.py b/conf/analysis/plot_4x4.py new file mode 100644 index 0000000000000000000000000000000000000000..e257f1a0b6cffd4450454d1d448a72496de21d98 --- /dev/null +++ b/conf/analysis/plot_4x4.py @@ -0,0 +1,290 @@ +import numpy as np +import matplotlib +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import random +import seaborn as sns +import os +import argparse +sns.set() +sns.set_style('ticks') + +colors = ["#3c5068", "#acbab6", "#dcd3cd", "#d4a6a6"] + + +#POSTER +params = {'legend.fontsize': 50, + 'figure.figsize': (54, 38), + 'axes.labelsize': 60, + 'axes.titlesize':60, + 'xtick.labelsize':60, + 'ytick.labelsize':60} + +plt.rcParams.update(params) + + +np.random.seed(25) + +DISPLAY_DIFF = True + +root_path = './../src/exp_optimization/' + +PREFIX = 'outputs/' + +# MIXED, REGULAR, GC_CONTROLED, MULT + +TYPE = 'GC_CONTROLED' + +DISPLAY_DIFF = True + +if TYPE == 'REGULAR': + PREFIX = 'outputs/' +elif TYPE == 'MIXED': + PREFIX = 'outputs_joint/' +elif TYPE == 'GC_CONTROLED': + PREFIX = 'outputs/gc_' +elif TYPE == 'K562': + PREFIX = 'outputs/K562_' +elif TYPE == 'GM12878': + PREFIX = 'outputs/GM12878_' + +if DISPLAY_DIFF: + parser = argparse.ArgumentParser(description="Gene Expression Optimization Visualization") + + # Add arguments + parser.add_argument("-g", help="a list of gene names separated by comma") + + # Parse the arguments + args = parser.parse_args() + gene_names = args.g.split(',') + + gene_name = gene_names[0] + + init = [] + with open(root_path+PREFIX+'init_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + + opt = [] + with open(root_path+PREFIX+'opt_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + + + init = np.power(10,init) + opt = np.power(10,opt) + diffs = (opt - init)/init + + + + print("####################################################################") + print(f"{gene_name} results:") + print(f"Max Opt: {np.max(opt):.2f}") + print(f"Max Init: {np.max(init):.2f}") + print(f"Average Percent Increase (wrt Init): {np.average(diffs)*100:.2f}") + print(f"Max Percent Increase (wrt Init): {np.max(diffs)*100:.2f}") + + indices = np.argsort(opt)[::-1] + + init_large = [] + init_small = [] + opt_large = [] + opt_small = [] + + for i in range(len(indices)): + if diffs[indices[i]] >= 0: + init_small.append(init[indices[i]]) + init_large.append(0) + opt_small.append(0) + opt_large.append(opt[indices[i]]) + else: + init_large.append(init[indices[i]]) + init_small.append(0) + opt_large.append(0) + opt_small.append(opt[indices[i]]) + + width = 1.0/(len(indices)) + bins = [(i+1) * width for i in range(len(indices))] + + ns = [i * width for i in range(len(indices))] + fig, axs = plt.subplots(2,2) + + + axs[0,0].bar(x=ns, bottom=0, width=width, height=opt_large, color=colors[0], edgecolor="white") + axs[0,0].bar(x=ns, bottom=0, width=width, height=opt_small, color=colors[0], edgecolor="white") + axs[0,0].bar(x=ns, bottom=0, width=width, height=init_small, color=colors[3], edgecolor="white") + axs[0,0].bar(x=ns, bottom=0, width=width, height=init_large, color=colors[3], edgecolor="white") + + axs[0,0].set_title(gene_name,loc='left',style='italic',fontsize=64) + axs[0,0].set_xticks([]) + + gene_name = gene_names[1] + + init = [] + with open(root_path+PREFIX+'init_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + + opt = [] + with open(root_path+PREFIX+'opt_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + + init = np.power(10,init) + opt = np.power(10,opt) + diffs = (opt - init)/init + + print("####################################################################") + print(f"{gene_name} results:") + print(f"Max Opt: {np.max(opt):.2f}") + print(f"Max Init: {np.max(init):.2f}") + print(f"Average Percent Increase (wrt Init): {np.average(diffs)*100:.2f}") + print(f"Max Percent Increase (wrt Init): {np.max(diffs)*100:.2f}") + + indices = np.argsort(opt)[::-1] + + init_large = [] + init_small = [] + opt_large = [] + opt_small = [] + + for i in range(len(indices)): + if diffs[indices[i]] >= 0: + init_small.append(init[indices[i]]) + init_large.append(0) + opt_small.append(0) + opt_large.append(opt[indices[i]]) + else: + init_large.append(init[indices[i]]) + init_small.append(0) + opt_large.append(0) + opt_small.append(opt[indices[i]]) + + axs[0,1].bar(x=ns, bottom=0, width=width, height=opt_large, color=colors[0], edgecolor="white") + axs[0,1].bar(x=ns, bottom=0, width=width, height=opt_small, color=colors[0], edgecolor="white") + axs[0,1].bar(x=ns, bottom=0, width=width, height=init_small, color=colors[3], edgecolor="white") + axs[0,1].bar(x=ns, bottom=0, width=width, height=init_large, color=colors[3], edgecolor="white") + axs[0,1].set_title(gene_name,loc='left',style='italic',fontsize=64) + axs[0,1].set_xticks([]) + + gene_name = gene_names[2] + + init = [] + with open(root_path+PREFIX+'init_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + + opt = [] + with open(root_path+PREFIX+'opt_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + + + init = np.power(10,init) + opt = np.power(10,opt) + diffs = (opt - init)/init + + print("####################################################################") + print(f"{gene_name} results:") + print(f"Max Opt: {np.max(opt):.2f}") + print(f"Max Init: {np.max(init):.2f}") + print(f"Average Percent Increase (wrt Init): {np.average(diffs)*100:.2f}") + print(f"Max Percent Increase (wrt Init): {np.max(diffs)*100:.2f}") + + indices = np.argsort(opt)[::-1] + + init_large = [] + init_small = [] + opt_large = [] + opt_small = [] + + for i in range(len(indices)): + if diffs[indices[i]] >= 0: + init_small.append(init[indices[i]]) + init_large.append(0) + opt_small.append(0) + opt_large.append(opt[indices[i]]) + else: + init_large.append(init[indices[i]]) + init_small.append(0) + opt_large.append(0) + opt_small.append(opt[indices[i]]) + + axs[1,0].bar(x=ns, bottom=0, width=width, height=opt_large, color=colors[0], edgecolor="white") + axs[1,0].bar(x=ns, bottom=0, width=width, height=opt_small, color=colors[0], edgecolor="white") + axs[1,0].bar(x=ns, bottom=0, width=width, height=init_small, color=colors[3], edgecolor="white") + axs[1,0].bar(x=ns, bottom=0, width=width, height=init_large, color=colors[3], edgecolor="white") + axs[1,0].set_title(gene_name,loc='left',style='italic',fontsize=64) + axs[1,0].set_xticks([]) + + gene_name = gene_names[3] + + init = [] + with open(root_path+PREFIX+'init_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + init = [float(score.replace('\n','')) for score in scores] + + opt = [] + with open(root_path+PREFIX+'opt_exps_'+gene_name+'.txt') as f: + scores = f.readlines() + opt = [float(score.replace('\n','')) for score in scores] + + init = np.power(10,init) + opt = np.power(10,opt) + diffs = (opt - init)/init + + print("####################################################################") + print(f"{gene_name} results:") + print(f"Max Opt: {np.max(opt):.2f}") + print(f"Max Init: {np.max(init):.2f}") + print(f"Average Percent Increase (wrt Init): {np.average(diffs)*100:.2f}") + print(f"Max Percent Increase (wrt Init): {np.max(diffs)*100:.2f}") + print("####################################################################") + + + indices = np.argsort(opt)[::-1] + init_large = [] + init_small = [] + opt_large = [] + opt_small = [] + + for i in range(len(indices)): + if diffs[indices[i]] >= 0: + init_small.append(init[indices[i]]) + init_large.append(0) + opt_small.append(0) + opt_large.append(opt[indices[i]]) + else: + init_large.append(init[indices[i]]) + init_small.append(0) + opt_large.append(0) + opt_small.append(opt[indices[i]]) + + axs[1,1].bar(x=ns, bottom=0, width=width, height=opt_large, color=colors[0], edgecolor="white") + axs[1,1].bar(x=ns, bottom=0, width=width, height=opt_small, color=colors[0], edgecolor="white") + axs[1,1].bar(x=ns, bottom=0, width=width, height=init_small, color=colors[3], edgecolor="white") + axs[1,1].bar(x=ns, bottom=0, width=width, height=init_large, color=colors[3], edgecolor="white") + axs[1,1].set_title(gene_name,loc='left',style='italic',fontsize=64) + axs[1,1].set_xticks([]) + + orange_patch = mpatches.Patch(color=colors[3], label='Initial Expression') + blue_patch = mpatches.Patch(color=colors[0], label='Optimized Expression') + fig.legend(handles=[orange_patch,blue_patch],loc='upper right') + + axs[0,0].set_ylabel('TPM Expression') + axs[1,0].set_ylabel('TPM Expression') + + axs[1,0].set_xlabel('UTR Samples') + axs[1,1].set_xlabel('UTR Samples') + + + fig.tight_layout() + plt.gcf().subplots_adjust(left=0.06) + + os.makedirs('./plots/',exist_ok=True) + + plt.savefig(f'./plots/exp_opt_all_{TYPE}_{gene_names}.png') + + + + diff --git a/conf/analysis/uorfs.ipynb b/conf/analysis/uorfs.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..12e3e75968541d70c91f1e4e9293af42f0b967b6 --- /dev/null +++ b/conf/analysis/uorfs.ipynb @@ -0,0 +1,37206 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from Bio import SeqIO\n", + "\n", + "seqs = []\n", + "\n", + "for record in SeqIO.parse('uorfs_7_64.fasta','fasta'):\n", + " seqs.append(str(record.seq))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "402140\n" + ] + } + ], + "source": [ + "print(len(seqs))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# read natural:\n", + "df = pd.read_csv('./UTRGAN/data/utrdb2.csv')\n", + "df = df['seq'].to_numpy()\n", + "nats = []\n", + "for i in range(len(df)):\n", + " if len(df[i])< 129 and len(df[i]) > 64:\n", + " nats.append(df[i].replace('T','U'))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# read generated\n", + "inits = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/1024_10000_init.fasta','fasta'):\n", + " inits.append(str(record.seq))\n", + "\n", + "opts = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/1024_10000_opt.fasta','fasta'):\n", + " opts.append(str(record.seq))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# read optimus\n", + "optimus = []\n", + "for record in SeqIO.parse('/data4/sina/UTR/MEME/optimus_fasta.fasta','fasta'):\n", + " optimus.append(str(record.seq))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "path = '/data4/sina/UTR/UTRGAN/src/mrl_te_optimization/outputs/opt_10000_1024_saved/init_seqs_FMRL_10000.txt'\n", + "with open(path, 'r') as f:\n", + " lines = f.readlines()\n", + "\n", + "mut_inits = []\n", + "for i in range(len(lines)):\n", + " mut_inits.append(lines[i].replace('\\n','')[:50])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "nat_trun = []\n", + "init_trun = []\n", + "opt_trun = []\n", + "m_trun = []\n", + "\n", + "\n", + "\n", + "with open('natural_truncated.fasta','w') as f:\n", + " for i in range(len(nats)):\n", + " f.write(f'>seq_{i}\\n')\n", + " nat_trun.append(nats[i][:50])\n", + " f.write(str(nats[i][:50])+'\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def transform(seq:str):\n", + " seq = seq.lower()\n", + " seq = seq.replace('ggg','p')\n", + " while 'pg' in seq:\n", + " seq = seq.replace('pg','p')\n", + "\n", + " while 'gp' in seq:\n", + " seq = seq.replace('gp','p')\n", + " \n", + " return seq\n", + "\n", + "# find all g-runs\n", + "def has_gquad(seq):\n", + " seq = transform(seq)\n", + " print(seq)\n", + " if seq.count('p') < 4:\n", + " return False\n", + " else:\n", + " occurances = []\n", + " for i in range(len(seq)):\n", + " if seq[i] == 'p':\n", + " occurances.append(i)\n", + " dists = []\n", + " for i in range(len(occurances)-1):\n", + " dists.append(occurances[i+1] - occurances[i])\n", + "\n", + " start = False\n", + " count = 0\n", + " if len(dists) > 0:\n", + " for i in range(len(dists)):\n", + " if dists[i] <= 232:\n", + " start = True\n", + " count += 1\n", + " else:\n", + " count = 0\n", + " start = False\n", + " else:\n", + " return False\n", + "\n", + "\n", + " if start and count >= 4:\n", + "\n", + " return True\n", + "\n", + " else: \n", + "\n", + " return False " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(len(inits))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "augucgaugauccggagaagacaacugugaccucaaguugucupagcuucupacuuggaggcugucccgcugagucag\n", + "0.00033855438232421875\n", + "starting inits\n", + "augucgaugauccggagaagacaacugugaccucaaguugucupagcuucupacuuggaggcugucccgcugagucag\n", + "uucaagagcuucagcuguaaccagcaaauugaggaaggaagauaugccuuuuuacugauauaaacauuuucccagaaga\n", + "gguuuuuucauuuccugupccugccugcugauagapaauucuuugccuguaccucaggcccccauaacaacccccacucccgcccuggagauacccggacuuccucp\n", + "cuccuuuauaugugacagcaggaggaaacgucucuucccccaccaggcuuaauuuguuugaagugagaggaagaccaagaacaaaaauguuuggccapagac\n", + "cugccuagcupcgccggcuguguuuugagcuuuccguuuuugccugguggcgcgguccgagcggcacu\n", + "agacguacuggcugccaugacuccapccaagaaaaacgccccaguguuuuccuaagagacucaagaucagguaggcuccuaaucuacaaccaccuugcugcaccguuccagc\n", + "acagguguguucccapauuggaucagaggagagccugaaaucacgaugaucaaguggaacauucuagaauaug\n", + "ggcuguggaggcccuugcccuaggagaugaagccaacuggcacacagacccaggcggccagaaaauugaggcaucaau\n", + "upcgcggaagcuggcgccpccggcagcpcupaccuuggcpcggccgccauaggaggagaccggcacggcuuccggagupcagccgccagaccuccgcu\n", + "gcucgccccgcagucgcauguccgagaggcaccaggcccggccgccgaggccccucagcccgccgcaguccccccgcagcaccgguuccccccugucacpcacu\n", + "agugagagaauggagauccuaagguucaaaaggaagacagaaauggcuggaaccuaggcuucaggauauauuggaauuguucuuccuacccuaaugcagcagcaccuaguuaaggcaaacag\n", + "ggcccggcpccaaaggagaggagagcggcacaucccaagccgcgcuucpccgcagccgccacaccuagapcgag\n", + "gucuccuucucagaaaaggcaagcuguuuagauugaugagaacacuguccaucuccggucaacaauc\n", + "uggaggaaauuggcagcucaauuaagcacauuaaggaucuuagcuaaaagcugcugaccuaguccggcuccaag\n", + "auuauauccucccuucaaauagaaguaaaguucupcugaagacuugguagcugaagcagauggaucaugcccugag\n", + "gucuuucagauccuccaucaggacaaauugacaccuauuauuugguauugugauaucgcpagcggugaacugcuuaac\n", + "aguuuucucacgaggccuucgucaguccguugaugagccuuucgucuccapcuccacucgcccucucggaaauuuccupacaaagag\n", + "caguuccagagcagcgcggcgaccgcggcuucccuacccucgcucccpccacgcggcgcgugaaggucguugcucg\n", + "gcacaguuucggcgugaaucugcacaguuuccagaagccaaacucagaagauccaggacccagucaguca\n", + "aagagcccaccagaaccucacgcgacggcaaccuccaccaacagacaggaaccagacggcacugaacpapccgaaucupacccggacgagccggugagcaaccgcc\n", + "ugcguccuggagcucagcuaggcccaccaauagucagaggagguuuggccaagcuacupcuccucag\n", + "aagaccaaggugacuggaaucuucaaaaagugcaggaucauagacuaaaagaaugagguuuauugu\n", + "ggagguguuggaggaaggaaucuuugcugcugucuucagaugucaugaggcccacugcugugccaacagcucaag\n", + "acauccuggcacggcauccaagcuuacaacucggcaaacagaucaucggcacuuacuuugaccacccaagaugcagucacucccaaagcccccagauucacuaccagccagcacacag\n", + "ggcapuucccgagaugagugugcgugagcpagaacaugcugagcugucguuugagguaccagccacuuggugcuaau\n", + "ucuccucacagaaagucaggaagcuuggagaaggcagauucuaaagaacuagaugupaagaaaggccaggaucuguuugucuggacpuuucaccccagg\n", + "ccgcgccccccgacuaccgcccgcgcccgcucggccgcpuggcgcgcpcugcgcggaggcggugapugucccgccgcccaggcugguguggccccagu\n", + "gaagauuggauuccccauacuguggcgguuacgguaugugaagugcupaauuagcagcaggagguupaguacuacagccuucgcagaaagaaa\n", + "aaguaggaapagaggcugcggcugcgcgcuguugcagccgucgccgcucgcgaggagagagagaccaggacccagaaagugaagapag\n", + "cucggagccpcagagugagcpuapucuucgcuucuccpaagugacauuggagaggccuauup\n", + "ggaagaguuucuuggugauuuuuagauuupccucugugaaaaccaaccgaagguauaggacacagg\n", + "gacggcugcpaagcupacaggcgguagcaggagcuuccuagcgaggcucugcugcccgccggcuggagcugcagccu\n", + "gaaguuugaaggaccagcaauaucuacugucugucacuccuauugcugaucccaacaaccugaugcagcacaaaaacccacuaaacaggagaaacacaaaccccaggcaagaaguuauuu\n", + "cuucaugagugcaugcaggcccacacuguucccpugaauggcugagcapucuccagugaaggaggauucucacccagagguuuuggagagg\n", + "papcaaacuguucugccugaccugagaccupaggaauguggugacagcagcpaucuuagacaccgacaccagacupaagaaucug\n", + "puccggagagaacuuagcapcaaaagagacggaccgaacaaccuaagcaaaaggcaaugagcagcaaaagagaccaauccccgaccaacccuauggaacagaagcaacgcacgccccag\n", + "gcagcacaggaapcpcgagcpagcpaggagcugagcpaggucpcpuupcgcagagagaggagccagaggcggcgauggag\n", + "gcgaggagccucuggaccugcupccgcaupcccgccuccuuccuucucgauuccgugacccgcagcc\n", + "ggaguggccaugagcuuccccaucaccaugguggaccugaguuucuucuaggcugaacaagagagaucag\n", + "agcucupccgccuccgcggcucccagcggagagagcgcggagapcggcgcggcucgccgacgccccggaggaggaagagugcag\n", + "acuuccggcguccgccuagucucguacacucgccacapuguggauugacagagcagcaggccagcg\n", + "cugccuggauauuucagagagcgcgaggaagcugccucugugcupaagugucuugaugcucuaaaaapccccgccgugguguggcacuucgcugccupauaagcuaaaaag\n", + "ggaaaugcugcaugaaaacugcuucaacuuugaagacuacucagcuaccuugaacaucagagucuuugag\n", + "gucuggccgucggcccugcagcggcuggaagcpagugcaagcucccugcuccgguugacgaccugcgcucggagcca\n", + "cucucgccugcugaagcgcuccgcgcguccucccacuccucacgucuuucgcgcuccuccggcuccucgcuggaugaaa\n", + "uacuucaguuuccugaguggagccccuaaaaaagccugcuuccuggugcucuucuggcuucccuucccucuccuuuuggcucccucugucaccgucacc\n", + "gcpccucguuggcuggcuggcuucgccaagaaguccaggaaggcucagaagacuccaaggaaggcc\n", + "uguuugaagaggccapcugaggugugagacggugagacugaacaaggcggccuugucacagauugcuggauccagguucuaucuugcugagcg\n", + "ggapcuguggcggapagcgcgucpucccacgcuuuggucgcggagccgupagcgcccucacaacaggugucac\n", + "agagccgagagccpcucgcgccucgcucacggacgcccpcgcgcggagucccugcgagacccuagagaaggac\n", + "gacucgcuuaaaccuggagcacgugcucuuugaccucugccgucauccagcuggaguuggapupcuggcaggccugag\n", + "pcgaccgagcugccgccccgaguccggccagcggupccgacucccggcccccccgcguccccupcaagacgcc\n", + "aaccggaguggcugcagaagcugagaaaggacagguuaaaacaaucapaaaugcuaaaagugcuaaucauaa\n", + "acuccugcuguuggagcgcgaugauaaccaagcaacucgucccuccccguucuugcaccuuccgcugaggacagaucuuaa\n", + "uuuucaccaucaucaacgucugccuacgaagacgacugcugugagaaguccuuggcuucaaauauugg\n", + "ggacccgaauuuaaaucugccaggacccgcuuuuuacuuuggagcpaauaggapagcagguccguaaauaccaguuucacggcucaagaguuuucacacg\n", + "aagaguuaccgcaggccuccaaagacccpagaauaaagcaugcagaaagcagacaguaaacaguuucacugaagaagguaucagau\n", + "aaccugucccggaaucggcggaaaaugugugcuggucugccaucgccgcgccuucccupccugugcgcacugugaagcpcpaucggacu\n", + "ggcaaaaggcuuuuaccaucuucuagcuugugccuugucggagaggcpcagugugagagguuacguucgcuuggapagccaggucugccpaucaagguggugaagacuaagugaaucag\n", + "gaagcuccguggagaucacaguuucugagagupagugguugupaupcuuacagaagc\n", + "guugcauggcucguuuccaaagcccggugcuccugccccguccuccgcgccgcgugccgacacpcacgguccgcagcc\n", + "gaggcugucupaggaccaguaagagcugcucguuccaguuggugacccaccacccugapcuug\n", + "cccggagucpagcggucccgagcgaggcgccggugacccaccggcggaguggagccauccccgaccccpcuuggau\n", + "ggagagugccaguuggugaggaccgcggcgguguggcpaggcpuuuuggccapuccgaagca\n", + "guuaagccaaaacuauggcagugccauguugauuugcugucacagcagaaaagcaaacuggccuucauggacauccacaacagcugcgaaucccaaaacugauauagc\n", + "gcugacccgcucccuccgcucaggaagcccacuauucauacauacgcuccggcucgagguacggagccag\n", + "guaacauccagacaccagagcacugccuccuucgguaugcagaaccagaaagccugccgaagcgucaccagcucaggaaccaag\n", + "guuugaggugcagacgguggugaaugaugcuguuccgaaggupaaucgcucuugagaaguucapcagcgag\n", + "cgcuccgcacuggcccugauggcagcagcccacagaapcccucagcgcgucugcgguaaapauc\n", + "aggcagccgcggagaggcggcccapcccagaagagccuggacacccaaccgacaagcaggacccggcggacccgcag\n", + "cugcpcaggugugcaggacgcuccucucggugccacauaguaccgcgcccuccccugcccugagagccgcccccgccccccgcccuccgccacc\n", + "gacgcgccugcauucuaggaccuggagaucaccugcucagcpcccaccucucuucgcuguucg\n", + "caguccugccugcaugguacuggcgccuucacugucgcaccaacucgagagccccugcgacaapcuucaugagcugccagugcc\n", + "upucgupaggaggcaguggcguggcauucgcugucucacguccgcuucupuuccucugcuccagcupcuuccucaugcuccuguccaaggauggccagagccgcc\n", + "gccgcgcaggcacacaccaagacgcgaaguagccuuuuugacucggcugagaaaaagcugagacucuc\n", + "guacugugucagcaucucauuccagaaaagacacguggacaagaagaauugaguuucuuaaaaccguuugucuuggaaaaagauaaugugg\n", + "gacapaccgcuggapuucggcagcguggcagcauguucpagaggcccaggcggagcccpacucaagccga\n", + "ggucaucaccccaccuccuccaccguccccaggcuugaggacauucuacacucggacccugcggcaggaaccuagugccacacugacagaguuaag\n", + "aagcucccgcccccagacccuccccucapaagagcuaggcgcaggcccggcgcugcupapcuggcggaggcuggcggcgccgcugagcupacguagaggcagcuccgcpaggcgc\n", + "pagagaaagapcggapagcggcuupaaggagcggcccgagccaccggagcgacccucggcacgaupccgag\n", + "auauuugaccuggaagaauaggauaacaggcccaccaucauguuuagaugaugacuuuugaauugcuguagaauuugcuuauauaaagugaugaauccugaaggaacaaauaacuuuuacuaag\n", + "ggcaaggagaagcagupagaaggcucagaucggcucccagcggauacagcucuaccugcagupuggcugcaaccugcapacaccuccaugguugcag\n", + "gcuuccaccucgccccguggacugcuuugguagccacaguuggaggccccpuugacgcccapagcgg\n", + "cgaaauagaagccgcaccccucguccccgapcuggagcugupaauugaacccccuggugaapagcuccgccuccapcgcugcgcgugcupaapaacacgugagccg\n", + "gaaagguugguggagcuuggaaccuucacuacgaucacccagaacuucugccugccggcpcccgccacgcccguacccauuuucccauccuacgcuagccugcggccagac\n", + "pcaggcupcgacgccgcgagaagcagcacccpagaccgaucugccpcccpcpagagagcg\n", + "aguggauucccauugapugaauauggcguggaagguagcagaagaggagauuuuguugcagaugcaagaguaaagauuuuagcuggcupaaaucuuaacacccauacauuuguguuuaucagc\n", + "acucccccgccggucacuucaggugcccucccggccaaccccpcggaccugagcucccagcgacpcggcgccugcggca\n", + "cagugugcucccugccucguagaucggcucccaccucuccacaucaccccaguccggauccccagcpcupcuupag\n", + "cccacucuggucgccgcgaggaguucgcgcagucgacgugaupcupcgugucuccccguucggcgucacc\n", + "gcaccguccgccgaggcgcgapcggcggcgguagcagauugccgcaccgccpccagcgaggccc\n", + "gauucuuugugaccugagaggaagacagaccaaggcaggagaugacagcugaaggaagaccaucagccaucaucaggc\n", + "aaaaagaaaaaaggaaucacagacguagcagcagaggccauccagagagaggagucggcggapagcugagagagagaggcpcggcggcp\n", + "accuccagcggcgcgcggcugcugcuccucucccgcgcccagugcpccggcaggcpcucccuggcag\n", + "gguacacpcccucacggcagcgcguucacacaggcugucggcuggagcuugcuuupcuguuggag\n", + "guacauugacguuuuugccagcuguuucuguucggacaugaucaccaaggagccgcgapucggagag\n", + "aaguuuuuugcccucuaucacuaacaauuucaguguuauggagccgauggaaccuggacugccgaccaaagaaagaagagcaupag\n", + "gcucapccupccgcaggugcgaggcgucgcccgccccagccccgguggcgcuggcgcccguccuccccguccccacccaguccgccaaaccccpaccgcagaggcacccggcuug\n", + "acacauugucccuaguccccggaucauggcauuggacguccuuuggaagaguaaggagaggcggugguagacuguugcauuuagaguucauggcuguguccaggaacauuc\n", + "gagaccccucuggccaupugucauacuggccagaggagaacaagaucccgcugagagcaggcag\n", + "gcacagcugaucuaccauggaauccuagcggugaugaagaaagucuccccugcuuucaguugaaguauaugcacgaguuucauuggcaccuucuccauccuuaguguuguuugcccugcug\n", + "gacauuuucgaccccggugacpcggacgcccgagcuggcgagcgagguggcuggcggcggcggccuggacuggagccgucucccupcu\n", + "gugaccuccugcuggaagaaccugaucuagupaucggaccggcuccuaauggcgacggugcugcaaccuucucpuuaaaggagucuccuccggcaacugcaaacagaaacgcggagug\n", + "auuucagcagcugaggaguuaugugucugagaagguauucauuguagcaccaaagaccaaapag\n", + "gaaacaccauuuauucacaaaucaagaaugaaaagcccaaguuaauaaaauugcugauuaauuagaaag\n", + "uucuuucugcagacaugccuguaagugcaguucuaggagaauugauagaagcagcagaagauagcaaugaaguaaaggacagaggaaguguggagauuauacaauaaaaguaugaauuuuagucaag\n", + "auucccacuucagugguccaguuagacuuucacauugcaauaccaaauaacugcagacaaaaugcuccgaagaauugaaguuuuccauuuuuccuuucagcgaugaucccuagu\n", + "acacggugucggcgcugcuucuggccccguguccuacucccugaccuucugcgagcuccgccucgagacccaugaagcuagcggupucccaggcggucucp\n", + "guugaagugapcpagcgcgcggcggcggagugapcuuccguacacgcggccuggugugccgcccgcgcaccupaagccgcgcggcpcgaguggaga\n", + "pacccggaagcgcggcguccpacacguugccaucgcggcgapupaacuuacguccgcggacgucggaggcgaggacaag\n", + "cuggaauucaucgaaugaaaaacaccugugccaccuuccugcagccaccaugauacagagaguuagaccucaagcuuacaacccuacgaacuuuuuagaggagcuacagucuaggag\n", + "gccagagaucuccccauucacuacuaagaacacaggagagguaccaagaauggaagucccagapcaaaaguguaauggacauauggucacugucugaccgcaccacag\n", + "gucaggcaaacugaaacuguggcaucccacupaaguuccuugcucuaauugaccagaaagcagca\n", + "gucagaauuuuccaaacuacuagagcuugaucgccuccagcaacccagaauucugcaguaupuugugcuggcucagaacacagagaaagacpucuggacguaaagcacuuccuacagg\n", + "ggagagcgacacuagccgcggacgccguuguguguguggccagaucccggupacauggcuuccauuaggccaggcccguaau\n", + "gaguccuupauagcaccupuggagaagccagcucagcugagcuacpaggagcagaapcgacpauucugcu\n", + "gaggcpagagcgupugcaguggcagaupcuccgcpupcaagcggccgagcpagagcgccccuguucaaccucuccgcagacuuccag\n", + "ggagccagacaggcgcguagapapcggaggcuaagaggaaagagaggcagcupaaccugaggccagcpcaggaacucggcupaccca\n", + "gcaccuuuuccugaauucaagaacuuuggacccuggcuccgcagccagcpccaauugapaucaucugucgccauuucacupcccuuccugcccagagag\n", + "gugacguccgcgugcagaacgcguuaagaugaugagguugugucccugugauggugcugacpuugupuaggugaccgcgupagucgcupccuggccaagguccpaguag\n", + "upcucgcuggccucagccgccgucugccugaccuccucaggccccggagacucucggcgccugguuucg\n", + "ggagcgccugcgcgguaggcgccccaacugagccgcccugcaccuucccggcgccggacuccggcccugcagcuugcacaccgcgcagccuc\n", + "gaaggucuggaagaaaaaacaguugguugagagucugcuuuagcccagcucagagguuuuuguacuuucagcag\n", + "gaguuugugucuucuguuagugccagagccaggaucuccucagugcugcagacacacuugaauuucuagucccccaggugaacucccpcacgcg\n", + "gagcugcugcaauugaggcaggugaaauguauggacaggcuauggaacucgguggagauggccaagacugag\n", + "cucugagcgcccggacucagcgaagcucuggaapugacugacaggagucaacuguauugcuguucuuaggaaagauuugaaaaucgcacuucuucagccugcagcuuguaagcugaaaaag\n", + "gugagucuaguacagcuguggauauggcuaccauaagguaccuuuggauuauguauaaugagauuguucaaagccaagacag\n", + "gucucggaupcuccaggcgccaccpccuucccugcccucccugaggucacugcgccggcug\n", + "uacugugguggaauuccagcacccuggaupuuuugaugacaaugaauguggucaguuucccuguugaaguucaaaauuccag\n", + "aguuggagcggcuucccuguuccagcuuccaaaucuuaapaaapcucacugagapuggccccpaggcugaccucagaaccacggcgaacc\n", + "aguccuaggccapcgagaagcgcuuccguugccucccccpcuccgcacccagccauccccuggucccggucuaggugccuuguccccucuguccaguuaag\n", + "gacaaacupaccagaaaaggccaaagagupaccuugucggccgucuacucuucauugcccagacgaapugcccaaccuauacaauuuccugcucacuugcccguccuucgugaacccucaag\n", + "aacgcpcucccuccpaguuugauggaaacagccgcpcggcugccpccgugupucggagcucggcuapagucugauggagag\n", + "gcgcgcgcucagaggagcagcguucgccccggcccaggccgagcupccccgagcccguaagcgcuuggcggcaaaagucucgcacgcccggccgucccuuggcg\n", + "uuuuuccugccugauauccgugagugcupagacuucgcupcggcccpagaccccgccucccuucgcaguacccagcaaagacg\n", + "gauugcucagacaucugccuggagacgupaugauaguacucauuauuccgccugagcaacgcuguggugucupcuguuuagguuccccaaggcucaugag\n", + "uuuuaauugauuuuacauuugcuaaaagaugaugaugcguuaacuguuuuuacagaagguuuuugauaaagg\n", + "agaaaugauaguuucgguucuucagauggcugguaucgcugcacgugcagcacuaapaccgaugaagacg\n", + "ccggucucagugucuggccgucgcgucuccgaggcagcugccagguggacaugucaccucucpacuucgcuuuaaaag\n", + "ggcaaacccaaagaagccpacpacccgaggacgcggcagaggapagcaguagucggagccacccgagg\n", + "uggaguuacgaagcucaccaaguuggaaggcaguuaggupugccuuppccgaguguugcugcuccapcugcaggugauggaagucaccaucagcaag\n", + "aagugagagcugaguguaguggugcaggaaaaggagugacuuucacggaguugccucccagcugacagupaccagcugccagugagcg\n", + "uuucccaaccuacaugucuguucupacacuccaggcauacccaagaaaaacugaaagacagcugcuccuacccucuaagagaucgaccgcc\n", + "gagcuggagaauucuppucgcuggcuagcugcagcuccacuucgugcaggcupagagapacgcgcugagcuccuguuccgcacgcgupuguccgaggcuggacguccag\n", + "cgaucagcaagagagcpagaagaugaggcggcggcgguggaggcggaggaapcccagaggccagcggcacccpccggapaggccaggcgcgaacacpccapuuaagga\n", + "ccccggcuuuuaauugaagaaaggacuuuuuaagauuucagaagauuuaaaaguguuaaaguccccaugaugccauagauugaaaacuaacugaagcaguuccagaaggugacg\n", + "aaggccguaacagcccuaacuacaggaagaaggagaagaggapaaggaggcggcggcggcpagcagaagcggaggcggcggcgaggaggagap\n", + "gaaccgugcugcuguuucugagagugaagaupacccugcaccuucagccacucaaagacagcuuccacauucucaacuucaucaccaaagaggaacagacccacugaacauuagucuaag\n", + "acccccgcuuccugcggapcagugauacguuccguguggaguuagaggauggaggagucucugcuuccucaggauugaagguggcccagccucuggaggaucag\n", + "uuccucaucacugccugucaacuuaaugugccugaagccucggaagacagaguuauggaacaagacugauaccgagauagaagcgaccacagcauaggaccaugcccuccucuucaggccu\n", + "caauugccacguguggaggcacaaauggcuacugcaagcuaaggcugaaacagccagacuggaaaucugagagacuucggaagagagacucagaagacagaap\n", + "cauucugcaggaauugccggaguuaagaacacacggaaaaaaguugupauaggagcuccuaugguuggaccuggaugacaccaucgcguucauggcuaggucug\n", + "augccagcpucacguccaccaggaucuauaugacauucaguccauaauucggcuccpcggucccucgcpcaggccucaaugag\n", + "aggcgccuccgucugccucuacuccgccaccuuuuuuaacauccuccuugcugcagcuuacpcugupcgauauguccuggcuucaacaggcaucugagaacuucccagccapucucagc\n", + "gcgccccugagagagcccucapacuaccpagccgapcugccucgcagcgccgcgcggcagcgcgcccpcpcccapcuggcgccgcgccpccaaucacccaggag\n", + "guaaapcuugcgagcaggcaccgcuaaagguguguuccucaggcucagucccggauagcccugcacuacacucuuuucacucgcucccag\n", + "gcugagcpagaggcuggugugupuauuggagaaaggagcaapuuagauggaggagaaagcuccaucaggagcc\n", + "gcacaaacaacacuaguuuuugaugapcacgaauagaaaucgucaacgcaucuguagcgugaagguagcugaggauggaacagcggaaacagugc\n", + "gcgcccgugagaugcgcgcggcgcgcgcgcgagcggccggaggcccupaugupacgupcgcgaggaggcaggaga\n", + "pcgacuucccuccgcgcgccccgaccgcgccugugcgcggccccaaaggcgcaggcgaggcgacpcgcaccgcuuccuggcuugacaggccagcucagccuucacucugccag\n", + "gaaaauuccagaccccaagaguggccugcucuuuuuaaaugagauaugccuguauucauagugcaaaggcaacuaagaaagccaagaaa\n", + "gcuuucucuccagcauccugguuagcgugacucggcuuccaacucuguuucuuuguagaaggagapaguggcugaccupauccacuuuccagac\n", + "uaacuugugaccaacagaaacacagaaggugaagaauuuggagcagcuauucagagcuaaauaauucagcugcugagcauauggagaaa\n", + "acggagcugcgguggcggcggccguaggcgcpacacgagcgagucgcccagccpcucaguc\n", + "cagapaacccaaaggucuuuccagccagugagcccagauguugaauupagaccagaguucuuaucuccaacc\n", + "paaaguuggaggaggaugagaapcuggaauccccuccuacguguugugguuucugcugcuaaacgucc\n", + "aggccacaggccccacccucuucucggacccgcgaagagcagaauggaggagaaggaauaauucugc\n", + "ugcggcuaacguuugccccugcucccgcccaaguccgguucccpccapccaaucucccagcgacugaggcagaguccggcccggcccpcggcccgcucgccup\n", + "ugacgaaccccgccucucccgucacaccccagccccuuccucccagucccgcgguucaguuugccuggucagcccccccgugcgcuuccgcccccac\n", + "acgucucugacccgcucccagaccugcaccagcagcccagagcguccggcapagcpaucupcuaagg\n", + "cappcgacgccpccuucgcggcggucggugcggucuguggugcccuugccucccucccacagcagccpcugucggu\n", + "uugcuguggcgccpucccugagagupacguuggcacuguccgugccuaagaaaccauaaacuccgacucagagacagcaacucuuccaagacagaagcagcpaagau\n", + "gccgcaccugccapucapcgccggcagcggagaagaaaccggacaggcagaggacggagcuggcaggcaggaaaauaaappaaaggaagagacggcuaacagcggaccccguc\n", + "acuaagccuucucgauuaggaguguguggccgcugcugaagcggaggcuccucuaaccauuguccuucccccagaaag\n", + "gguggaggagcugacagcgccugaguacggcaacagccaaccugcugugcucccagguguggugucauccccucaccuucucggaucagag\n", + "aaccaggcauguugcaaacaagaauagcugapcaggaccgagagugacgcuguccuuuccaaccaccaaaagaagacacuuccaguggcuccacaccuuguaguucacuuuaagag\n", + "agaggaagaggagcggcccgaaagccggccccacacgagccggupapcaagugcgcaccgcgacucgagaguapacgcpaucggcgugugaucgccgacacccg\n", + "guugacagccugcaagaccagcuguacugccagguuggccagccguucgaaagcugguggccacgugaau\n", + "uugacaacagaagcaggacagcuggaauuaguaugacgaagcucauagaucgugguugaguaggaaacuuagaaguauagagcapacuuucacugauaaaguguuucacgcuugaag\n", + "gugucugucauccacagaaguaagcugcuucugagauuaagcaaggupaugacaggapcaaucccuggcuaggcuggaguugaag\n", + "gacaacugguuaguupaggcaaaguaauaucugacuuaagugucaagcuuucugcccugaccuuaucaguguauuu\n", + "auuguccaucuuugacacupccgagacugcaaucgcuuuucagcucacugaagcuagaagcacucucapugagaaugcapaccccuugaagugacugccucccagcaauccccggcucccag\n", + "acpcuucggcuccggccucuugaucupcgcgccguucuucgacccgcuuccugucaucuaacag\n", + "paccugaugcgagcagaagaccaagugccgagaucucagaagcccccacuuggaugapcpauaggcccacccgcuccccucaccccccaga\n", + "aagauguupagaguuguggaugauaggaagguuacaugcaacucugcuccagagccccuucaucacuaucgagagugccupacacagcc\n", + "guupcuggagguggaacccgaagcgugugagugaccccgccucaaagccapaccaacuauccu\n", + "auuugccggcgcagcaacccupucgcaggccgugcugcggucggcugucucaguugcuacguggcpcggcgcagccccguc\n", + "agcccccggagucupuucgucagugcacuuagagapcacpccccggccucucucccpcaggagcuggucgcuguc\n", + "cuuuuagagacuucguuapacuugcugucuccugcgagagguuguccgcuguguucucgagacucgaagaauaauggaaaagacpauucagagcagcuccuccg\n", + "gauugaagaguacagauaauuuuccuuaupacuucuucuccccaaggagaagagaauuaucugcaaagg\n", + "cacucaguauuaaucccucgaagagcucucauucuccugucuuccuugaccuggacccccagccugcacaagccag\n", + "aucacagcuucugcucucccgugaugcaucggacuguaggcugacaacagguguggaggaggagcacgccgaca\n", + "aggcaaaacccacagagcaaucccagaaaacgccgaagaagcapcagaacaagaaggaaagagapapaaggagaacaggcgaupaaaggaagcugcaaaggcaauagagacg\n", + "augcgguaggaguguuuccagcapcugcgcguggcgcpagcggcggcpcugcggcgaacccgcgacgcugccapcggagcgagcggcapccpapacaggaaucgapccg\n", + "aucaagcupcaaauccgugupapcaaagccpcaggcugagcpaagcgaggaccupaacccaugug\n", + "gaucuauugaccccacaagccugaacuugagucaguccuucucuuucccgupagccgacacugguuagguuaguuuccucaguugaauugcuaccucagcuuggcu\n", + "agcuucugccugaacuugcccgagcucugaggcuapaugucagccucugcugcccuccaagaccccgccuucuuccaagccucaaaggucuucaucauccuucgacccccccaggcaucaacg\n", + "acuguacagcppcggauggcugcpuggucagcagcucccggccucggucccgcgcgugcgcucpcccgcgccucgccggcagcgacugccuugccpacugaggag\n", + "aggacuaacagcugcaaccaagguagagcagapuguuaauucacaaguuggauaaaaugagcacuacuugugaauucaguuguugg\n", + "acagagcauuuauuuccccauagucaccacauucuuucaacaaggauugcauauccuauaguucauacguaucauaauugauauagauuauacuucacuugauagaccauuuagaauc\n", + "cugcagauucagcugaggugaccaagauccacucacaacuggacugcugugcccaccuuucaaucuuugcccacaugcaggagguacccuaauugaucag\n", + "aaagucaugagcuacauauggaauugagagccagcucuugaacaguaaagauugaacagucuguuugcacaaacacaaagauugcuugauccaaaaagaaaupaag\n", + "gcuuccpuggugaaggcccucugauucpcgaucugcccgguuuccucgupcugccgagcagcccpccgcugccgcc\n", + "gaggupccugguaucggcugaapaacguppcgcgcuupccuuccggacccupuaacauccugaaag\n", + "cacauucucaagaaaccuccugcuucacacagaggccacaaccacaguuguauuacacuuccaacacag\n", + "cuggucaagagcuggapagcgaggagccccgagcuucguggaggcupcucugaaccggagccgcuggcacccgapuuccag\n", + "cpaacccgaggaggaagcaaapaaaaacucacagagaagagaggaapaggagapaagaaggaaaagagaauauagagagccgcggcggcgacccc\n", + "guuaugugucuuuuccgaguucguguagguuugupaaguuccupcucucuaacugccucugaugau\n", + "paaaagauuccaaaggcugucupugguuaagaauuaauaugucagacuggagauucuuuuugacaaaugaagacccgcuuuagagauaagaacaucuuacagcugaaggaacaacagg\n", + "ggaacaggcagcaucugaggcagcgagagguuggcagaucugcacucuuuucacccauacuggaaucuuauuuucgguagcagcacacuuuacuccaccucaagcagcuggcagcauc\n", + "gauucacugaaacaauucauauagcugcugaugaggcagugcuaaaugauggauaaggaauucccaaucaagucuugaaacaaaauguuccagcaguagguaagauucaagcg\n", + "ugugauccccgcgaggcpcggcugcupucuggaaggcugagccacpccuggacuggaggccgagccgcagcga\n", + "ggupagcggcgagccacggccgcagcagcggcgcccguuccggugcgacuccgccugcgcgacuucaccgugaccgcggcggcugcacgaucgccgac\n", + "gcuuucauucupaaaapacgaagaaaguuauggcucucuggcuccauacaaguaauagcuucuggauccagccag\n", + "cuuuccgccauuaaaccugcagugcucccuaaccucgguaggugucagagagugaggagucuuaacuuccucagaaugaaauuuggcacccaagcuccaggauuuccugaaagag\n", + "guagaaggcggcuucagcgcaggucggcaguagcugagcggcggcpaagcgccgcggcugcpapapagcgguggcag\n", + "auacagccucagugcagaaacuguucapaaacuggcupagagucacacguuaggagccgcggauacuguuguapuuuuuagguguggauucaacauucuguuuguaau\n", + "gaagugucacagauccuucucccugcugcucccucccagupuggccacgupcgcacacugucauggugcapcauccugcuuucgcuucccaggagagcgcugcugcc\n", + "agagcccugugcgcpagucggcgcugcupcucggcgcgcagucggucaguucgcupuugcacugcgaucccggcuggcgcgagacccccaccggcccgucccaccccaggacagcggug\n", + "guuucaugaacaaaagaaauuguauucacugaccagaugcaupcapcaggagguggcagagaccaagccag\n", + "auauuugaagauaggaagcagcuggauauuguuggcuccaauugcuuuuuuuguuaaaugacagaaugag\n", + "gcuggcgcuccgugacpcccpcugcauuccuguggcacugcuggauugaagcgguccgcgccuguccgccuucgccagagacucaagcccggacgccgcc\n", + "cccccacccgagcacgaguagcugcgaccaaaagaaaaaggaggcaggcugaggaaggaacapappcgcgcuuccgcc\n", + "ggcugccuccaguuccagaggaauucuaucguggaucugcagcugauacuauuuuuugugauupaggauuacuauugcucuag\n", + "gucggccuggcagcuaggugaagcgcaguapauccgcguucuuguguacacccuappucucugugccgcugcgugg\n", + "ggccugcugaguucggccgagaagauccapuuggagacapucuugccugcacguuuccagaagguacccuuuggcucgcauccugauguuguggaauccagagaauguggcagcagcaag\n", + "aggccauuucccaucaaccaaaagcaaacuacugauggucauuagauuuucaguucaaggaauugau\n", + "paaccuacugugcaugaaagcacugaacggaagagauggcuauagaggacacgcgcuuggacgaacuccuggaca\n", + "cucaauaguuuuucaugaucuucagcagacuucagaagacagaagauaaaagaggaaaugauaauggacuaaucuauuccaauauugucuaca\n", + "ggaccgcgcgccgcacacpuccuuuccagacaggucguugcgcucuaggcgagucccagagccuggagcacacguuugcugugcacuuug\n", + "gcccagaggcacagucgccguccggcugaapuaugguuugagacagcgcapacugagupugcgccuugaapcguguacgaaccaaua\n", + "aacauuggaagcaccaccccagcuucugaaucucucauuucucauggacacccagacaaagacacuguggcuguguaaagugugaaccauguuaucucugacacc\n", + "caagcuagcaagcaaccggucccgcpagcggccgcggcggcpccgcagccagcgcgcgcgcucgcuaguupuugagcgupcuugccggaagcgcaugaggaggaccgagc\n", + "uguucgagucugcccaauauggagcuaauucaacucugaagaugaacugcaggaaaacucuuuccccaccucaguuggccauuacaacuuucaaaag\n", + "puucaaaaagcuuuguagcupuggagaguugguuaggaagacacaggcugcugaagacagcuugcucuaguaaguacgcuuugguggua\n", + "gagauaugauauuuauguuguccucuguuucacuauucucucugcaugagacagcuagacapuccaugccaucuugaccccaggaagacg\n", + "gacccucpcucugcagugccpacgacugcaccuagaacaucgccggagcggcguggcccaagagcggagcggcpagag\n", + "pacpaggugccgcuccccuccccgcgcucucucgcccagcucccaccguugccaccuucagucgcccggucccaucgcccgcuguaagcgcagcugcag\n", + "gagaagaaagacugucuugaccuucagcuccauugacguccucgacuggcaccaugcgacguaugaggagcugugugucpacuuaacaaagaa\n", + "gaaaaccugccacacuggaagaagauuuaagcaaaacccauucagcagcupcccagagcccaagucagagaucuuucacuuugcaacggcagccc\n", + "gagccggagagaaaagacaagagccauaggaaagaaaaggaapaaaagaaaaagaagaagaaagagapaaaaccaaacugagaggagaaapaacuuagaggaacucaggcc\n", + "gccaaccccgaggcuaggcgcggaccguagcuacgcggcuggcggcaaggcaggcgcgupcppuagcuggcggcgccgcgagccggcgccpcugcc\n", + "auguucaaugucuucaggcucccaggccaccuucucagagcaguccaggaaguggcuguaucucuugacguccaaguguuugagcuccag\n", + "ccuuucgcucauguuuuccucggcggcacagccuguucaaguggagugcgcggugagugaapccuccggcuggaggaggucugcgcacccccgcucggcguggucggaggcccuga\n", + "acagccugcaggccccaacuuuagaugaggccacagguuaaagaaggugugaaucagagcuggauuaaagg\n", + "gcugcggcggcggcggcgapcagcaagcccugaaccagagcgagucacccacaacucagaagccgaa\n", + "caaguuggcacccagacacagcagcucacacugguuaugguucuaauggcucuucuaaagaaauaaccuguaaugagaagaaauaguuucuggcagucgagcag\n", + "ggaagaaauggcagugcugcagugaaaauucuggaggcccugaaucacaccggcuucagagcagcugaaagugugagacucacacucccupaaguuuagcaag\n", + "cuugcaaggucupacaucgucpcgugucapugugagccpaagaaggaggucaccag\n", + "pcpcggcgcucggcagcpcacpaggacaaggcggagcgcagaggcccpaagucgcggccggcggagcuuucupcucupcuuguucucucag\n", + "upccaaauaacaacgucuaggapaagaccccaggccguuguacacgcauuuaaguucauuaucgapugaucaccagcgauccucpaaggccuugag\n", + "cacauggupagaggcuacauccuaucuuuaucaupccaaaacuacaggugugaccuagccaggccauacgaggcccugcgaugucgccuuccugaguugagaaaag\n", + "gcacuuugcggaaccgucccagccucagccccuccgcagauuccacagaggccagagcugcagcugccgccgccgccugccagaacpcggucgccccggccgcucccacccccaaaag\n", + "paaapugaugaucagcucacgaagcuucaagcuuccccaucucucuggaaaaguggacccaaggupccagaauguuuugaucaugaggaggaagupacccccuggaaggacugagccag\n", + "guupuuucuucuggcuuucgcuucagcgugccuccgccgccucucuguccccagcuucccccgcccagcagccuccuccgcccccuccuugacugcagccugaguaagaaucacgucuaggaag\n", + "ccgcccgcggcucccpacgcggccccgaggaucagcaggcgcagcagcccuagaagcagcugcccggaggcgcccpcccgagucaaaccggcagagcgg\n", + "guuuuuuccaugucaggacugcacugcaagaaapuuccuggaauugcaaggagagaagapugaggaacucguggagagaagaauagacpcacgugcacggcgag\n", + "aguuguaggucccacagaacuaucuugccccauggauaaaagugucccuuggaacgaagcapag\n", + "cucaaccaguuuuccuaacagcagacccgacuucccggagagaaauuggccuugcagucagaaagauugcagacuu\n", + "ggaaguuuucaacagaugguccugcucuuuauaaaupuguauguaucaaauggaagaaauucauuugugaagaauuuucagcuaag\n", + "ggcggcugcggcugcgacgacggcaggcggcuaggcugcugccgccgcugcucgaaccpcggcgguggcugaggucagagucccgccagagcp\n", + "guaagucccgcagcagagcgaggccucgaggcgccgcacggcucccccpcggcuguugcccccucccucccggcuuucuccggcucccuggcuuuccccgccucccgucaggccag\n", + "cugagcgcggcapagcccgccugccaggcaagagccuggcucguccgcuccccgcgcgucccgcacgccccagugcccpcagucucucpucgagcapagccgag\n", + "puccgugcaucugcuuucuuucugaagcccgcupuucgaccupaucugucaugcggcugcpuaaggag\n", + "puggagacaccggcugcupcacuuccucgacagccuuucuuggcgcuagguucucugcgcaappcgacuucc\n", + "apuccguuccuggaacapaagcucuggaagaccacguccagagguggagccgagupaccgcggucgcagccgccaccugcccpaucuccgguggccgccggcgcuggc\n", + "agaccupaugcggagcuggagacacapagupucaaccpaugaucuacguacagaccgcpcacagcaguuucgcgacc\n", + "cpccagagccggcucggccggaaccacggccccguccgcauucccggugaagcgcgcgupuaggcccgugaguccccggccpuggcupcu\n", + "guccaaucuuauuucccacauagagauuuuggcuaaauggcauuuuugaaaacauguuguucugcagugcagaaaacacggaguauagaa\n", + "ggcugccuugaggagcccaaagcuuaapucaaguuuuuuuuaaacagacaggaggcgaagcaga\n", + "guacgaugauuaguuuccaauauaaccacuapcccucagagcaagacagapacguugaauucaauguggucguuugaguuuugguucugguuuuugagcaggcugagaacag\n", + "auupagaggaaauucuuucauugagaapaaagauuuucccuagcapaggcuaugaucuuugugcaauccguggaccaggaaaucggcaguuacuggupaagcaaaucauuug\n", + "cgcggugaagcgccggaccpcagcucuagccccucgugccuuuggcpaggcucccagaguccucgcggcgaccgcagucucugcggcuucugug\n", + "gucucauagaaauugaaacauauucaaaacuggaacauagugcuauuuauucacuauuugcaugucagauuaaauaaaucaaaaacuaauacaccaagacugauauagaauauaccugacau\n", + "uguccuggucuaggccupuapcagcccguguccucacuggugaggucacagucccucaccapacagaugaa\n", + "gugccuuuggaucguugccucuaggcagcacappcacaguguggagcucaaucccaucuuuuucagau\n", + "ggccgcuuccggcpucgcugcucggaccugcggcpagcucgccgguggccggcgccucpccggcgccccccagagcaggagcgccucgcuucuccugagucccgccpccaagaccgg\n", + "gagguggacpaggaaaggcauappaagccguucgucggcgccaaggaaapcuuucccguuug\n", + "agagcaccgccgcugccguugugagcacucugagccgupaccugagcggcccapacaugcugguuuaugucgacagccgcccgugcccgcuupugcugacugcaccagcc\n", + "gcgcucucgcgccguccaccacagacgcpacugcapagaccucaucuaccaucgapauuagauccugagccucgguccagaauccccucuaccag\n", + "ugugacucuuggcucgucuugcccpugcugcccaggccggcgcccggcgacgucggcgaggcccacccccpcucccgucccgccaccgcgcc\n", + "acpcuuugaccaugccuuaagaguggaagacugugaacucggagucacuauaauccagccagaccuccacaacagcuugaggccuuagccgcag\n", + "gucucgaapucccapuucggaucagcuugagugcgcgcggccuguggccpcgcuuugguuacag\n", + "ggugccagcgaaggcgcgcggcuccagccacgcugcuuccuuugguucugcccucuuccacccgccucccgcucgcggcuggcaaug\n", + "auuccugaguucauccagcaggcuuuugagguucguuuugaaucaaagapugapugcccgucuugugguggauuauuucuugcgugcuucuaug\n", + "gccugcgcgugcugaacgccgcugcucagaaggapagcuuggcccuaagcccggccgcgagucggugcaugcagagagagcccggagcpcgcgcucggccpcggag\n", + "gaggacccuuucuguagccgagcgcaapuucaagagucccgcaggupcapcaaccugacaguuaugcuucccgcguuuuauaag\n", + "gaaaaauaucccggucagugcagcuaagcuuccuuucauacacuccgaugccccagcccaauauuugagcucugguuucccguuugugcaucugcucacugcaacgaggaaccca\n", + "agaguggacucugucggucugcgccgcgaaguccpaaaagacgucgacpuucpuupagaagugaacuuuaagauuaaaacaugccgag\n", + "ggucuuucagcugcuaccucggagcuagucagagcugcapcagcuagugguuugauugcggccc\n", + "gcuuaaacccucgguuugcpcagagcpaugagcgaaccccggcgcccggcuuuccucccggcuuuccgagccgcggcggcpagacgucag\n", + "agccccagccuccgucuucugcucagcuggacuggcupacccuggcuaggccugugccaggaapauguggaaggacuggaapcuuuccacgcag\n", + "guuccgaagucuucugucugaguuguuugcuggcauucucaccuuguuuccuuagaucgcguggaucgaccucp\n", + "ugucgacagagcgguggaggagacauaggugccaugcaccgaaucuuuauccgcugucuacacugccuacgcgapacagccucaaacccacaapagcauc\n", + "ugaacgcuucugucgcccucucugcgucccgcacucggcucuugccaccgucgcaggcggacggaucccgguuggaucgaaccagccccccugcuucggcuaccagagacccaupcuucg\n", + "agacccccccagguuuccugcaagauucucagacagccugcaaggaaggaucgcgguccucgacccguagguccccguccacc\n", + "agagcguugccacaccgagcguaccagucucucccgcupccucgcccugcccagacccgcugccgccgccaccaucucuccccguguccucucacuguu\n", + "acccuccupcugagacuucgccccccacccccupcggcggcggcacccggcccccccaccaaacc\n", + "agacggucpugguugccggcuucggcacucapagauccaaggagcpapauacuuggcgcuggaauucgccuggaaguccggagcggcucaacccguuugcgccpucpa\n", + "guaucaaupcgcuaaauuuaaggauaaaaaaaaaaaggugagaaaagcaaagauauagucaaaupcagccauacauaaacaa\n", + "auuugcauuuggagaagcaucaaaagcuccagcuuccuaggcagcauuuagugaugucauaauaaaagaaaa\n", + "aaguaaucuaaauccugcuccauccagugacacccgucuacaccaaagagugcccuacguccagcaagaacaaggaaacag\n", + "gugucucccapcucgaugucugcagacaccaccuauuucgccugcuggugcccccagaaauuggccgcugaagcg\n", + "gccuucuccuggcgcguccgcccuugugugccucagcuuccugcgccggagguuggagaugacagcgccuuaggccpaucucgcgucuuccuacccuccccpaccacagcaggcugagag\n", + "gcuugucaggucaggcpccgugagccpuupcgupccpacagcgcggcggcpcpauccaggagcagccpaac\n", + "cagccaccgccucccacccuccggagucucagccuucacauuagagucaupaagucccccugauugaagagccgagaacauccagaacuccag\n", + "auguggugaggagccuagaagcugcccugaagacuuccuggccuucacucgcgucucaccuccccugccuccuaccaccggcuccuucugugaggaagagguugcucgugacccucag\n", + "guggcugcggcggcggcgugugccgcggcccgaguccgapagccuccccuaccccagagacgcagcc\n", + "gacacccaaccucugacgcuggauguuagcaaucuagauugagcuuuugcuugauuagcuuuggauaauuuaaugauuaa\n", + "uugagucaucagapuugcaggaacggcuucaugguaggagccacccugccgacaucuaucuguucguggcaguugagccac\n", + "ggccugacccucuuucucgugaaggcugcucuacacugaccaacuugcucggaacaguucccugaggccapcugcauccuugaucacuuccuccuucucccuagugcu\n", + "ggaagaupaucuucugaagguccuguuugugagugucuucuggapugccaaagaagagagaagccaggaaggaggaagaaaaacag\n", + "gcccppcgaggcagcgacgccccgagaguccccccaacuccaacgccgccgcuccacccccauccgccccugcccuuccapcacggcgucc\n", + "cuuccagcaagagagaaaacacaaggagagugugaagcauucugagagcucucccaupccacaaaugagaagaauauuguaaacaccaaaagcaagcccapcccaggacc\n", + "gcgguggcgccpcpagcgcaggccucagcggcgacgagcggcucgacgcgacccacgccccgaccccguccccccucgcacuuccgugcugcggcgcuucugccuccuaaccgaggaag\n", + "capaggcucggcccugcuggccccccpcgccgcgccggagcpacgccpcccgcccagcgaguuggcgugcgccuugcgacuuuagcccgcggcgucgcccgc\n", + "gcuccgcagaggapapagcuggcuggagacggcggaggucgcagccacuguggagcgccggcggcggcag\n", + "paggcuuuuggagcupaaaucucagcucuucucuuuauagguagacacagacccpagccuugauccagc\n", + "guuggaaguuccaacgauuagccaagaagcacugcacagugaccuuccggaugagaguggaguggugccaauccaagaucag\n", + "ggacuggcgcpuggcggcgagaagaggcaguagagcgagcagaaagaggaggaaacgaagaagcacaggaacc\n", + "ggacgaaagaaggacauacccgugccuupcguccucagcaaaggaggagcugauauguuucucccagagucauugacaggaccpucgaagcuggagaacug\n", + "pagaagccggcagccpaccagagcugccgcuggcgupagcuugagaguugcgcuccgagg\n", + "ucccucucpagaaaguggacpacuugucaupauggugucuacaucucagguucagaguccaaguuacuggccuaagaga\n", + "gcuauugauauaacugacuccacucacagacucuuucgucgccacuggccccucgcuccgccgagcgcggccacc\n", + "agcagaagcucaggaaugaucuccagucacaggacacaggcauuaucuuccuggcaccaccaauugcagcaguugccuccacuucacucaccagcagaacg\n", + "cccaaggaaauacaccuuuagcccuaaaucacuuauugaaugaaaaaauaauugugauacauupaucucaugcggaagaaagaacuuaaaacgaaaccucaggaag\n", + "guccuggaguuaucucagcagguaggugcuccaacuccucucuuaggaaauccuccccugucuguucuccucapagccgcc\n", + "pcccgupccaucucgcuggcugcgagccggccgccpcgcpcggcugcccaggcagaggagcccguggagucccpccggcgcuuggcgccaccpagaagaaacuggcgagcc\n", + "aaagaacaaaaaacucccucgucaggugguugugucgcagcgcccuuuucucucagcaguaaggugucuuagcccaggaaa\n", + "ggaaccucagacccucuaagcccapaggcaauucccupucuccuccaagaagaggcccaguuugcaag\n", + "agugcgugugagcucugcguggccgucgccgugugcaccucggaugcggcgccggacgcupccacagccgcgucccgcgcccaggauupucggagucccuccccucguuuaag\n", + "cuucuuccucgccgcgccuucccggucccgcccgucggcacuacaaccucaguacagccacucggacucaguccuaggugugcggcucgcaucuucaagccugaag\n", + "gcggcggcgccpaggcgccaggacccgaggcgagaggcggcpaucaguapccggapcagcgguagacgagcgcag\n", + "ggaggaccucugcgaccccgcggagucuccggaggccpapacuccgaggagcgccgcugccgccuccguccauc\n", + "cuccccuugguuggugccccgucupcucaagguagaguuucccaauccacgucucaagcucaugccacpaaacucaucuucccggccugcucccacgg\n", + "ggccgapaagcaaagcccauaccuucuuccccucagacgcguupcggagagaggcggugcupagaaggaggcccgg\n", + "gguuuggcucccgauaagaguguaugcuaupugcacuuaugcggaaagcugacauggaaacugacagcucaauagugaggacacu\n", + "ugcuggagacccccugcagcuucagccaagupccagagcacgugcgcugcugaccccucagcuagcacccacaguccuccuapacugacuccuccacuguucucauagcugauag\n", + "ggagucucccggcuucgucuuccuguuuucgaggauuugaagauuacguuggagaaugccugugaacga\n", + "cuggacaguggacauuuggaggcagagacggacaacagagcugucugaagaugugccaguacugaaggaaagcauccccggaagcuaacacacauaccacacaag\n", + "uccucccuccaccuggccucagccagcaucccaccagcccuupccugugagucagccccacucagcagugaauccccugacccggcc\n", + "cuucgcaccgcuuccpaagguggaggcpcgaggcapacuucauccgagaggaagcuggaggagaggaagagacc\n", + "agaauccccucpagcccaagacccgcggcccgccccaccgcgagcgcaggcggaucaggccccaccaac\n", + "uggagaagcagaauuuuugcuuuguccaggauauuauacuguguaaugacauugaagcuuuccuucuguucccagauuaaauucuaacagauguaaaagaaucucupaaggaaag\n", + "gagacgcugagccuccpaauccagcaucacggucacucacugapagcuaauuugucggucauaucugag\n", + "aguaucaucauuggcugaaagaaccgucccuaaugugcuccggauaaagcagcagaaugaggcag\n", + "acugccuccuccccuguguguaaggcacugacccucuggaaucggaauagucuguapauuccugcupaggaagcccuuccugugaggcupccagauucauggcagcaa\n", + "cuucccuugccuuuugaggaagccccapagcgucupuauuccgcpugaaggaggaaaaucaucucagcugagguaaaaauggaugaugaggacugccuuccupcagaagaaauuccag\n", + "guupcauuguuaacgaagucccaacpagaauuccauuugacccagcgcupauguccaaaucaagaaaucccgguuagagccgagcaucaugucc\n", + "apauccugapcupccapucuccgcpcucuucpcugcggcggccagcccccccuca\n", + "aggcuaagcagagcccaagagaccucccagcggcggccggagaggagapcupaccgagcaguaggagccagagapagg\n", + "gcgcuaggccgcgapcupaugacuccgcucappacgccgccaagucuacccucgcguccuucgcggccgaggugcpcuucgacggccguggcggcuggcaugagcucguuggccagc\n", + "ucuggacagapccpaagcccuggcugacuggapcccagguaaccauuuaugguuguaacug\n", + "uaugucuggacuacaggaaucugagupuggaggaacaaucuggcapucugcuggapuguuggaggagugcuggugcgaaagcapucggaggaaacap\n", + "gcaguuuguuggaucagcggaggacuggugaapagaaagacpacuccugcucccagaccaaagacuggaggaaaaaag\n", + "gupcggucggcggcgccgcpcaagagcagcuccuccgcccgccccccggagguugcccgcgcaucgcuguccacgccgcaauc\n", + "gaggupugaggagucuuupaccpccugaggcggcgcgcacggagccgcgcggcccccggccaggcgcacagcucucaca\n", + "agugugaagcucccupaacacuggagcggcguuccgaupcggagccccucccuccccggugguuacgagacagcccuggccuugaucucggcuucuggupacuauugcuuccuucag\n", + "gguuacauucucgugagguccccgcugcucgagcgcccagucugugcucgaccagcagcgcgugaccgcp\n", + "uacaaagugupugguauggaagaugguggaguuuupcuggagaguuugugaccugugcaucuguggaugga\n", + "aaacgaggaaggcucagagcugaagaugagccuccaccugccgguugcccugagccggacacugaagaagcccagcggcaacgaapuggcgcuguc\n", + "cacccucgagauggaucaccupccucuggaaaagagguaaacgaaggagaagcuaaaaaaaacuccugagcccagcccaggaag\n", + "agagcuccagugccuucaccguccuguauuagcagcuccuuggccuucuuauugccugugucuaacugugaacgaggcccacauacuauucugaaagcaucupacacuuuccug\n", + "aaaaucaaugagccuggupcagcacaccagcguaguaccuucaccuuauauaaacuupacccu\n", + "ucucuacggugcacugacacupuguccagagcuucugaguaggcaagupcuccggcuggucapagucccucapagcgccapcucucagcagaguugccugcucagguuaguacagg\n", + "gguccuuuaagaguugccccucaggauugugugugcapcagcaaaguauuuucagccgagcugagcpcguacgcauuccggcaacuag\n", + "pacgcucuggccauggccgagcagcccacpaagucgcuccpagccgcccacccgcucccagaacugucagcgcc\n", + "gugaugcaggcgcggagaagccggagaugcugcaugaggagaagcugccagcaccuaggcagccaacac\n", + "cpcugcgcgcgucupaccpugacgugacgguuucpugaucgcuccuggcugucgccucgugap\n", + "gccaaccugagcucucugccucucuugagccucugguuccucauccccauuuucagaaggcaccggagccagcaucaacagcagaccgcccagccccucguuccccuugcccgg\n", + "agaggcupcccgagccgguggcgcggapuguuggcgacggcagagcgcggcgacugcggccgguucugacgcucccggagcggcuccuggcgguuucgguggucccapcuacccag\n", + "aauucacapuuuguuuucauugaggagacuuacugcacggugcuuaapacggaaggagaaucugugccuuggcucaaag\n", + "pacucugucucucgauggacgcccugugcpcagguuuuccpcgcagauguucggugugaggagcacuguggaccccuggcucucucguuggcagcaagaaugucaa\n", + "gauuuggcaauuagguacagcuccagugaggagapaauucucuuuccaccaacugcgaccucccgcag\n", + "gcgugcgcccugccuuugcuugugapagcuguucuggacapagcugaugauuuugaugcgccgcagccucgucggaggacagaagcpaacugccucugcacggacucccpaag\n", + "pcucupcugcaggacugacgugcucucupaguccagcuucapuacgapuggcgagcuccgagcagcgcagcacugcccgcagcccggagcagccagcaag\n", + "agguaagucucacuacgaucgacagacccaagauugcucagccccgaagguagaggaaggcgaaagccugcccauucacugugagugauagaagaauucuauagaaagcacagaacauaagc\n", + "acucagcugguauuuugaucagagaaaagagguapucaguaguugauuaugguugccccaggagcccacaucugugaauuccagagacaguuuuugaaggaaug\n", + "gugugguggaauacaaugguguugcggcaggaggcuggucaaaauucgauggugguccucacagaaggauuuuuccugugaucccucacccugugacauuguagcaaag\n", + "gcupacagcggucucuuuccuugcucauaaaaucuaggacaccaccaaauaacgcuuuugcagcaaa\n", + "agaccaaggcugcuggagcgcagcuucccaccugucucgguucpugcagaggcgcgugaacucugag\n", + "guccccgcugucggacgccapacccccgccacgucpaggcuaguccccccgcucccgcgcccccpcucgccpauapucgagaacuccucgcc\n", + "gguuccucugauugaaaaccaccagcuuugguggucugguauuuggccacucguggucuuaaagaauuuaagagcgcuguaagccgg\n", + "agaggapuuuccuuuuggcuucucpagacucaccucgagagaaguucucccauucgccgguuucccpcgguuaccguugcgauccccaccaag\n", + "uugcuuaaauugauacugauucugaaguuaaaauuaacugaaaagagauaccuuccagguuuucaacug\n", + "acacacggucupauuccgccccuucgccgcagcuaccgccauccgcgcgcccgagcagccgapccuggugucpccccgcaggcuaccgaggcggcggcag\n", + "aucucgccccuucgccgcuacuaccguggapucgapagccpaguccucgaggcaguggugugugcccacpcupccggccpugccpuucaggaguggcugacaup\n", + "uacuauuggcagauuuguggcugcgauuaggcccaagaugcacuuucaccauccauuuaaagauagcaguucuccucgaag\n", + "aggcgugugcucggcggagcgagcagcacpcuuccgcggcugcagcgaggcgcgcppagcggcagagccagcagcgagacccgcgaapacpcggcggcuuag\n", + "gccaguaagacggugaggaagcgupaccgagcguggcuuccgacpcugcgupcgccggcggagaag\n", + "guccugccccucggcgacugcagcccacucggucaccggccuuuccacgcuccgucugapccgcggccgag\n", + "cucccuupcgcggugcgcgcugccgccugccpuccagugccacccugaggugccuggacgcguucuccuucagccupagguccugccgagccag\n", + "gaaauggapcacacgaguacuaacugapauuacacaggaguuaaaccucccgcucccaggccggagcgccgcugcc\n", + "gcaccaacccacacggagaucacgaacaccgaaugcuuuccaaauuaucuggcccgaaagaacuacacuggaccaucucguccugacaagagaaag\n", + "acugaguuagcgcuuuuccaacuccaacccgucaccagauuucagccuuugcuccagcaccagugauguucacacgcggugacgagugccuacucggugupcpaugauaaccacuca\n", + "guaguguuuccugagccacggagaaucuggcauugcaguugccacucaaacuccuuuccgcaggaggaacuaauagupauuacccguaaaaacug\n", + "gcpagacccuguccgcggcucccccgccugcgccccacccugugugccgucuuccgaucugaccccagg\n", + "gcuuuuccaaaugcgcggaupcagaaggaaaagccuuaaguucccgguugcagaagauguugagg\n", + "gcggcaagaagagcaaaggaggcgacgucpcggaggaagcggaugcccuggucgcpcugag\n", + "agcgcuucccgccucccggcgccggcgaggagcgcpagacupcuagcpcaapccgcccpaaccag\n", + "ggaagagguuucaugcuggaggcacucggucugccuccuacccgucacauguuaguuucccguucccuucuccacuuuccgauguaagcccugugaugcagcagcaggaacucuaccupcagcgc\n", + "ggauggugcccgguuucugcuguuguggagaugucuuucugcaguggcccguaauacaccupaaucugugacacugccuucggcccaagaaacug\n", + "gcucaccgagaaaggagagaggcpcuagaagaggcggcaagccgauaggaagaggccacugagappagaaau\n", + "ggcucugagaccaagcuaagauugcccaguagguguguuguugugaagagagaccuggcagcacugccagccaagaaugguagacccagacuuucaac\n", + "gcggcuucucguuggccuagaucgcaauggacpcucugaccccuccpucuuccuagauucuacc\n", + "guuuaccuugucaccuaggcgaapaagapupcuugcucccuccucguacuuucgcaccuucuuuccuggcpaauuuccuucagcgacag\n", + "gcggcccpuguaaugauppcgcpcucugccuugaagguguugcugcucaaaaccupaccapucuguuggcgcggaccapcggcggcagcuaccccgcgcugcgag\n", + "gcagucugcauugugagaguggaacauuucggaucugacggaagaaccagagauuuuuagaugcuacucaucuucagagaauaucaaugcaaaucucgaaacaag\n", + "gugcacugguucuuuggagauuaaapcagguggucagagcagcuuucagaauugupuguuggucucggcagagcuuggcugacguguggacaguaagacuugaapccucup\n", + "aacaucuguaggcagagagcagcgcuupagugaggaagccaaccauaacauupuccuggaaaaaccagaguuccuguugucacccaugcugaagaccuccuccgg\n", + "agcgcucacucgugucuuugcpupcggaaggaguuggugucugccgaguugcgacpucapuugcaagagaacagacupugguuuggagcccaugaaacucugguuuggcugcagcg\n", + "ggagcugagcpugcagcaggugguccagcugagugcuucccacuccaggcaacccucggaguucccgcgcgcccagacgcgcgcccggcccgcgcccc\n", + "gucccucuccaucgcaacggapauucpcupagucagugcugagaggaaaugagccuggugccuuaaagaaag\n", + "paagcgaggagauuagagguuccagcuugguuaagugaauggcagcuggaaaugugccccuguguggaauccucgccupcaag\n", + "uguucuauuuucauuguuccggaaggaccagcaapcuugucugugaggcucaaucauauguugcupauaaag\n", + "agaupagcguggacuacpccgaggcguuucgacpaaggcgccgaacccuuagccccucguuccuguuucagcaguucuuuaucaacuupacccucuuccpccpccaccgucggc\n", + "aaacugugupucgguugccaccacacaaaagaugagaagcuacugaggaggaaccccgugucuupagacccgagcccuuacagacuucgccaggag\n", + "ucuuucccucuaccugcucguacguggacucuuccuccgacccucccuuuucgcccuccgcucaccguggcuccaccggcuucccacgucccacgcccccacc\n", + "aaaagcpuucagcgupcupacacggcgacguaguggcggcgcpcccggccgcggcuggcgccgucgcc\n", + "ggagcgacggacagcuggcggugcaggagccggcuaaapccaacppuaacupcggcuaggcggcuapucpcuug\n", + "ggucuupugcuuucagucuggaggugcuggugcuccucgcugagcugcggagugupaguuggcagcugcagccccugguuggagcgcpaaucuauacccaucgcccapuauuugaaau\n", + "aagcugaguguapaucuuugccaugugucaugagaccuccagcggaaaaacagguccguccuaggucuuacaccauaucgaag\n", + "cucccgguapcaagcugcagccgcggaucggccgagcccugauacgaggaaggcucacpaccgagcagaggcccaggcpucuccgcggagccggcagacau\n", + "aaugcaacagcuagcaguguucaagagugaagauagucaaagaacaucaagauagauaaguguaauuaagcapaaugaaauuaug\n", + "pagauuuguguuuauauuacaguupauauugcaaacaugucauccuuuuccagaaapaucugcgau\n", + "puagcgcagaaccaaggaagagacaucacugccgcggccccugcggcgcgcgccgccggccgccgccgcc\n", + "agugcgccacucguggauccucacugaagcguguccaggcugcccacaggccccuguccgugaucacuggcaccc\n", + "guuuguagucggagcaacgccgcuuugaacacaaggcuaaccugguggaggcucagauccagguacggccccuccauauuuccaugugguaugcugaugcccuguagcuggacag\n", + "gcacgcguccaacgcucapapcggcugcggcpacgcgagcgagcagagagcgguuggagacpagccgagagcgcccggagaagccgccggagccpccgcpuagaapaga\n", + "agcuaucaaacagccuuagagaaacaacagauaaaaagcuggagaaucucagagagcaauugacguaagaauauaaaccuguacuggaucaucaagguuguaguguguuuggaggcauuuacaa\n", + "ugcgccggucgccgcccagucgagagcgaaauuggaagguuaguggcuaggagcagcgaggcgcgagagguuacgacuuggcapcugcgcgauugccagaaaugaagccuu\n", + "gaaaaacagccuccugacuuuagcauucuugcugagauuugcapcacaagugcuuguggucucgugagccccaagaug\n", + "cuuuguguugccugaaaugauggaaacgacpcugacuuccuagagaggagcacacaguguuuauccuggaguuguauuccaua\n", + "agugcgugauggcaccggcgaagucggcagaacuuuucacgcaugagcpaagucgcuupaguuuacagccuucaaaaacaag\n", + "cuggauugaucccggcccccaggaugapaggapacpaaaccuguuuuccuuaaccagagaauuaaugaaaagaaugaagugcuga\n", + "ccugcuuccucccuugcucaccccagguuacggcugccgucaccgugaggugguucaugagcuuccpaagacagaggaugagcuugaacuggcaucagaagccupauaccggcacugcccag\n", + "ccgaacuucccaguagaggaccuaagcaccagcagagcggcggcagccccpaacugapagcggccagcgccccgcgcggccagagcpcapcgcugcgacc\n", + "gugcpagagguugcgucgccacgcuggccgcguggccccacccgcpagccugcgaaaccgcggacucuucuccucccagcugcaaacuucugagaagccpccugcgag\n", + "aaaaaucgcgaugacccucapugucucacggaagguccuguaacucupaucpauuccugccagagagcuagacuccuggupcucggcggugguugcucag\n", + "ggacauuucagcacggcaucacauuupugaagacgagaucuuggcucauacauuucuguucgguggucugcagucaauguugauuauccuuucaaguuauuuaacag\n", + "cupcaacaccccgupcuggaaauguugccagaggccgucgccauccagguugaauuuggucagaaauggaagaag\n", + "ugcagagagcaucaugcuacacagcuccggccccugcugagauuugucccuucugcccaggaaagccuuucuppcuccagcuugcuggaugagccacc\n", + "aaaaaaugcugguaucuguaucugauuaauaggcaaacugcacugaucaucacuuuucgaaugucacggaaaaagaacucaaucuuuuaaaccagcuaaaguuaag\n", + "agagguugucpuguccgacgcggcpaccccgccgcgacuucccacccagagcggcggccpaggucgccggccuccgaggaguccaccggccgc\n", + "auugccuucgcuuucucccuucuggagucacggauuuuccaauucuuugcagcauaaagupuguuuuacaggapcucccuaacagaacapauguaauguaaugacaccaaaagau\n", + "gcggaugaggauggaauuccgcgccagcgugccupcuggaupucugucgaacccgaggcugcuggcccag\n", + "cgagcgaagaacaggcaaccgcugguugcaguaagcugagcgacugcapcgaccugcagagucccguacccuacagcaagaagagagaapauccaggccugaappuaccccugg\n", + "agcgugucaugagagcgcucaacagcucaggugugagugagupcggcggcupcuggaggugaaggagaagccggacaggagcucuacucccggucuuccaccaucuuggag\n", + "auuacuggccuucucuaacccgguuuaaggcugagugaaggaaucagcuupacugcgauuugaauagugagcuccccaauc\n", + "ugugaaauccagccggagaaggaaagcgacuucuuuggaaagcuupuggugaauggugccupaagagcugcpuuguuaggupuuuugagaucg\n", + "gguccgagccaggcacaccaucucaggcaaaaccaaaaaaugacgaaaacccaggaaagccacgcgcgcpagaggaaaagaaaaaaaagagaaggaggaggaggaaapacccpacccugaag\n", + "gaucaccuccaagguguauagaupucugccugauaccccaccuggagacaauuguagacuguuaucauacugaaucugag\n", + "caccapcuucpuuuaggccccugcaagcggccuccaccugugcgccucgcgccucccucgacuccccgcccuccuggccaccgucupcggcagccgcaucccpcuccugcagagcggc\n", + "cucuccaggccpacgccggcgagcgcgcacuggcpcuccgaggaaacggcggcaapcpacuuucccgugcugugcccggcpugcgcuaauccgaaauccucggccuuugcuggacc\n", + "acagcagcacagacuuugccucugcccccugucucagguccuuuuucucccugccupaaccugaucuucagapcuccccaucccaga\n", + "acacaauguguucacupagguucagccucucaaguacgaggaaggcccacauggcacgcuggcguggauuag\n", + "gaccaugaaauugucagucucuggugugauucacacuugcagauuuuuugauucagaucuucccuggagcagcu\n", + "guggaguugaccaaguugapacacuggauuuggagagcaauuccguaccagccucgcuggagaaucucaagagupauucagacuggcuguggccagcupaacugccucacgcc\n", + "gugcaccguaggcaaagcagcucccucucuggcuggaugacgucgcgcagguccuaucuccccggccccgcccccag\n", + "gaaagaacucagacagccagacgccacgcgaccaacccaagccccaagagaaucacaacacacaucccacuucccccpccacagccgccgccacaaccacapaaguc\n", + "agauuaggcucaucagcugugugaagugaguuggcguaaaucugagaccccaapacugccugugguuccuccaggaaugaaggaacuccagaaugaagacaugaugcccacgaagaaag\n", + "gcpaaaaggagaugaagucagagcacgcagagcauccggcccugaaggagcapaccgaaagguagcggccgcugu\n", + "gapaapaaugcggaapacagcugagccaaugugacacucuaucgaagagcuggcccapccccpucauccuccgcuggccucucccauauaacugccccgcc\n", + "ucucgucgcagaccacaugcccuccgcuguggcugcacuuggagccgccgccgcggacggcggacuccggauccccggagaggcag\n", + "aagccugcgcggcgguguguaugcugupuuppccucpcgccgapaaagapacucccgcaapcugguucuggcaccc\n", + "gaggugccpuagcuggcucgagcapaacccggcuugcaccagucugcgcggcucagcucccgguagcc\n", + "aggugagguggcgcuggccupcupccgguggcgugugagagagcggcgucuucucgauucuuccagccucauggaucugcgccpagugccuggaccccupapaguuuugcagag\n", + "cgcagcugcgcgaaagcucgguggaaacaaagugcccaagcacuugaagagguuuggcagcuccuugucccgucgccucccuccuggucugacggcug\n", + "gagcccuaagaugugcuggugaaaguggaagapcuggcccacccgcaguacccucgguggugucaggaguccgcugccaguucupcccgcgaag\n", + "ggaaugaugcugauaaaagacuguuuccccuccagcagcugucugagaaggcugagcaggaguccuucagaaaugacaaauuuuuacgugucauauauuuuaaagcauuuug\n", + "auaauaggccagacgaagcuccpauggcupcccuguucucguaacagugaacgaaccuuugucgag\n", + "guucagaaacuuuuacggccgccgcuuccuapacccagcguccuagacuuggapagguucpcgcccuggacucccuaccgcccacgcugugcgccpag\n", + "aauacpaggcuguuuuaaaaauaauuugauucugucagcagaaagaagauuggagaauuaaauaaugagaaaaguggcaaacuuuuccgucuugcugcupugccuaagg\n", + "aagaggcgccgcgcagcgccaucccugccgcuccggcpcaccapccuccggacgaucgccaaggcagugaaggaggcapcagagagcgaccccagcgccgccaggaaug\n", + "cuuuuccuguggagcaguaugcagcuagugagcacaaauggauguaguugaagcuuuaggcacaccuucaccaccaguggccauacggauaccuauacugag\n", + "uagaupaggaggaguuuuuggaupcauaugugcuggagcuugaggaugacacgcugaggacuggauccag\n", + "cugcagagcuccgaucugagapagcucacaaucpaauugaggaugauugacccaagccuuucaaccccaguag\n", + "acugugcccupaaggcapaapagguggagccggaaggcagagcagacugaggucugaggccugacacacugag\n", + "aucgcauguaaucugucacuuuugguguaagccuccaccuuccugcaacccacucaucucpaguggcucaggugugugucgcag\n", + "agauaugaacaauggcccuggucugagcauaaccauucucuucgcugaguccuuaaupaagaauaguauuuggaagauacuucuacaucagacuaaaaagcaaccauagcuuuucag\n", + "agauaapuuccagcapcucacpagaagccaggcacaagucgcaapuacagcaaaccacccucagaguuuggaugauggaagugugcugagccgagaagagcgcugccgcgcgccggc\n", + "gcguupccugauguuaggccpaaccggcgcagccaccgccacccgcgcacacuccuuccggccgg\n", + "gugcapacagucucuguuggagaaagcucuuccugagguugcaggaacuuagaagauggagcugccagg\n", + "agcgcgccccgucggccugacaccucuggugupcccggagcgaaaugapucgcgcggcgcccgga\n", + "cccuucccccgccucupacgguccpugccccguccupucuggaccccgacucugaguggcuggaugaagccapacugcupcaaggugaggcugaagaac\n", + "pagcagaccgugaagguuuapcuccuuccuaugguggcuuccuacuuguuaacacauuuugc\n", + "ccacgauuupaagupcugagcucugcaacuugaaaaagguuagcauuguggugucugguauuuccaguaugcucauggapcggag\n", + "caucugcuacuaauggcaagguaaguuggacucaggaucaaaaaagucagcagucugcugagagugcauuucauaua\n", + "auuuupapcauucaagaaauuguggapcuccggcacacugacuccagaaaucaaacapaagcuucccuuccauagaggccaugaacuacacccaaugauguuguugaauag\n", + "acagagacagcggagucaacagagacagaagaagagccagaagagcggcggcpcccagcagaacgcgagauguupacpagcgcpcuguag\n", + "ggcgccucgugcgcgcgucccaaagcguccucugccauaapugcguucguugaggcugcuug\n", + "ggagccuguaaugugaccaugcagaagaccacgaugaacuacucacacgagucuggugaguggaaaggaggaagcagcuugagagugacagcuugaapacuccuccucuuuccugaacagaacug\n", + "cuagagcacuggacugagaacccggcccaguugaagagaaguggcuuccagaaaaccgagaacuuauuucuucaagcuucugucauugacgcag\n", + "acggaapaaucuuaaaaauugcugcaagaaacaacggaguucuuggccuagcacaaaggagacacpaccagugaccaag\n", + "gaggagccugcaggcpaggcpcgagacccagcaccpacccpucccgacccagcugcagcugcagccgg\n", + "accaaauccuuggagagcucuuaaaapcpucupcagugcagcuuggaguggagguggcuauagaaauccuggupaccagcgcucuucgcaacpaguagcagcuggagcuuagcag\n", + "gcauucauuuaaccugauucuggagaugaaauuaaacagaacaaugaaguaacuuugaugucuauucucaugaugg\n", + "cacugaauacugacggugaaucuaccacaagaauagguggaaaaaagaacugagaaggugcccauuccuacugccaucugagagaguugaucauaagaaagcuaupuugccuagcaug\n", + "ggugugaapaugcaggaggcgcuggaagccpcagugugucagcccggcgccagaggagcucag\n", + "ggcupcupcggcacccgagaggagaccggcgcgacgcgaaccgagccaguguccccagaggcgccccccggaagagacuucagagucccpcuggagucacagguugg\n", + "gauggagaugauugugauuaggagaaugagacuucauuggugaaaugauaaauuuaagaaaaucuguaaacucaaggauag\n", + "ggaguccaaguagaaagugcuuuguuuacauguuccuauaagauuagccaaccuggacuucaaagcacuccauaauguggcagagcucccugcuuucuuuuuggacagcuuuucugaag\n", + "cagguccuguauuucugcuuacacggcpcuggcgcggaggcagcggcucccppagacgcpcgcgacpcagcpcggcgguuuaaacuuccgcc\n", + "gaagaggcgcpccggcppagcagcggcapccagcuucgcggcgccgccccaaccccgcccacaccccgccpaggcccggcgag\n", + "agaauaaccaacaugguguggaggcagguauuucagccagaguggagguuuuucagcuuuagugaccaggagccaag\n", + "gaccaucgagcagauguaagcccagugcagaauuagcuggcuaaagaapagcauacgugauccugcuuucccgcucuuccagccugcagucacc\n", + "aaauauuccaugucagguaagcagagcgaggaagaccuccugaagaaguuuucagauauucuggacacugucccgccaguuuuauaguuguccgaguucagucgcupuucucagcccagaucug\n", + "agccucggcgacgcagcgugcgucuuuaccgagcuupugcgccgagcugagcucgcucggacucuggugcggcgaacugguccuuguccugcagucgcagcc\n", + "ugagauccucgcggaggacuguggcgugaacucupucgugucgccgcccgccuccgcguugcaaacucugagcggcccgcccucccacugcggug\n", + "guacaugcauaggaggaaaggcgcpaaggaguguagapcauugguuggaguaapuuaaaaaaugagagagccccugaaaaguucaaggacuugga\n", + "guuaaagaucagguaggcuccaagcugagagugaggugaauccagguuuuuaaauugcugucugupuaguucgucuucucgaaucagugcacauaag\n", + "agcucpccapccugucgcupcccgcccggccccgugcucagguguucaugaaggcggcacpuguugapcgguuagcupugcugagagguuggaggagg\n", + "uuggacuuguucaguggcuaagcccagcaguggacacagcguugaaggaggagcagcaggcaaacccgcuggaggaaagaauaacagguggaguccauguguccaguuguuuuc\n", + "apacuugucgcugagaaagcauuucccggcaggcucacgaggugaccccpucauagagacaucucg\n", + "aacguggagcgucpagacagcguccpucucaccccccgcucccguccccgccgccacagcagacucucpuccpcaccccggucccccacaggcccagcgcc\n", + "auggcaaagaauaggcuuggaagauuacguuuacauguggagaucauuuaucacaauucacagaacuucucuguuuuuuuuggagccugcaucuuacuuugucucaaacuuugcaauc\n", + "agccgcaggaaaggcucccugcuguguguaggacugacagcccugcgaapucuuugccaucggag\n", + "accgccaccugcacpcugcgaucgccgccgcguaccgcagaguaaugaccaagcgugauagupcauaucuugacagcaagguapaccgcugcu\n", + "ggugaagugcgucuucuugcuggccacggagaucuapuucgcugacuggaugugaaucaccccgcagagaagcugccugaauuugcugacucaag\n", + "ccgccauccggcpcgcpaagaggaagaguagccpccupcuagcggcgcggcccagucpagcccgacuggcccgagcgagcacuccgcaggccpcgagcccgag\n", + "ggacgaggaggaggaggaaggagaapcacagaugapaggaaapaaagaagaaaaagaaaaagaagaaagaaacaaccacauapaaaa\n", + "agaaagaugcaagagagcggcggcaggaggaagaagcaagaggapapcggccpcaggapcggcagapcgagcupapcagcagccgcgcag\n", + "ggauuccagcugccauaugupacuccaagaaggaccccagaaaugucucagauuucuacugagupaagagcucccccugauucaagucccuguccuccagcg\n", + "cggagccggcggccggagcuccagacagaggccagcucpauccgcgagcugguggccggaggaccpagacpagcucpacccapcgcggcggcaucucagcggcuc\n", + "ggcggccacgcgguapcupaagaggupuguuggugcuggccgcgccagcccggcgcpaagup\n", + "aagucuagguaacugagcauuguagcuuaaaaagaugcuucugugacaccaaaagaaaggaaaaaacagaag\n", + "cagcagcucggcuuuggcupcggcpucagcuacgagccugacucccpcggcupaccuggcggcugcugcggcugc\n", + "guuggacaggacapcagcgguggcuauuccagccuccuccaggccacgagucaggaacuccgcggagucuggcgccccgccuucccgcuuuugcucccggccpccaag\n", + "ucacauauaggagacacuaaaccugguccccuupuuacaccucugaugccaacagcaucaguauucuccccgauugccaucuggcuccgcauccucguucaguag\n", + "guggcucupaugaappacguguccuuccaacauccaaupagaccugguucaagaaagcaca\n", + "gcguagaggccpcpcaacgaaaapagagcgapacgccacucuaggaaggaagagaagcaacagaccagcaacacaacagaugcggaguuggaggcgcggccgcuccgaac\n", + "acaaguaggcugugagacaaaggcagaugaaaguuuuucaauugaaaaagcuuuuagaaguuucuuuuauuc\n", + "gaagaagccagccccucugcagcggagcggagcgcapccgcgcapcgcucgcacgcucaccuccuucccccaccuccugacgguugccagacccaguucuucuucaggaagagacacagag\n", + "agaguucgacccpcgcggcpcggagaggcgccaaaacucpagugucuggaggugagagccuucuggagcucuggucpaacagapccgucggccugugcacugcgucu\n", + "gguucupaagugaacagaagaaapcuuguugaaauaguuggugcaccaccaaugagcuguguccagcagugaacaauguuacuguuaauaaagugaccuuccucaggaagcugaaggaagccc\n", + "gguuuccuuagcuggaagauucccuacacgagcgcuaccuugacgccuggcgauuucugagugagguuucaaauggaaaaccgugugaaccucccccuggaagcgcguaagcc\n", + "ggucpuaapcpcggcuguggcpaagcgcacgcpcguuagcupcuugagcuuugcpcugugg\n", + "gugaguaaggacacugauaucaagaauagacuaaauugaacacuuguccccaaaauucaccucagauuuuuguaugagacaacuucaucuaaaag\n", + "agagucpuggucccagaggagaggcccacccpcgcaaagcccapccccacacacgaacccaagguccccgcgcgcccgccuccgcgacccpcccaggcccugcggccgg\n", + "gcacaauaggugaaauuccuggaacugaagcaapcaccagcpaccapucupaguggcagauaccacggaag\n", + "ggcuccggugccccgcggagccuuucaaacuccaggcugccggugccggcggauupacaggcagcugg\n", + "gauauuagauggaugguuaugaugagguuucaguuauuuuuauaaapcuuagguugccaagaaaaaggagaag\n", + "aguucaaggagugcaagugaggcpcacgugcugagupaagucggccacpucugguucucccucugccuccuccggaapcuggccagauccaagcacggaaagagaup\n", + "guuauggauccucugguauagcagauggagucuccpcuuupcugcagaaggugucacappagccgccagcgucuucuguaauuuguuggcagaacccggcuugcuauuuuccaggaag\n", + "gaggagcaggaacccacagcccaagaaagucacaguuagccagucggccgccuccccuaaccugaaguu\n", + "gguagccupucuggaaggagaaapugcccacguguuugcaccuuacccguuuccuccaagcugaauucccapcaacuaggcaccagaaaaaggaagaaag\n", + "gacuggaagaugagcucuaugcagagugcagcacaaggccagucacaaccaagcucaaaauccgaag\n", + "gcaggaagcaagagaagccgagccgagcuggugacgacguupagcggcpccgcgagcapcagu\n", + "puggcggaagccuccagcuccguggcguucucugcgcacgcguuucauuaggcgccpacccgcc\n", + "gccgacugucugccugcaacccaggcaacaguuggugaaggacaucagacggagaccuggcaccaacc\n", + "auugcugccaaaguugacuuaaaggcagagauuuuguccauuuuucacauggcacuggaauccuuauuggacuuuggaucuuggaaacc\n", + "cacacgugucuaaaaggcguacugauuucuuupuauuguggaggcuccagagccauacaacuaucccaaggcuuuguauacuguccuacucccggaucagugaagcg\n", + "cagugucgcgcugagcpaagacaaugcgccapucccgcgugcgguuccuaacacugupcgg\n", + "caccaagaugaucacuuuuggauauuaggccauauaupaucuggaagcauuaaaauuucuaauuucagucuaugcag\n", + "cacccgguggacgcgguuacggccggcpucuggcagcucpcugagguuggucucguagccuuaugcggcugagccgagcccugcccgcggccgccgcc\n", + "gcupupuccggcgccggagccgagaucccggagcucgaagcggcggcagcacggcgcaccggcgcaccggauuccccagagucacpagcgupccgguggapcaag\n", + "gacuaaccauaacccaggcugcugccuggagacacuugcagccagcccagaucucuugagaugaccagg\n", + "acacgccuguggcucgaagcucpuggcugaagcucuuggcpagcuugucucucggaupagaagaagcauugapacgcugcacupaagcucugagcgupacugapaaucugag\n", + "agcupuuggcggacguucagugcugucccccaccagaauucaaagcguccagcaagagccccggacccgcgguaagcaauuuuucuggaaucgaacgcg\n", + "guucaaugagaacacgcacucgaccuggcggauccagauucuguaggagupcccaucccgguccuccagagaagcaucgagacggag\n", + "caauuggccacagcuaagaaaagaggugcaggaugacagcaacuugucccaucuuugguaugaaugcagaguaacacggagagcccaguuuaaaag\n", + "aaaugacuucuacuccaapcaagcuguuugcuggccacaaaaacuccaaaaacgcuaacgugguugguagugcuagcgca\n", + "cugaccccuucccgcacccguccgaccccgcuccgccacccccaccccagccpcccagcggagcggucuggcuuacccugcgcuccagguccccagccucgcc\n", + "gcaggaggcagcaapagcaaugaggaagauagagaucccggaagcgcaggagcacccuggacucuguuccccaagaggaaaagacuguucucuuuucacacaggccaa\n", + "gcggaggugcgcgugugcauuucagcgcpcggccaauguaaagaaacugagapcuugcagcupcucagccggcgagg\n", + "guggcugcupcaccugucaacuucagcccccgcapcccgacccggcgccggccuggccaagaccpcaccgcccaccgcggcggca\n", + "auuuuucuuucucuagugcagagcugcaccgaggacuucgcuuuccuucucagcccaucaggagcacacuugcugcacucuuccucaucugcagcccucacugacupagaaccuugc\n", + "gacagagucuaacuacagaagagagcugaagacauuaaugaccuacuuguaagaaguugaguacuuuaaga\n", + "ggcagcaggaggapaggagcpcaagcpccgcgcgagapcagcggcaguagcggcugcggcacpuagcc\n", + "aucauccccucaccapucagaagaccagacucaacccccuggagacaccucagauucuuuucucccugcccccpaugaucaagaacuccgaccgcuguuucaccag\n", + "gccagccaugacugugaagcuupaugauccaacuugcagccacaaapuaaaggcuguaugccguagcaccpuugugagugccagguacag\n", + "uggugugugugugcggcagaggaaggcgcggagacgupcucacgupcugcggugacggcggaggcpugcgagcgacuucpuuggaggaggugaugugugcpuggccggcucag\n", + "gcaaugcuaaugucgguauagucagaauccagcuuuugaggaggacacaaggaucggcauuaguuuapagccaaccuggucaaaaaaaguucugaauauacacugauagaaguuccugcauuuuug\n", + "gccgucuggcgugcacguguaacuaucuccuccpcagcccugugauuucguucgccgcugcgcucuuuguuccuguugccgcaguggccgccgccucuucuggcgagccggacgcggcgagaagc\n", + "aguuauagcaucgapapcacagagcaggaggucgaaaagagcaagucuuuggapcgugaauaaccpaugguaucucuagagcuggagaaaacagccccuggauuagugaaaauuag\n", + "uuucuuguuugaaccaaguccaccguugaaaugauccuaugacaucccaaagaccaagacacauuuaaupaucuguaaucacugcucaauucagg\n", + "cguuauaccugccccucuugugcaaggugaagcugcagcuucaguggccucaccgaggupcacaacuccaugccagccuuucauauguacgg\n", + "gacgcggccggcuccgcguguggagccagagaaccggcaucgccggcgcccgcgcggcgcggcgcagcuccgagcagcgcuggccgcccgcggcuggccgag\n", + "augacccpagaugacagagagugapcauaucuacacaguugaggugugagaauuuuguaauauugapcpacupaagaagccauucugcaguaaauccag\n", + "pagaggucuucuuacuucgccgcccccgucgccagccgcccucgccugcuguucgugguccguucucapccggcc\n", + "apcugugcapcggcugcaacggcggcgaccaggccagagacpagccguucagccccgcgcccccucccgaaccgguguguuggagcpucpcaccauaccag\n", + "agcgcucgcggcgcuuccpccucpagccggacccpcggccapagacgcuggcgcuggugcgacuugcggapccupucacggcgcupccgcccaggcugcuguaacg\n", + "gcgcgguggagguacggcugguggcagucgcaucugcccugucugccuccuccgaguacaggaggccccgcgucpag\n", + "ggccucggcggcuccuugcpuuguggauacauaccagguugcuugugcaaggcgcgaggccagagccgcu\n", + "agccugugacuccguaagaauuaaugguuucuuucaugaaaacagauacauaaaaaaacuuaugaaaauaaaaauauauauaaaauccagauguauucagaaagcuucuucuag\n", + "cugucuucuccccucacgucccuaagccgaggcgcucucccuuuccugcgcguggugaggacuugagaguucuuuagcccagacuucucuggucucupaggaugguggacuccucccgcuu\n", + "acagaugccaccucggaggugccuaucgcggucccupccuuccugaacagaaggagcagcagag\n", + "gugucupupagucguccucgaggcggcgcuggaguugcccaagccguggucucacccugcccuccgucaccac\n", + "aguuguugcaaacaccaagaugcucgccuccuaggaacccaucaggcaguauuaacaagcugucaacaguugug\n", + "aagcacupcuugguuaggcuguuaaaauugapuucccucaagaagaaguaaaagcaguggagucucaucg\n", + "gacgcagauccupccaagaggccccccugccccucugcgapacucggccgcgcuagguccuapcgcagaacaccucuuagccagcaaguggaagugguuc\n", + "gcagaaucucucggaaagacucgucccupagucaucagcgcccccugcucccagcucgccggcgucuucccgaacugaagcucgagucccgccugcucgcuuccagcccuuagcaguucc\n", + "ucaggaacaaugcuggcugcuaccgcagaccucgucuccaauupagaggcgguacaggccapcagugccccuaagucugagaagucugugacc\n", + "auucuuugaugaaagupaugaaggcaaugaaaccaggucaaauaacguauuuaaaccgacauaauggaaccac\n", + "aaggcugcgcacgupccgcacpugcucccgcugcgcagcugugcacccuccaguacagguugcucaa\n", + "ucuccccggcpcgccpcggupcucuggcagccgccaguguucpucccpacacgag\n", + "agugaggauccaaaaccagagaguacaaguuuugupcugccgugaccaagccucucgcugaguggcucaucccuuuugccggaagccg\n", + "ggagcuggcgacgcgcuccggcgcucupuaaggagcugaaggugaggcpuugcagugcgguupcacauggauguguauguccgcg\n", + "gucgccuggcpuauggcguugccaggaagugaapaauugcauccuguggaccagcuggacucauggaaaagaaau\n", + "aupcggccapaguugaagugguuccgaggccggcuugcucacauucuppcgaggugcugcuaugcgucgcccagcpuuagcuucgcucagcccucucaagc\n", + "agagcuapaggcgcggaccpcggcguuucupaaggacpuggcggcgcggcgccggcgccgucgaccgagg\n", + "agcucaggacugucaccauacacaccuacagcagcauauggagucuagucucuggaauguugcugag\n", + "paugagacgugacuagaucggccuccgcgcgcgccuuccgccgcuccccccccaccucccaccuccguccupcggcuuccpcccgcgg\n", + "guuaauccpugagagguupcaggcucacaagcaguucacgaupuugaagacacccagccpagccaga\n", + "auacacgaagugacacagagcacagcggagccagccuaguggacaccggcugcgcgcaucagcguguccagcguccugagcgaucggagcccugcuuccaa\n", + "cuuuaaaaucaagaaaauagagcuuuugucucugcuggcacguaacaaagaaaccucccaaugccuuuauuuacugcucgaugugacacuccagugaucuuccuguaag\n", + "gacuuugccugcccucacaggaaggaacaaacgaggccuugupaacccguccugcucuccacucaagcaguggagcuacuccagcaucugcuaaag\n", + "auuupaacuccaggaagaauugcccgcagugugcccucucaagacacacacaugaccuacgcacauaccgugcugaaggc\n", + "auuuccugcguuuggcagcuuccugccugagagcccupuggaggauuaapacccucgcuaguccggcagg\n", + "gucggccgccgucgcuggupaagcggacgupucuggaaguggaacccggccuuccgcccgcgccccggccccggccgaggcccggapaccugcagcuugacc\n", + "aaaccagagaagacggucuuucuagaaggauucccaagcuaaaagaccaggaauacuguggaaggccggaaaaggacugcapaaaucuccag\n", + "ggacugacggcggucucugcaccaauguucuucagaaccugcgucgaccccpcugapccpaguuaag\n", + "aguaggaggccgagccagaggcpaagagccccgagccucgcggcgcgcccgagcpcaccgcggcgcgacgaggcagcggccgg\n", + "auucggaaggaagcagaggaagaapcccpaguuguugugcauppuggucuccagguggcuaucaaagaggaggagcugucupcupuugauga\n", + "aagugauuuccaguauccacacggaaccuauacugcagcpacagapcccgcagagagcacaccaag\n", + "agcagaggaguagcauuacggagacuguggauugcugupaagagaauacacucacaggagauuaagacauccccugagcgacuuuugcuccagucccagg\n", + "gucaaapaguaggccacggauggcacagauuucagguaccuaggagaaccuaccuuucucaagcgg\n", + "gacaucgccugcgccaggaaccugagauggcuuccuucuguccccacuugguuccugcaccccggcuccuuuccucuuuuugugcgccauug\n", + "agagauaccuggcuacggugugaaagaguupucccagugagcacgapcaccuggagaagacagauaguguccuuggaaauccagcuggagcaaagccugcccaccucagccuuaucug\n", + "aggcgccgcccgucgcccuggcgcugccggcgucaguucacacagcccggapcgapaucccagcugaaggccacc\n", + "cucguacccgcaccuccgcccgagcagcccgcugccagcccggagccgucugcuccgcgauucccaucapaaaug\n", + "agugacaggacguugcgupcgcggcggcggcgcucaaagcggccucagucccpcaagguga\n", + "aaacgguuucaacccaccaggaguggugccaccgucuccccaugagcaucacgaaggaggaugaggagcauagcuuccagacuucccagacga\n", + "aggaugucucuccaggcaagcacugccuuagcggcauccupaaucguuuucuuccaccuggcccguugupuaucacaucccucaagaggaucaggcapuuaag\n", + "cuauuuccauguggacucccagcaugaguuuugauaggauggaaaugcuggccaggaauccuccacaguuugcaguuagacggagguuugaacccggaucggaacaaaag\n", + "gcggaugugagagcuugcacccpccaguuupcugagauggaagccgcaucccgcguuucupagcggcupag\n", + "ccuuccccucgcucccgagacccapapaagagcgcgaacccgcaggagccggcucgcgcupacaupcagcg\n", + "agaugaaauaaguugaccucugcuaccccugauagucuugaucgaaggucuuuugagaaaauaacacuacugccagauugccaaugaaacaaaagcauuauuucuguaagaugg\n", + "ggacgacaacauggccuggacgcugcgupaacaucuucccaaaacacggaaagaagaaacaggcupaggccuaggagaagaugguaucauacuuuggacugagacaucagcccggcugcaag\n", + "auupcugguggcgcguuuacggagucaccuccugucapcacccuuccuccugaucuccaguuccupcgcuacgcgcgc\n", + "aauggaguuuucuucupcuucauguacuacuguapacaauuggccagcguuaacauguuacaucuccucccagaagacauapaaucuuaacuuaggug\n", + "apcuucugaguuucacuaggauguugccaguccccuupuuuugagugcugaucuaagcagaguuuggagcugguugguuugugguggaugagaaaugugagucucagcgaagcac\n", + "gagagaaguaauagaaaucugcaguugugaaauguuguuuaagaagaucuuagagccuuuuaguauucag\n", + "gucaugacccccuggugugcupcucuucguuugcaucuugccaaucuuaccauucuggaagaagacugcugauccuggagcag\n", + "gagcgccggapcucagguuccgcupcccgucacuucuccgccugaccugcggacpuucggcggcggag\n", + "auuacacugaccuacugcagcugcuggaaguuucucauacaugcaggucacggcaguaggagcacuuguggagauucuag\n", + "ggccpcccacgcccucugccpacuggccgccgucauggaugacccguugaggaggcgccgaucccgacucucag\n", + "acaaccuagaaccaugcccaguuguccuggaggacugccgccgcucacauggaupauaaugauugauaaccuguggaagcaagcaaaccucuucuggaccucucggc\n", + "uuaaggaapcaacaauggagucacccucucugcccucupagcaggaaggccauaccacccagcuccaggacucuucagccccugacccugccaccaggcaggaaca\n", + "gaguagcucccacgcaggccpaagagccaggaucuguguggcacgauggugauuaagaaaggaguuaauagcaaggaggaaagagaggcuugg\n", + "ggagupcpaccpauucgcpcgucugcaccgagccggacgucacgagcugcagugcg\n", + "guuguucauuucucaauucugaaacgguaggucugacccaccaggaugguccaaacugugaucccagag\n", + "aaggcaagaaaacaagcaagaagcagaaacuccuccagcugcccgcgcccggcpcucggaacguagccccuugapaaggcpaggccugcg\n", + "acucaugagcgacggcpcgccggccggcggcccpacccugagapaugcgaggagcuggcpccgcggagcgcpagaggagagagugc\n", + "paggcagguacacupucugugccccucugccugccacaacaugugaccccucacacagaaaaca\n", + "pcugcuacucagaagcaaugccacuccuggauccuggagcucaucaaupacuccucccugccccaaucaucacuguacaacuaacgauagcucagcuuuacagcagugg\n", + "aucagugcpcugcupcgacpacgcgcaagugagcaacccpccpagcucggcgcpcgag\n", + "ggauugagcagccucccaggucuuuaaccagcggcgcupcuguguuagucgcugapcupaaggacaguagucccggaucuaggugaucag\n", + "gaggcgcugagccggagguucpuguguggagacpaagccuccgcgacgguguggcgcpacuucgcgaguucccggaaggccagcgccacgccccccgu\n", + "aggcuacgcuugacacgaugaaggcaccggugagagccgcacgagcccguuuggaccucccagcuccuauuuca\n", + "gucgccguacaguguaaagagacacucuccaacuuuuguaugaagaugcagagcaaguucugaggcuucauacacaugucacpacauccccgugaagaaagccaccaaugaagcu\n", + "gcpcuaaacacgcgcaggacgcgcaupcgccgcpugcgcccgucupaguucgcuaaucgcucugaccguccuguggugaggcccggcpacuguucaccgcagagccg\n", + "gcccggagacgcgacgcggagcgcgccupagguggagugcucccgccccppcupacagcccg\n", + "aaucauuuuucuucupaucagaguucacacuccagcuccccugucucggacucaaacgcggcuguucgcagucuugaccauacccucuaguccucagg\n", + "cgcpcgugcagagccgcagcguccuggaagucpcggucugcgcgcggcgccpcugacggugugcgagaugcpccugcagccaacg\n", + "aaccuuaaguggcaguaugucaaggcaucaagacacagaaucuauuggcugaaagauuaguucaaagugcuguggaagaaagugcccgauaucuagcaaaac\n", + "aaaaacuaucccaaugaaucgguagaucaucaaaagucccaauuuggcuucaacagcacagaapcaugugagccaaacccugaugg\n", + "pcaguggcugcggaugcugcpcguaaccagccccagccccccugugagguggaggccgcgccaguugagaggcag\n", + "gaagugucapagcagagaagaagaagaacuuuucupuucagagagugccagacggaaguag\n", + "gcuucuaugaaccagaaaguccugccaaccagagapcucuuccucccauccauccgguguuguacuuucugugacaaggaacagaucaucag\n", + "guacauuggaaagagagaagaguccagucgcagcuccapcacagacugcaauucccuuuapagcaccacaccaggagaucgcaugagccgcag\n", + "aaaacucaaaagaagcaaacaaugugauugaucccaaggaucuguaggaguuagaugugaaguuagcuuuuaguuuuacaccaaaacuaccgc\n", + "cguuucucgagccccpcggagcagcugcgcugcupcugccuaguccaagugccggagcgcugupaaapaggcaaucggccgccgaggcc\n", + "aaaaccugcuacacagagccccagccggcuaugagccccgcccccuccgccccuuccccccgguccuguagcupcacugguuccuccguggaugucgaggag\n", + "gucugucaaucaguucugaaguccggcugccucapccgcucapaacaggagcagccggaagaggaccccaag\n", + "gcgcccgcccccccgcccuuccugguccuggcucagagcgccguccagcucuggcggcggcuguggaguugaggcapacggcaagugccuuaguccccupuuugguguaggcgccgug\n", + "gcaucaucaagcuccaaaagacpcauugauggaggauuauagaagccacuggaagaagugucagugacauggaagaugugccuguagcacagcccuaapcgugcagcccgg\n", + "uaguuacauacucuuucauucugcaggcuugccucucgaaccccuuugccugcauuaggaaagaagagaaaag\n", + "cugaguaaapaguggaagccgaaacuuacuaauucagaauuccaaggaaaaguagaauagcag\n", + "gcpcugcagugagcggcacpcccagcgcagagcpagcpagagccaggcccaapcagagaga\n", + "guuugucacugaaguccaugaaaguugagaguucccuuccauaauuucaugccugagguacagaaaggagucaccagugcggagcauggaaaagg\n", + "gcaggucccuapucaggaggacggcggagcgcccggccacgcgcuugapuggugcpagguugupapugucacaucggccupcaugauaucgcgccuaagccugcugguuucaag\n", + "aagagcccucccpcccugcgcccacguuccccuucccgcccgccuccccuccuccagccagapacguguuggccucgcaggccccauucuggcgacccccucgc\n", + "aaaagugugaguuugccaggaaagaaaaagaguggcpaaucuccagcucugcagcccaaucgccuccccauccggauagaagcuauc\n", + "gaacaccagcgcagccuuacgguugcagcuguuaagcucugcugccccagucaggcggccagccgcugagaggagcgguccgugcuuguugucggccugccuccg\n", + "ggcgguucucupcppagcupcgagcaggagcuggapapcpagcpaggcpaaagaaaggcgaggcugcagcggcggag\n", + "cgacacagagucgcggcggccagcagacgagccgaggugcpaguccggagaaggugccggauucccgaggaaggcgcugcgagccuccggcuacucggcggcgugcccggcggcgcc\n", + "aupcccggcucccggcccpagcguggcacugagacaucgccgccpcugcucuggccagcgccugaag\n", + "gucccugcuugccaggauuaggugaugauuaggagacgagcuaguagcaacagucuugacuagaagagaggucaaugaaagcacupcagagacagugag\n", + "gaucuccaucugcauuccgccucccgcgccgcuucccccucuccucccccugcccccacaccuggaacgucag\n", + "cagcguccuuaagaggucuaggagcgaggugcucccagguugaagcgaguugupuuuucagcupcuggacup\n", + "agcuagcuggcucgaccggauaccuucugaguugacggcggucucaaacugaccggcuuugcuuccggcccacguucupacggaacagcggcgcugaapcucccagcpucaau\n", + "gaaagacugaugaagacacccacaugugcuccccgccccucgcuucaccacagcucuggaaacccccauacauuuucacccauugacucucccuccaaggc\n", + "gagugacugcuagcucccucuapagagaccccgcauucuuggccgaaguagcacggcagauaggucccagcacuauuugagappccgcuccaaugcaggcuucggauaccuuacgaa\n", + "gucauuccaguaugugguuaacaaauggaaaggaauaaaaccagccuagguucauaauauauauugcauugcuaaagagaaaucucacaagaauggcuupacgucccagaauu\n", + "gcgguauccpuupcugupagauaagaccaggcaucacaguucagaugaaggugguggagucag\n", + "caaagaggagcuccugcugugcuguggcuccgccccgccucguuaagugguccucapuuuggupacccgcgccuucccuggucugag\n", + "ggcgcgcccaccccaagcccucucuccaaccugcuuccggcucccpcgcggugacggccggag\n", + "gcgcggupcgaggccggcpcuggugcpcggccgagagaapcccggcucauacgcugccccucagugccuuuugcucagcag\n", + "agacuucauucauguccupacucuacauacaacuaggucucuuggccacuucauupaucugag\n", + "uguugagapaaagauacagacgauagucgcupagucuguuaucgccauccgcaggaaggcuaaggaaguccag\n", + "cucagagaagucgcgccaaccgcgcgcpacgcugcagugcccagucugaggacuucagguucuugucccagagagaaguguuccgguguggaggacccggagcuaagg\n", + "aaaacaguucagaggagauucaguuggaggcuguauugagagagcacuuuugcccucagugaucagag\n", + "gccuuucuacauupcugaaagcaaaccaauagcagauaggacccaagaauuuugaagaguggucauuugcaccucagagaaag\n", + "accucuacccacggagcgccpccupacucggacaguccgugauucgcaccgcgauccgcgcgcggagcgcggagcccgagacupcccggcgagaa\n", + "gacaaauaugucccuguucugaacucaggaguccaccauggccaggaaccagcccuggccuguuggaacagacauuugauagauugcauccaugaaag\n", + "pcugaugacuuccuaauuuucaacaucuccaccuugucaagagaaagcaagucuguuaacaccacuguggaaagaacuaaaauccag\n", + "gcauuuuuucuuuuaucuuucaaaaaccaaaguggagaucccucucuacugcacccaacugagugucagcuccuuccaagccacuguaa\n", + "ggugcugcucgcgcgguggcgucgacgcpapacagacacgccuccguccguuuguagapuguupag\n", + "aguugauauupucaagaaggaaacagauacauuccagauuucacupacucugucaacuuugguggacucccuugaugucuccapauaggcgaaucucugcag\n", + "agauuugauuucuuuguucugaucauagcauacugccauuuuaagcuuuucagugguguucucugagcuggacagcauuuauuaaag\n", + "gaauagcccagccgcgcuccgcgguuuuguguguggaguggucpccagaucccagcugcaggaugagagccagcaggugcggca\n", + "agaccuugaggcuuugaugaagaagguaucggagacaccccuggapacacuucaggaggcagaaguccugaaaugaacaaaagaaaggccagcaugaguggagaaaccaaag\n", + "ggugcucuguggcuucupcugupcggccggccgcgcgagcggaggcagcgacpuggcpcggcggagagcgccgcggagaggapaccupcgagagcugag\n", + "gagcggcguugguuuagagugacugugcupugccagcccggccccucgcagagcaggcggacg\n", + "apccucugaaauacaaaauagagcuugccapaucaaauuuaccgauupuuacaaagcgcuggagguguugauuugag\n", + "guucuccpaagcuggapcuaagcucgcuupagcuucaupaggcugcauggaguupuuaacaaguuuguagaagauggagugaaaa\n", + "cuaccacgacagapcucgcugaucguaucuuuggagguguauuuuucuguuguacacugcuggacagcagucugauguuucuuuaau\n", + "aacacacaggaguauaaagaugguguuucuuagaaggaaaaguaauguuccaaguagaaguuugaggcagcuggaaauuccupaaguuacug\n", + "aaucupupacagguggcucgcggaaucccuucuccuucucuupuggugucccgcuccgaccuucucccuugccuucccuuccggcccgccuag\n", + "aaacccacgccggcuguucugaggacacagaaaacggugaugauuaagapccucapuugugacapcagg\n", + "cauaupucagugcaggugaccpcuggagccguuggugcuuaauauugauaccaugacugaauucc\n", + "cuacagcugaguucgcuuguacagagccagcuggaggagccauuagacacugaggagaugaucaugauaagaacuugugaggaggcauccucgaagaaaaccucccpacucagcaagua\n", + "agucccgugcacuacucaaugcucauuuucugccucccucuuaugaaaaacaucagccucugugguucuggucuuugcag\n", + "uccgugauuucccaaaacgacuggcucgcagacupuuacuuugcaggapaggcuggagagguuccaccagcagaapucugcucag\n", + "ugucuaauauugauuuaggauuaauauuuuacauuuucagucaccagaggucaauaauuccuuucauuaaaaaaugaagacuuaauugagcaaaaauuga\n", + "auaacaccuuucaaagapaguaugcacacagaugagccaaapcucuaguugcacuuccugagaagaaauaugaugaacaccacccaacuuuggaguuuuaauucuaaggcccccgcc\n", + "auagaacuggcuguagcuacaggccgcggauguucaaaguagaagaaagupccucaaguaagaagcuaguucucaaacauga\n", + "agguccacgcgcaggcgcgcgcccggccagcugucggcguucccugcggcagccgcggcgcgaaccagagccagcaccag\n", + "ggagccggcggagcacggcupcucuucggucgagccccgcagccgagcccgcggcguccggcggcgccgcccuuaacaacguccgccgcg\n", + "gugccggaguggcugcgccggaggcgcugagagaagucagagccagcagcggaggcggagcuacgcggcacgcggagugacucggaguagcgacggcggccgccag\n", + "gacagccccgagaagugagcuggcauucaguuupaacucagcccacaacagacaguucggacugcucguguggaggaggaggacugcagccugccaucaacacu\n", + "agaggucuccgaccaggaccgacuugucacgugcapaccccggcugcccgguucaugagcacagguagacgucugcuccagcgcgaccgcgg\n", + "gaauacpcagcucpaaggagcugugcgagcugucagcuucaaguggccugugagaacccgccugguugcuaccggcucgccaupagccugag\n", + "ggagcugccuuucaugccacagaggaggaapagcggagaguuuggaggaaucugaaaucccagaauuggcccuggaaacaggagaggugucccaguauggaaagagagagaaaaucugcu\n", + "guagcugcaagcuucucuguugugcacccaagcaggagaaagcuugcuuggcucacuagcaggcagacguggcccugcgcuaagugcccag\n", + "gagaaggaguaaagcugccgugcaguguuuaccuccgcuggucccucuuacgucucupaacacaggagucugugauuaacg\n", + "ggagaugagugcagaaguuuggugugaaguugaagagugcugcccugaaaagcuuucagaaucccccggcuuccuuggccagaacaaa\n", + "uagaaacuuggaucugcgagccggaagcuaacupagaauaaaauaccguugcccgacgucggcagagcucacu\n", + "aauucgcugagagcaccucaaacacagccucupccaggaagaguucucuagcupaggugguuaaucaccuagcaguuuguuucugcgcccauccuagaaggcggauc\n", + "cugcccccgcccpcugccgcguggagapcugagcacuggcuccucgagcgapcccapacccagcugagccggcgcugcggcacc\n", + "uuucauaaauggaaaaccuugagcgacuagaupcuuggccugucacacuguugupauguucugagguguuugugaagaagaguggccuupaacccapcgaauugaaggcag\n", + "ggcgcgcccgcaucuuccugugaupcpcugcpcggucaugaaggupcacagcccugccpa\n", + "pcgcpagucgccggcugugcguggcucggugucpagcgcccggccgcccagcgcacpcgucucugagacucggacauccagcgcggccpuggcgcgagcgcgg\n", + "agcaaguguuggaucaggagccaucaaacauuaauuuugaguaggcugguuucugagccuccauccaaccucaaccugupuaacacuaug\n", + "gacuccuccgcucgguggagaggcugaagagagaacgcaaucggapuccaggccgcggaaggcugcugg\n", + "cccgcgcacupcgcucggcagcaaucucaaaaucuuuggcuggaaggcuggagcuuccggcgcagacuuccucuguccggcggcgguuccucuupcuugc\n", + "gagcggcggcgguaccugguggcpcuggagccgcgcggaggcgcpcggaacuuupagccggcggcgcccgcagcggcgccpc\n", + "guugapagguggaagaccaaacucucggaucacagcgaaggaaagaaagagaacgucuuccagacagcuccuuccua\n", + "aaccucaguggagaaugagaugacauuucccaggcagguuguucccugcagcccacgacuguuuacaauagaggaagagauugguaagaguaccacagacugcugccugccccug\n", + "gccgccgcgucpcccupcgcuccuaagccaagaggcuuugcaccgccagccugcucpaguguguuupcgcaccgcacccacagcggucggugagcgguucggagc\n", + "agauaggacpaccggcggcggccacggagcgcugcuggcggcgugcgaggacucccugccugcccgcuuucag\n", + "acaccuuguggucpagagacgagcacgccgccgccgccucaagcupaacggcccggccccuuccuggccgccaccug\n", + "gacauggugccaaagauauuucapupagcgguaagagcauaaugaaauucugaugccugaggaggaggaggagcag\n", + "guccaagcccugaugugaacuccacuaugcgaacugaaguaaaugagucaugccuuapauccuggaacacpaagauugupauagauucagg\n", + "gugcuggugupaaucacaugcugcupcaaggauggccacccugauucucauuccauaaccuccuacgugccugacuccaa\n", + "auaagaaacccacacggcaccaucaucauugaugaggcaagucaccccaaaagauacauuucauggcccuuacuaggaaggcuguggcuauuc\n", + "aguaagaggapauaauuucacucupcuggupaagcugucuaaguggccagacauagaaagccccggagcagccupaucacuuccuccauaauuac\n", + "gaagcagcggaucaaagaacucaaaaagagugccaguucucccacagcucacucuuuuccaguaaguuuuaagcagaaaggugcagccaagcaagg\n", + "ugaaacgugugguguuuggcagcagaaggupaccggcucuupauucaaaacaguaucucccugauagacaggagcaggauucupaaupagcuggug\n", + "aaguuccguucuagugcaaaagcuuccaaggaaagaccauacuaugagaaggcaggugaucugag\n", + "ggucacpcuuuuccccpucguggaccaagaccugcagcccggucuaccggagguguugcgaggcucuupccagccaccucuaggaggagagccgcccgugccacacu\n", + "upacagupcgguuucuucgaauccacaggcugucuugacaucaguguccacaggcaggcugccapagacccuacacccuaagaacaggaa\n", + "auuguucagcuuucgaagaaggaugaacuaaugaucauccugccagacaacccacccauccucagcagcugacaggaacucucuccacuugauucaccaacuacucccaggccugccuac\n", + "gacacgcuuggaugaugcaggcacuggcaacccaaapagccaccaguguuggaauaaagauuugcuccagugcaagcuca\n", + "auuuguuugcuguuauaaggaacaucuucgcagaagaauggucauccccagcuaaaaaacggagagauaagagcaagcaggcagcaccpuaaag\n", + "gcgucaaguccugcaggagagcpucccgaapcuuucuagugcugguggcucucupcugcuugcaucgacuguacguugapuugcagacgcguaucuugg\n", + "ccauuuauagcauggugaaccaucaugucugcagcuuuaauuuuugcagcaccuguucaacaaaauccauagagauaucauaagagaag\n", + "cucgucacuccuucgucuuuacuguauccuaaapccugagcuagaacguguucaagaaacugcagcagaucuacaucagcauugugcuggaacaauugaaaag\n", + "augcuugcggaacccacaucaugauuggaggugaaucagaaaggcacacauggcupauggugcagccaccaguggcuugaugccauagaaguauaucucaaaauuacag\n", + "pcuggcgugagccggccugcpugaggcpcacauuggauccpcgccgcagccacguguucucagguucccgccuccpucucgcccgcagcggupcuggacggcag\n", + "cuuapacuuggaaucgccggucgcugagaggccucuaaccgucugcuucgagcaacaaccaagcaccuggcauuacccugguaccuggccuuaucpcpugugugaaccagaagcucuaag\n", + "cpccggccapcccgapcaagcucccuccaccugcgcgccccgcccccaccugapaucgccgccuccacguccgaggucucacagccaggaacaucgcc\n", + "ggcccucgcagccgcguuccpcguugcgcuccggccaagugcpacpccgccgagcucucggcgcagccupcucguag\n", + "puccgagucggcggaggcgccgagagcagaggcpcucggucgccgccgcupcggaagupugagcgcggcupaccgcgcggcucgag\n", + "aaguagaaagcagagucacugaapccuacucugaucacucuggaucuuggucccgcggagacaauggcc\n", + "aaaaaaagaguacagccccagcaagaagguucaggagaaugguguucuguuugacucagcuaugaguaac\n", + "gauggcuuugauccuacaccacccccaacaggapcggucucgucccggccgacacagcucguuagcugucgucgguagagagucgcagauaccaguuagagacgag\n", + "cuccaaaugccaguucuccaagcagaguuacaggugucacauugagacaacgaaapuugcugucacuggcuguuagcagaacuaaagaaaacacaagcaucuucaucgcaauugug\n", + "cucgacaguuggcuuaaauggagauggacggaguuggauuauaaaaagaaaucuguguggagcauugcuuupaucacug\n", + "ccuauucgcaacucuguccucagccugagacacaucggcucgccucuggaagcagaagaagagugaagug\n", + "uuuucagcuggaggaggugaaaaaaacugcuuacucaaccaguagucaccugacucccggugguagcaaagagacugaggcggaaagccac\n", + "ggauuaaaggaggaaauucuugagcupccuacauagauugcaaaaaggaauuggacccugcccacauuaacuguccccugaccc\n", + "pccpcuccpaapcgccagccuccaaaaacacugaccucagcucguccgcuacucagugaagcguuugugcacggccuugccgg\n", + "pauuugcccuguccggcccgagcaggcgucaccuccagccccggaggcgccucccucgucuccgcgagcgccgccgccccuggcaggaccgagcgg\n", + "gacguguucgccuapcuacagugugguguaugcgcupuaacacagcagcugcucaagagcuggacuccaaucagcucpacuagaucccacuccaaccagcccaguuagug\n", + "uguuaupuguuucauucugagguggucgacccaaguucucugcagucccuucaggaggcuuggaguucuggagaaaagaccuucuccgagaguccccp\n", + "ggapacaggagcgcaggaggaccgucpcggcuucaguggccccuagcugcgaagcugacuuggacuuuucccaacccgccccacuuucuucuaccucaguapcugcuccpaggacacga\n", + "agcucccugcaaccupaaguuguuugcaaucugugcagaaguacuuuguuucuagaggaagaacuuguguuggagaauggcagcuggugauuauggagcaccuccgguagcauauagg\n", + "agccucugguaggcaugaacaacugacuuucucacccauggcagaguggcccugaacuguauaguggagcauugaacgcaugaagacagagcugaagaugacuuagguccugagauuugau\n", + "cacucuccugccucccuucauuauagcagccccgcgcccucggcccggcccugcugaaucuauuccugugacugcucugugagag\n", + "gagccugugagugcuucaucucuccaacgacupauugccagccguuacaggaugugcacccpcgguggccpucggcgcguucggcuuaag\n", + "gacacggaagagccaucugagacguggcuccacgcaggcucuucauucuggaucccaapaaaagcccagagugaaaacc\n", + "aguuacaccagcuccaguucagaagaggacagcacacgcugaagcccaauuuugcguuucuuugcuggccgguaguacgccuagccuguggugaccaauuucuguuccugugcccagacaggaacug\n", + "uugcagaacuucaaaagcaaguggaccccccaaguuaggagaccaaacucacugauuuaagucaagag\n", + "auccagaaagcuccaacacccacuuccccuguacucaccccgguacaugcugcauccuccagaagcacugaaguaaagaccagaauaaga\n", + "gaacggcagaggcccucpccucccpcgcgcaccgucgccgugcpcccucpccccgcgccccgcacaggagaccpcpucggcgcggcc\n", + "cuuucagucacagcagcugguggcuucgcugcacuucccaggcuuuaagugucccapuugcupapagguugcagaaauupugcgcuugaucuacag\n", + "agccgcagucccccauccccgcccgccugcccgcccgccgccgccgccgccgccgcpcugagguccgcgcccugagcgcuggacuccggcccagcc\n", + "ccucaucauccugaacacucccuuccccgcccucucuuaaggcauugauccucuaaaagaggaagaagugaugccuaguggugaugaaggaagcaggag\n", + "agcacapucugcuguuauccucccaggaucacugacupaacaucucucaccaucgccugcucagacuguggaaaaucagaagccuggacagaucaaguug\n", + "gaggaaaagagaucacugaugaaaaaacggcacaggcgcugaccccucauccauccucaguagcuapacaccacgucaaggaacucgagugccacucuccau\n", + "pccuccuguauucgaguugagcccugaaguggcccugaagaagauuaguuaaupaguagaugaccucaauacggaug\n", + "aucacauaucuaaauucugagcuauaacaacaaaaagagauuauaauuuuaauuuuaugauucuuuuggugaaaauaacauauaaaauu\n", + "gagugcucaaggcagguaacaucucugugaugguugcuuucugagcccacgcagcccagccagaccagaaguuuccugcuguucapcuucccguggcug\n", + "guguuccugcugaagccgcaugagauggauaaagupuuuuugcuaaaacacaccaccaugauaaagaccaugacapugaucagaaagaauaacaaaaug\n", + "gapcggcggcggcggcgcggcggagcccpacacucggagcggcccggagcccaggcgcggcggcgugg\n", + "cucaaaaacupaguaucccagcaccuccuccugugagcucuucupucgccggccgapaacacagccccuccuggaugcggccgcc\n", + "aggccagagccgaaaagaacacuagccggaacagccgcggcggcagucgcuggaggugaaggaagcugagcacgacagcauccucuccacc\n", + "ucgcuagguccagcgccgcucccugccuggcccucpaaacccugaggcccugcugugcauuuccccuacccugugugugacpauggaaacuuucauugagaggcuccgg\n", + "auuggccuggcggcggccaggaccucacguguucccagccuggugcccgapaguggcccguucaccgccccgucaagcuc\n", + "agcaacacgcggcgacccagccpcuaccggcaggccggccpcaggcggagacgcpcugagcpacaaggcggucpccucggacacgaggccccgcpucccgcgccauccgcu\n", + "cggagguggccagguuagugaguaagaggugucgccgccgcugcagcuccpccggcccucucccccggcccucagcucgacgcuuucacuucugcag\n", + "augugugagaaccuucgccupacaggcccaguugcagucaucccauguagaagaagcagguugcuggcucugaggaag\n", + "gaaagaagauacguuuguaaucaggccauugugaggccaaaaaauacpugcuccucugcccaggaccaauga\n", + "gacagccucuguguaugcgupccaauggagapagaaguggacagccucagugcaagaaagaccuagccpuuugaaucag\n", + "acuggcaacccagagaauuggaggaagguaugcaugcuucaguauauagcaagucaauuupcaaaggaacccaupuuuuauggaagcauugaugaacag\n", + "auaacauuaggagaaaacugcuauucuggugugaauaaggauacaccaccucucucaggaaccgaag\n", + "paccuccuccaacggucuggagcgcgcgucaucccucguuccccgupaggapaapcgccgccuguggcucccuguccuccaccuccgucgcccgccc\n", + "ggacaapuggugaapuggaugacgupaugaggaagaaggcugagcagguggcacccgaggaacuugcagacucuugcc\n", + "acuucccggcagagcggcggcagcgupcggacucagacucaagccuucgccguggaggugcucucgaggaaggacg\n", + "gacgapagagaucgcggcgcccgucgguccpacuggaauucccagcgaacpagcp\n", + "uacgacuuuaaggcaggcugcagcacagaagugacugcugcuuuuaaaagccucucugaaaucuaucuauggccagaauguguggcuucccuuccaagaucuug\n", + "acgguguuccpugcgcggagguugguguuuguuuggcupcugcgguaggaggaguguggacuaapaaagaacuugug\n", + "cacggcaggagauccauucucaaaggagcuacccuguacaucaugguuaaaccagaggaaaauuuggccaucaucuuucaaaugcuaaagauauuuaucuggapagag\n", + "aaagucuuucapaucugcugauugcagagcaaacagcauugguccauuucuccccauuuucugaucaucgguuugcuguccagacauguacccauaguguguucaggcucucag\n", + "ggaugaggauguupaucacccaaaacuucugcagcaauuugcaggagaauggucugcucagugccugucccagccacgacggccaaagcauuup\n", + "uccugucucagcugcagagaagacucuucuaaagacaccaagcgcucauccagcaaccaaguaaaguugcccggugapaccuug\n", + "paguuuggcagaggcacccgccpcucucucuugcguccuucgcauccacggaagaagcugcccgccccgcgacuucccugcacacuggccaggcugucgcg\n", + "cccupaucugucaucugccagauucguuuuupcagcuuccugcggucggugucagccucaaucggcuccuugcuggaggucgccaaccugaggcgacuccggucuuccag\n", + "gaugaagguuuucugaaccupugaggaaggcagcugacapagccgacguggcuucgcaaaagguugcpugcacauggagauagguguguguagcccggacaacaaacuggugacauuuucag\n", + "ggcuauuguaacgguuugcacaaaccuaauugguuuuuaagauugcugccuuaggcguuaagaagaaggcccaaggagaaaaacauccauauccaacaguugaguaaaguagcag\n", + "gcccgcccggcgcugcgucgaggccgccgccgccgccgcccggccccagacccagccgagccagacgcgugccccapcgcuggccgccgccggcggcgccccccg\n", + "gagccguggucgcaccgcacccuccucuucuuuccupugccaggcggagcupuaagcggcugagaccagaacccgccaggacggcugag\n", + "guuuaauugacaaagccapaugacuauucugguucuugcuccccagucccuauggaaggaccccugcuucuguccucaguugugcaguacag\n", + "accucgaugagcucggucuucuuaggcguaucccagccuguauggaaccuguuucaccuaagaguuuucgcuguacgg\n", + "apugcagcugupcccpuccgguuugcpccacupacggcgguugugaagcugcgacgcagcugcggccaupcuggcag\n", + "gcgaagcaaapucucaaaccaagagcaucuuggcuuuuucacuccccggacagacgcuucuucccugcaggcug\n", + "gauguacaauugaggaaggaaucaaaaaccagcacugcaacucuuuucauuccaugcuucuggagaaugcuuuaaaacuuucgaugcucagaaguuacag\n", + "agcgauggugacacgcuuucagcugapcccccgcucugcuaggugcucccupucagcacuccupcagaaggaca\n", + "ugugccuggugcacacgcugccccaaccpuucgccuuucaggccaggucguuccgguaacgaccugcugcggcgagcagcucccucg\n", + "auauacugupcuuaguuaggcggaggagcagcuuucuuauagaugauauaaguaucaucuggagaaugcaaaaguaucuuauguugucg\n", + "ggaggcugupccccppaagcugccguggccgagagcgagcgcugcagcgacpccuuuuggcgcpcgcccgcgcccccccpcgcccagucgcagccgcugcgcccggcaucacaag\n", + "augaucacaacuaucucugaauauaacacauuuaaagcaaguucauuuuauccgcauggccaccguuuuaaggacagcugagaaag\n", + "agagacucacggccacggaggcugugagcagupauugaaucuugcggaaaagaaagugcccaaacucpaagaaaagucucag\n", + "agacuuccuuggagupauucccacacgacuuucuaugaacagugaaguugacagacauuagaggagcgagauggcuggccagcccuaa\n", + "agauaaaauauaacggauuuuuugcpcuuuucuuucuuuaugaauucacaagcaagagaccaagaugaggcuuuuauugauacuccaguuggaggaaccaaguccaggaguccaapcuuga\n", + "gucggugcacgcggcpcugcgcugcagcugccgacuugcacacugcuggacpcccucugcua\n", + "acugugaagaguuagcccagcgaagccaggaagagaggaggcccagcacuuuggacguuggccccguucupucgcaguaguucccacaagaaggucguggucaggcugagugca\n", + "cuccgugcucgcgagaugccguaagcaguugcpaggcuggcugcgccaaacggaggaupaaacaupcpcucugaaccauaagacccguguacagcucaggcagcucacgcag\n", + "gaagcgcugcugccccaaucgcpcuagccgcggcgccccpacccgaggcgagccgagcgcaggcpccuaaccccgccgccgaauccucgcgcccg\n", + "aaagcagcaggapagcaaggaggaagaaaaagaccaagagcacagcaaggcgaggagagacccgcagacccggcggaacucuagcgccggcgag\n", + "aaaaucagagguucauauuucaauuuauucacuugucuuuugaaacuagucuuuucuuccuguccucaaauuucug\n", + "gccaucccgccagcagcgcugucguggagccccggagcccupugaccpccccgccpccgagugcgccagccccggagcacg\n", + "uccaugucccguccucccgccugccugcagccaggacugccaccuggcuucucccgcgccagguggcpaggcccuaaaa\n", + "aacggagcccaguguuuggacucccggagugugauggugugapcgcguguccguguggcgccggcpaucggaucuucgcacgcagcc\n", + "gaaaugaaagacaacgacapcuuaaacuuuggccucuapaaagcgugucuuuguccuguguuuagcuggcucccaccg\n", + "aagugacugcapcugcccaagguguggaugaugugaguaacguuaagacuaaggcugcuccccacuaggauguaucag\n", + "gcaguguaggagcccauccauccacacggcaacucagaccauucacugcgaggauuguguupaauggaaggcugaa\n", + "aagacuacacaaggagacccaggauugaucggugaaaucgaugcugccccugaguaguucccaugcucaagauga\n", + "guguuccupuuaacugagupuuugcugguggauugauaaagcaauacuucaugucucccagaacupcag\n", + "gugcgaaaaaugcagaggcagaapcaccuacagcuccuaaacaccugucccugugguuaugugugcuca\n", + "agccaucugagauaccucupaaggaguggcacaugaaauccuggugccuacccgaupaaccugugugcugcagauugagacucucccgugccugaccuggagcuccgcccaag\n", + "uuacagaaaagaguggcuaccacaguuuggaaaagccgcggacuuugauaaaaaccpaaaguuugcagaggucugauaccuaggagaacagcccagcc\n", + "gcuuccapcugaaaaagcugaggugccaapugacpaaccccugucgguucucaauugaggcuggucaugcagucaag\n", + "gaugcccucuuguuguauagguuggugaaggugacauuaguuagucuuugauggapagcuucuguauuuucugcagcuggauacaguugauuaaagcaugcuagucucuaaaaaaauuucgaaag\n", + "agcuccccccpcaggaggugugguugcggucupugaagaaaagcagcgccupcccuccuacaaggaccagguguguccgcag\n", + "aagcacggaccacagcagagacguccgcccccuccuggacgcgcggcugcggcupcccgcagccucucaagapaagcucugcguccacg\n", + "guagcgcucccgccacagupacccgagcucgucugugcgccggugcguupcccgcgacccagcccagagccgucpagcgag\n", + "uuaagaucuaguuuucugugcugcgugupucacgaacaaccccuccccugaucuuccpcaacuggacgcugacaggcgcagacccggccgcgguggcp\n", + "aucccaapccagaguccpuccgcgcccagucucgaccccgaggagccucucccaucccacccuccgcgagcccagccccccgucgccgccgccgccacc\n", + "cugcuggcucucauuccguguuuucuuugagagccaggcaggapcacaucauuggcuccaggaaagugagaagccagugauucucccucugaagaagaucauuuaau\n", + "guuuuuuccguacpuuccuguuccaguuugupcugccuguuggcupaacagauccucuugg\n", + "ggagugcupuuaaaauggauggapcapucucagagcugagcuacugaagucacgaaguacaaugaggcuacaag\n", + "aucuagaaccaaugaggacacuguccggucacucagaagcuggccacaggugaugcggugugguguacuggagaaag\n", + "ggugcaaauapuccuguaaucuuaggaguguggucauuuuuugugapaagaaapacugcacuggccagauguggcaguucuguauucguaggauggugaucaaugcacug\n", + "guggcaacagaaacaauccagccggcaaggaucuauuucauccaggaaaaaucaacgaugccauugcugugcacuuacaggagaauggccauacccag\n", + "cugacaccuucgccggaagagagguucaggaauaaagaauccggugaucaaapacuuccaccuuuggcagugcggccuuguguaccacggugaa\n", + "gacugcgcggcccagcaggcgucggaggcgcpaaucucgucgcacugccgcagcagccaaguccagugccccagacccag\n", + "gucggugugagcgcuuuccugguaugaaguggucuugcccgccccgcaggcccaggcugugagauugcagaacucap\n", + "gugcaagaagccagaguggaugaaagcaccagaggaaauacaccaauccuggaagagaaagagaguaagacagaapugagaaaagaucaagg\n", + "agagugugcupcgcgcccpcgccggcgcgcgcugugagupcugcgcpacgugaguggcggagccuugaccgcgcacgcagcugagcc\n", + "gugcccccgcccccgcuccucccgcccagguccgccgccgccggccucagcpaagcuggagacpuuupccacggugccguaggccgapcggcapucaccacua\n", + "gcugcagccucaucacagcgugapagcauaugcggaggcuguauucpuccuucuucguccccagagucuccauggagcgucugaagccuaagcc\n", + "ggugacpaugcgaaggcpuuuccagguauguaaaaagaaaaguugccaccugugcaacgucag\n", + "gaucggugauuacacugauggacaguggcgcggcagucuccaaccacagugauuauguggccggaaacaacagcugcccucaauaaagcugcuuuugacuc\n", + "cucucggagccgucaguaugauguagcggcucgcacpapaggcuuccccucccccccaguuguucaaguuucauugacauaucaauauauaacagg\n", + "acucuupaagccacgcacccugaaaggaugaccaaagcauggcuucacacugccuaccugaggugacugag\n", + "ggcuuuauugucaaccapcagaggagugagguugaucacaauuggaggaagcuugugauauupaccpaguuaau\n", + "gaaacuguuugcupagcuucauaggagaguuuugcuggagugucugccagacaggaaccapaagacaccca\n", + "gcgugacagucgcgcpucugcacuagcuucagccccggcagugcuggaucgcuucagacugagcuggucccaugugcuuguccugguguuuccagaag\n", + "ggaggcgcggcggcugcgccgcucupaccgcaaagccggaagcgaggcggcpcaggcgcagcuagcaaggucccccgcpcccagag\n", + "ugccugccccugcccugaaagcagcgucugagcuguacuacuccuggcugcaaguccacccagccuucuccagcauaacaccuuugaaaug\n", + "acuuauucucaagaacagcucugccggauguggagcggagucugcugaagaggaaccpcuucccagugaagacgagcuugacaaggauagaugcuaupcagcacuugaggcuuu\n", + "upaucccacpuaaaaggcagaaggaucuaacuguacuccaccuccuuuuggacgucuucagauc\n", + "ugccuacuuaacupaagcucugcccuccucuccgccgccucuugugccgccgcuuucucgucgccggccuagugcacguggaaagacuaagcgucggccccauucgccacacucaggacccggcg\n", + "aaacugcuagcpagagccagccucuuccgugcuugugugcgcagucpaugcgccpagcacauacagg\n", + "guggagcuccugcuggaagagaaggaaaucgucugcugcggugucugaguggucagucaaacagguuauuaaagaauggauaaacagugagaacag\n", + "acuaccapaauaaagacuggcuguguggaugcapagaauaaagcuuaggaguuuagaggccuugaggaaaaggugaaguuggauugcccacagaauuuaaagccucc\n", + "ggagaggugcugcaguuugcpcgcagccucgugguccgcagccguggccgcugccgguuuguucugccucuuagu\n", + "guaagccugcugcucggugaggagcuguuugcaucagcagcapagcagaagcugcagagcacuggaaggaaggcacaagucacaaa\n", + "agcagcucuaugcagcucucgcuggaauggugcuugcugauccuucaacccgcccapagcgccpacac\n", + "agaccagaacguuggucguppucccgagccgcggcgccuggccccugaaggagccpcupcucccgcucccgccgcc\n", + "agagaaguuaugaaugaaacacagaagauguccuggaaaccuucugcaaaaggaauaccaacccauacacaaaucagaacauaguccagaaaaaacaggaaaggaauuucacccauaauuuuag\n", + "gccccuucuguagccupcccacggugcuggcugacuggcgucugcugugagccguuacuggccuccug\n", + "aguuuaaccaugagcaauguuucuagacaacagagcacagcuugucuauuuggaaaucuauccaaccagguuaaaag\n", + "ugcuguggccuccgaguggaauggccucgccucgcuucccccugacgucccccauugccccucucucacapcucccucccgccgcacccucccuccgugaggag\n", + "guggcucuagucgugugguguuuggagccacccgucuuaagcccucuccagaagcucugucgcggacccugaac\n", + "aaugauggagaugcugagguguaugagaaagucaccccugcagagagcgacuguguagcgacagcugccugccuucuagugg\n", + "aacuaaaauacaguuuguauugcuucuuuauugcaagaagugaauugagacucuuuauuauaucauugguaguaggauaaaauu\n", + "guggacagccgcaguccccgcuuagguccuuucuccucuggaccgaucaugucgauuagcgagauggugacuggaacuucaagccaaaaggauuagg\n", + "gcccggcucgacgccgagccppcguuccgagcucgcggcugugcugaggucggcucpcguccuuggapaga\n", + "guaaggaauuaaggucaauuagaaguuugcugaauuaaauuaggacaacugaggacccucugagaagaaagcuauauccauaccuacuuaug\n", + "aggcpacuugapcacupauuccuggcccugcuccucgucpapcggcugaagcugcc\n", + "cucugugaggagacggagugccugguggaaggaaguucugcaagcggccugcagccacagcgaaugcag\n", + "ggaccuuggcccggcuguggaucaaaucccuuuucagagagucucuggacaacaaaaagucacccuagaaucgccuucc\n", + "gugcuuaucugccupaucugcguuaaugugucacuggcaacagccucccucagcaaguuuaag\n", + "gagagacacaccauaaacaaaaagaaauguuuggupacccgcuugaagcuaugacucgcuaaagaguauaaac\n", + "gccaauccccagacagcgcagaupugacgucaapaugucggauucguugguggaggcap\n", + "gccaccacuuccuuggauugcugcuggagaauacccguauccaagapaauaucaugugauacauuuuuuugcg\n", + "gagucagcapuccccgucucacacuuucupcuucccgagcccgapagcuugcgaguuuuguggcgagacacguccugcacggcpaccpcupug\n", + "gcggugccpagapcggucgccgguugcuugcaggcguuacacgupcupcuccuccugccucccucguggaagcaggaagucaggaugaaaaggcugugauugguucauag\n", + "agacguggugcugaagaguuuguuaaaagccuugagacaaaaaaaccaggagcugccuacacgagugucugaggccuguggucaucccacauacaagg\n", + "cccucuuucuuguucuccccuccguggaggaucucugagcguguugcuaugguggcagauuauguuacaagaagccagaagugcagacaucaucagccuggacucucacuccugg\n", + "ggagcgaggcuggcggcggcpcappcgugagcgacgccpaggcggagcugcaccgcguapagcgugaacccg\n", + "uggcuccgcaccaaggcacgcgcugcgucggugaccaupuguuaaggugaccucgucacuuucgaucccugagugcacgccuguaug\n", + "ggcggcgacpagcgcpccaguggcaccuagguacucuucagcccccacucccccgcguccguuccgagaguuaacuggcaccgacuucucucauucccgagcacc\n", + "pucucucagaagaccggauguuguuupaaggcgaaggagaaapaucaucuuugacacug\n", + "guuuuuuccagaauucugcucagaugcupuauuuuagaauucagaugugccagcuugcauugucugcacaaccuauuaaagauuaagca\n", + "pccucpagccpcuguguugaccgacucugucugcugguccggacgcgauggcguggaugcgcagg\n", + "gaaagcuuuccaagaugcucauaupaccaaacuugguuccgccauugucagaggaaacagacugugag\n", + "ucaucugcccgugcguugguccugcagcgcgaguauggucgccucucccccgcuccgcccugucpcccacgccccccgccggapuuggagaccuca\n", + "gauacacggagcccgcgcuccgagacccpaggupcpacpucuucpcgcccgcppcuccpcgccagacgacccc\n", + "cucacuucccgccgugagaccauggccguucacucagguaapuugccggcguuccupacccagaccccagcaguggcucuucpuccacuc\n", + "aauuuuguauggaaggcacugaugaagaagapagcugaaagagaagugcaucuggucccaauacuucacuuauaaccaagacccccagcauaaaguucagguagaaggcccucagg\n", + "aaggaacuuaacpaauaccuuggcauccacuccggcucaugaucacugguggcggaagauaucagaucgagcaccauacucauuuuucauucugcugcugcggcug\n", + "pucgcgucacaaccgcgcpcgcggagccggaaccccuappcaguggcggcggagugcuucucugcuuccuaagaggugcucugccugcccuaaacgcggaccapuuuucug\n", + "caacccaapuuugugguupcuggcggcpaggapcgcgcgccgccpagaggcggccgcccguuggagugaauaggcaccgcggaag\n", + "ggcgcugcgcagagcaggaaucgapaagacuguguguggaccupuuaauggugugugccagugacaccugcccaaaug\n", + "ccgcucccagaucagcacggagccagauccgcgcpccgcgcgccpcugccgucuggauuuccacaggucagag\n", + "aguccucagccucggccuucuuucucaggcpccucugcuaccaccucguugcagaggaaccucugccg\n", + "uguugauuucagacaggaaaacaaacggaguuuuggcccaauuugguguugaugaugaaagugugauaugaauuuggacucaagaaugaagguugcaagaccaagaugauuca\n", + "aaaaucucccugaucauuucuuacugguaugcaggauaaucauagcggaggaagaacpcuaapuuguugaacugaaaauuuacuugaggaacaagccacpuggucuccuagaacag\n", + "uccacugcuauuucaaaaauauugucagauuacggagugaauuuuccauaaagaaaguucuuugcuucg\n", + "acupaapcuuupauuupuaccuuuucccuccauguuguauguccccggcucauggcucccacccggcgcuugcag\n", + "aggcccuaaggucucuaucuuuugccuggcucgagugguggugacupcuuaaccgcguccgcgaccaggccagccucuagg\n", + "uucucagccuacuagcucagccucugucaacaucgugacaccuguauugcacuucugcagugucgccucugagacaggagaacuccuuuauccggccagaccucugucggcagcuaga\n", + "gcggcucagcggcggcpcgaguugugcucaccgcggcgcgugcggaccgaccpuccggucauggccagg\n", + "guuuucauacggcagcaggugcugcuucuggagaccucagucpcggcugcgaggccucucuacuucgaacug\n", + "uaccacagcugcuuuuugucugcugcagaggcugaggaacauccaaagccucaaccagagucgaaaauagcupcccggauugugaucuccucaccuccuucugccccucccuugcagacu\n", + "agccapcaacgcagugcagaccuugcuaccaccugagaauaggagccacgccuucucgccccggcccagcugug\n", + "guggagcuguucgaggcgcugcggccgcuggaugcaagupcgccucuugcucagccgcgcaggugacuugugagcccugaucugcupaccpaagccuguaguucccgccgccgccag\n", + "guuauugacuapaggcagauucagugauggaacuuuaaacuccgauaccugaccacuaaagaaguucauucgcuucuuuacag\n", + "cagapugauccupucccagacaugccpaacuccuggugccucacucugcuuccupagcuucuugacgaggcuagccccauagacaggaacgcggaauugacuccuugaggcapaa\n", + "gacaacupaugauugguuucuggucuuggagaggaagaugcucaggagccacaccauuugcccapaagaugag\n", + "apaguuapcucuggccgcuagccgcugcupcaggaggagapugaacagccggugugg\n", + "aguccccuccaguccucapcccagacccccgcgcucuggccggccgcucaaacuccccccaguccccccgcucaccgcucacgucccccgagcgucgcccgcc\n", + "gacacgcuggaccuccacgaugugugaagaacaggaagugaagcaagaggaagaupaagaaaaaugaagacgg\n", + "gcagcuugacucugcaguuuagacgugugcuaggcggcuugagcucccaaaacacaagcaguuggagucugccupauuugcag\n", + "gagaggcgacpcpccgcagcgccggagaggugguccaagaaagcacagccuccgccucgag\n", + "uuupugcgcagaccccucacaucgccccgguuccgccgcccaucgcgucccugagauccpacpuaaggcugcugucccguccugagugccag\n", + "gcgapagccugcggugugucupagagcgagcuaggapccgugcucacguugccupcucugcaucugucaccpcgcuccag\n", + "aagcuccauccugaauuccugcggucugauccccaauaaaccgagucucuggaauucagguggugaagaaaggagaacugcuugacucggaccacacag\n", + "auacacggucggagcpcucgcagagcggcucaggcgcccuggcguccccacuccucpaapuccpcugcpagacugcggcugcgccgaggagguuguc\n", + "acacagcugugacaguaaagguuccccauuuauagacacauuguacaugauuguauguuucucauucucauagcuuauauugacacagcagaugauuuagaaagugacag\n", + "acggcaccgcpcuccgcaggcggcggcggccccapcccgcgcugccuucuuccuccgccgcuucgaccuguaggcuugcuugcpagcacag\n", + "agcaccucagagaccaacuggaagacaugacacucaacauguaguauugagauacugagacauuggcuggagagauuaacccagcc\n", + "auucccagcaugaaggcgaaaacggcauccugaucacaccaccaaccapcccgcuuccucag\n", + "auugguaauagaagaguucccaagauguaaaugccauaggagacaacaaguauucuucuccauugccacauggagcuagccuaucgcau\n", + "cacugcuggcagcgugaucaaagagagagaauucuugcagagugaguuggcuuuaaggaagcauacggaauugcuucuugucuuacag\n", + "acggugcacuuuccuagccaucgaguaugagucgcugaagupcaucaauuggcacagaacaaagcauuaaag\n", + "apagucgaggugcgupagacacapugugaguggapcgccgcapacaaugcggugapugcgugagagacaacguaccgcgg\n", + "uggccucapagaaaagcacggaugcggaggcuguggugcagcugapcacaguagaauccuuccugcccccgacag\n", + "uguccuucupcugcuuuaaaggacaucgaagccuucagaagagauucagcuauaaaaauacuuuccag\n", + "gugagcupuuuuucagcaacgaguuggugaaguucuagcuauugcguauggcauuuucagaauggucuugcaagaggcauuaaggag\n", + "paauaggaauaaaaacuccupccagguuuguguacauaaggaaaaggapucucaggaauccuucaaagugaacuggaag\n", + "gccccgccggagcggcgapcugcauuucagcuuucccaaguggcpuauguguccpcucccugguccccag\n", + "uuuucauccugagaacaucucugcgcuugaggcaggacacgcagacuggcucagcaggcugaggcpaagaacaapcccaggccuuaccuugacagccgguauuaag\n", + "cucugagaaucugccuugucaaaacuuccacgcugcpacacagcuuuugacagugguccucupaaagaaugcpcuugupacagag\n", + "agagccacaaaaacgcucagacccagucaccucggagcuggcacccauacacucuggaugccggcucccgcuuacccugccupcccagcuggcaccuuccguccccuggapa\n", + "gugcucacucuacguacuauucucuuccaacugcuccacagcucugaaccggugcucpagcuuguggaggccgcgcaaaapuuugcugugccggcacc\n", + "gccgcucgcuccugccugcagcpcgupcgcgcguccccgcagucugccggucaguccgcpcagcaccgcgugcggcggccgag\n", + "gucaguagugcagapuguuuuuccucgcpaagguggaaacuuuaccuguuauugacacagcuggagacugcugcuucggcgacaagucugucuccag\n", + "gcucuccagcccaggaggauaucugcucaccaucucaccauccccuuugccacuaagaccacggccucuc\n", + "aaagaacaagaagacccaggcacccucccuucccgaggagcccagaacccaaacaaagaggacagaucacccggaccagcccgcggcgaacaagcpccgagagccggcg\n", + "acapagcucacuaaguauaggcacacaacauggaaaaaauuagcacaagaccapaagaagcaggaggauacugaaaucuuucgaucuuggcaaugauuuggagaaagagaag\n", + "ggaggcggaggagccgcggagguggagapaggacggcggagaaggaggaggcgagcggupaaagagaguccucagccgcaggcgag\n", + "aguapcauucaguguupcuucgcugaguggacagagccagagaagcacaggaggaucgacuuc\n", + "aguuaccuucgucccccauucucugcuguugaagaaguuagauccuugcggugcuuccugauaacaaggaggccgag\n", + "cugacggagccgcccgcgugucuggacugcagcguccacggcugcauccgucaucagucuggagcccggucgguguuccccgcgcggauccccggcgccgup\n", + "gccaagaccgaaagucgcgcuguugucucacucuuccuaggaggaggcgagaauacaguuguggaaagugcccuauucaupcgccacggagaauugacaccaauuccuuccaggagcaaug\n", + "auupaccauuggacacuugcuugcccugaggcccpagcgcaccguugagguccguacugccuuggucagcacaccagucccgucccuggcccagcuccacgaagccaugag\n", + "gaggcuggaauacuaccugagacpaggacuccapccacuaucagaucaaaauugcaucccagcccucaaccagapaaaagagaaaagag\n", + "gaacacucuuggagcauugagaucccaacaaacaggcuguuccccaggaggaaccgccuucuuguaguuaa\n", + "aagcuucuggcuccgcgcacagucauuacuucaaupcaacuuugaacapcuucugucuguucuccucaagcaguuguggcag\n", + "gucuuucaccccuagguccuuccugagaacgaccuggaaagaccagacuacucugaaguaupaggcccacc\n", + "gugauaaagaaaacaggacagugccuccuuccauccugccuccucagcaaccauuucagcuaggagugccuccccgaccuucauacuuacucaaguggucag\n", + "cuugapagugccuguuguggugaucaaguugcacaagaagugaggagcuacugcauuuaucaucaauugcugaguuauggaaguuccagguugaggcuaauggauaucaaag\n", + "caaauuguaagaacuuucuugcagagcaugaggaugagcauagauauaguuggucuuugacuuuaacugcccagcagcaaagagaaagccuuucaaaauugaacagag\n", + "gcpcugcugcupcapugcuggcgccgcapcucgcagcaggccagcucgacccccgcggcgcgccgaacgcaaccuuuggag\n", + "guagaaagagauaagugagcccucuaucuccagccucucacuccugcccuaaccaaccagcguugcagcuuuuaugccucaguggcuucccuugcacuupuucugcucugcggcuuu\n", + "gccauuucuccgucuucgccuggcuggcggccgcguccgacccccuccpccgccagagccacaggaccugccgcggucgcggaccgcgcccaguc\n", + "agaggaagagaagccpcgcpaggcpccggcggcggcgguggagapcaacgcugcpaggcggcpagcgaguupcugupagacgugag\n", + "pcugcacuggcaaguucucaagugaauuccaacuagaggagaagaugaacagaaaauuaacaccccacuaa\n", + "agagccacggcugcgauggcggccuggcgcuccugucaggcccupcggagucaccuuccgcgugcc\n", + "cauuccuuuugauaguuccucuuuccaaagucgguuccugccuucauucaacgapuagaccaguggcacuaaccaaagagcuaccccaacaacccucccugaaagcag\n", + "ccuguucccggccgcgccggcggccagagacucacgcccgcacugupacggapccagcgcpaggccagagccgcagcagcgagcucugg\n", + "ggucucggccaugagagugccapaccagagcgauggcacagugugcuucgagcgugcgugcacag\n", + "apcgugagagaagagugaagauucaaguauugcugugaucugcagcuugauacccgcacugucaupacacccaapugaccgcugagaaggaacaccapcauucuggagaaag\n", + "aguggaggagucggcgccgagaacccpccccgagccaucapcucuggccgcuuccccgcagcpcaggcagcggagcaguuuacgcggugacgag\n", + "auuucagccuggaaggagaauaaagccugaaaacauauagcccagcucgauauuccaaagguaaccagugguacaaaacugcucagugaagagauagcug\n", + "acuguccauuuuccggcuuugaucagagcucaaauugucacaucgaaggaaguucaacugcuuggagcuaagauuggcagcuuauugccuaagaucuug\n", + "uuuguuuaccuuucugaggaauaupcugaagacaugccuucagcuggaagagaagcgcagcguccuaagaccgagcaccggcuugagugaacucagcccagaucucgg\n", + "gacccugccguuuuccaugacaguuggugagagaagagcugagcucaggcaggaggccccagaacag\n", + "ucucucucaggacccggccpcgccacgcagcugacupcagcaagagacccccgccccgccuccagccagcugcagcc\n", + "ggacgagcaaucucaagguagacccacugguccuuaaagaggccugagauugagugaauaggccuagguaag\n", + "gaagagacacuuccugcucccccgcgugugccuggcggugcgccugcgcucuguguaagcagcagccccccuggcuuccuucuuccacccacaggcucuccucucccgcucugagcuaaaccaaa\n", + "gauggcuauapapcucccgagagagaaagaggagcugaccpapuugcapcggcagcacpcgag\n", + "gagcuucuuccupcgccuaaguccugcucucuccucaucccpaupaagacgcaapuuuuucugcucucccaggagauccaagcag\n", + "cccucgccuuucgccggcuggcgccgcagcaucuucugcgcgacgcuggccucgaupuggupccccgaagacgcugugcugcuggacaag\n", + "caggaaccaggapagaapaagcagcaguagccaagcggapaggapcggagcggapcpcaggcggcaagagaaccuapcaggaagagagapcggucggcp\n", + "agcacpcuguguguauagucuugaaggaaguuccuuuauggacgugupacuugcggugcacgucccguuucacgcuuggccuaaaccacagaacgaagccacuauccauccag\n", + "acuggcugccauccccugcaccuugccgcucugccgaggaaacaggaaaggaucucagaagaaacguaaaccagcaccuccaucugcuauggccgapaguuuaugcuccaggcag\n", + "cgcucuggcucpauaagucagugcccagugucgcagaggaagaagagugagacgcgcgcggcgcgcgucucucugaggaagapagaagaggaugucucugcacguggcgaagcag\n", + "aaccgcggcucccagugcugguggacuuagcaaguuucagaaagcaacgaauuuuuauugcuucuaugcauaaaauuaug\n", + "uuuacaaaucagugcacgaacagaugugupagguggcgccuacgcugacgacgucugaggcpagcagccaccagcgcuccgccgcgccucugcauucagcugaagg\n", + "pacccguaggcgapcgccuagaaacacuggagccgucgccgccgcggcgapccpcaggcaacacccpagguapcpcpacucagcggccp\n", + "guuugugguaauauuauagugcauuuugauuuauuupucauuggaaauuauacauuugagauccuuauuucapugcuuuuuguucuuug\n", + "ucccuggupacuccuagacccccccauaccaguucauaccagccuggcucccacauccugugccuggaauccugugucaucgaaguccucuucccuacguc\n", + "gucccagaagcugccagguugaugagugcugccgcuccgccucpugucpcucccucagcgccgcc\n", + "ccgcgcucagagcucaggugcuucccagagcapaagcugaaggagguuguucagguuuacpuuugguaaaggcuccuuugcaggaggaupaugaaugcgaag\n", + "cccucucacucccgaggcaaggugccgcgcagccagaccggagcccugguggaggaggcacgagcapaggccggcggcagaaauc\n", + "agcpcggcaacgccaagaccaggapcggcggagagaagguagacucgagccgcccagcuccccaggcccapagaggcgccacgagccgccaaag\n", + "pacuacgaccuggcaagapaagguuugaagacaugaaaaaagacacugagaaucagaauuuag\n", + "starting opts\n", + "guuacacacggacugccucuaacuucuaaggcacaggagaggaapcauccugaaauuccgaagacgagcuuguagacc\n", + "guggcuuuuccaguguccugaauaaguuccauacapaagguugcugcgcuaccaccacuguagcaagaagagaac\n", + "apaucuuccaggccgcggagaaguugaagcugacuacacugagcuccgccuagagugucgacugcuaccapacugcccugaggaapaucaucugapccugcuaagaggcu\n", + "aaaagaaaaaaaaaaaaaaaaaaaaaaaaaacccaaaaagacaaaaaaaaccaaaaaaaaaaaaaaccaagaaccacaaaaagaggaaaaaaagagaaaaaaaagacauagaagappaggagac\n", + "guuugaaauauaauuauccccaacaacacaccuuuuuuaaaaaaccccuuccucuaaagcaagugccucaguuugguaaaccuuuuuucacaaaucaaagugucupcucccacuaacgcagug\n", + "gaauaacaguuggcgaagcccacccaaggaagaacccgguggugcagcaagaggaagupagagaaggcuupaaccaaggaauagacggauuuuugcuuauucaggaagcagaauugcauaacag\n", + "cagcuuggagaaaaggcccagagaaaggaguuucgguuauuaauaaacuaggagaacguuapcucupaagcucuucacgguuugagccpagucaguucgugacgagcucagga\n", + "acauaacuuucucccacacuucgaccaapcugagagcgcgugcuacaacgcgucccguccugcapugccugcgacucgccgguuugugccgcuuccguuuggcucgauauccaggaggccccg\n", + "ggaagcuucacacuggugucuggaaccgcapaccupagucaggaupcugcaggccpuguucaaucgaagcucugaca\n", + "cauuggacucaccuuuucaguaagcuggucaagaagucauuguagagcgccucugaagaaauuccacacugagcuuacuaaugaag\n", + "uuuugacaacuugugaaggcacucaaaagaaguuaaaucuaucugauauuaguaaacuuacagauaucuccagagcaucuuuuacagauagaagaauggag\n", + "gcagagcaggaagaaguagcpcggaggcagaaaaaggaacpcggaucgcuggagcccaaggccgagucgcuuuccpccgaagucgcaaaacccggacupagagcaacucagcacgcgcc\n", + "ggucaagucacucacucugaauaacccaacuugucacucaauacccuagcucgagaaggagcauaauaaaaaaaaccuccaggauauuugccuguuccuuaaaggaagucccuacaaca\n", + "pccpaggcaggagaagagagaapagaggacaaaaccagaaaacaacagagacaucaccucccaaacccucccaaccccucacapaaapagcgapcacaagcugcugguagagac\n", + "ggaaaagcaggcauagcgaaagacagaggaaaauuagaggaagacguaggagaggaccuaggcggcagcagaggagcugauccacagagacapaagagguagaggaggaagaaggaaaugaaagca\n", + "gucuuucagauccuccaucaggacaaauugacaccuauuauuugguauugugauaucgcpagcggugaacugcuuaac\n", + "gaagaacaaacaaaggcccuagaagcagagcgagcgcggacugaacuuagapagccgaaacaaaagug\n", + "guauuaugaaauauacucccuggacugcggaguggacguuggagagauuggaaaugagucccaccaccucugcuauacccpauuuacgagguauugguggcucauugaguagccua\n", + "auucpcuuuucacaaaacaucuuccaguggaacauuuucuuccaaauaccuuccuccaccuccucagcuauccucugcugacggcaauuugaccgaggacaggaagcaagugau\n", + "gcaaaccagucgguucagaaacgugcaaaagaaaaccaagcaggugacauuaauuagcucuaccg\n", + "pcgcggacgugaacaggauacagccacuguucuuaaaaaaccgcagcccccugugcgagguuucccucaccagccgucauugacgag\n", + "cauucaaccaauucugagagagaagcucuauuagaaucauuguugcauuuuucauaauaaaacauuucaaguacaccauuuuacggucc\n", + "ggauuuccugcagauacagaggaacuugapaaauucauaucauuccaaacuuauccagccuugacugcaaacaaacaaguguuuguauauagaucuuguugaaucauucuuggaauauuuguagac\n", + "auucccgcguggaaggcuccggaaucagcgucuuccucuguacuacucugccuccucuucccucccguuuuccugcgcacagugacggauuggagauuucuguucucucuagcuuacuugcpcgac\n", + "uagcauccugaacuuagugauaaagugaggaagaaggcugcugcaauaaaauuucugcugagaacuaaauuacugguuucugcagc\n", + "auugacaccuuaaaaaccugcucuucagugcaguucauaaaaacagccuuuugaagaaauupcucuggagauugugagacagcacuuuugcuguuguggcugugaagupagugagcac\n", + "uuuacaguuaguucaucaaaggaacugccacagccaccacgauapucacucacuacugcag\n", + "aauuuuuuccaucaccacaaapaguggaacuacagupuguuagaaguaaaauuagaaaucaupugauacaaccpaucggaagaaacagagauugucaggaaucuccu\n", + "cucacucucaccuggcucuucucacuggaagcccccugugugauaaaagaacugagcuuccuggugagaagagcagucucugcupaagagaugccccggaacuugaccuua\n", + "ccagcaaaaacaggaagagaccagaaagcagaggaaaaggaggagaggcggcggcpaggagguggcgcpagccpagaagagaggaagappagaugcuggcpagcuggagccgcc\n", + "ggaagaguuucuuggugauuuuuagauuupccucugugaaaaccaaccgaagguauaggacacagg\n", + "ugcucgugucugccagaguguguuacccggcgccaggagaccaacccgugaucagaggaccagag\n", + "uuuuucagcggccuuccccacgacguccuucacaaacucuucccgugcgacaccccuaaaccaaaguggucucpaaguaucaaggapcaccupucucuccugcccguauaggaagaga\n", + "gaacccggucggcpuccacpagcgcacggccaggucacpagcggagcgagapaggagug\n", + "gagauagaggaacccaaagagaccaaccacccagcccucccacacgcccaccccaccacaaccaacccagaccagcaaagacacca\n", + "ggaggaccgguguguagcugguaagauuuaacauccugguugcpaagauupaaggcaagucucaagcccagaagaacaaagaaauucuuacag\n", + "cggcccuugccaagcuucuuacacccaucccgauuccuacagcuuucugucuguuaaucaccaacaaccaaggccuuuggaucaaagaaaggcpcuguacaagaaggugccuccuccagcacgcau\n", + "ccuuacaacagauuccacugcguguacugugapaucugugaucagcuuacccgagauaccacccuuugccagucaacuaug\n", + "ggcgaccuuuugcauccaagagcuacagacuccagcgcuuugaagccccccccuccacuuucuccacccccucacugcagccacugucagacuuuuuacca\n", + "uuugccccaaggauuccagcuccuugaaggcccugupagaagguuaaaaauauuuacggcaggcagaccagugguggccaaaaggagaacaggauugcugcgaacugcu\n", + "ccucuccgcccccgucgugucccuuuuaccuccucagcuupauacccaacgugucccacccuucgupauguccaaggaggacgauuugauggacacg\n", + "agagcuguugaauucacccgaagcucacacguucccaagccaacccuuccuagcacccugugccccugucugcccccggucugagagccgucgccpapuuaagugcaca\n", + "ggaaaugcugcaugaaaacugcuucaacuuugaagacuacucagcuaccuugaacaucagagucuuugag\n", + "gaauugaacacccugugcgcggcagccacaguugcugcccacagagaaguuaauuuuccuaagcugcgcccuugaagupaagaaguuaacggaauuuggaacacaggugaucupuucagcaaug\n", + "gaacugcugaaaaguuuguggagacaaaaaaaaccaaauaaaaaaucaagaaacacacagagaag\n", + "agagguccuauuuggcuaagcagugacagccauucugcugagagccugacauugucuucuagaaa\n", + "agccpauucgugaggaagcucuuuuaaaccagagaaacugauagacccuagcuauuucggcuucuucccuggaccaggagucggcucccggacugaggugguuuuuucugagcggcucagguagcc\n", + "guuaaauucuaggcaagupaagcgcpagcaucacuagaagccgagguugauucccggcucuugucuucagcugccccguuaaacguagcgcuugcagacaugcucugcucucccaaucccgcc\n", + "ggaggaagaagaaaaacaagaaggaggaaaacaagccagcaacagaggcgcaaccagcacagacaucccagaccccgaagaagaagaguaggcucuagccgcagccaccgaaacugaggccggaagac\n", + "pauuggagacagcuugcguaagcucccugcucgcgcccuuuucauauaaccugccuuuacccucccguucucguggc\n", + "ggaggauaucacccagcagagugaaapaccaugucaaucaagaacuccuguacacapaggaggacugaggagaaaacaguccugccacgaaucuugg\n", + "agcgagccapcgaagcgcagcaaagucggucugcgcgcaguagcgugcucgcucccugcagccaacagaaucacagaggcggcpcugagcpacpcgcuucgcugcugcagcaccag\n", + "aagacaaggaaguuauaaaucucucugaaggaacugucccaauccccaccuccucccagcccauccacuuaccugaapauauaauauuuacaaccuuuuaaccccauuuggaaaggcaguauc\n", + "ggucaggcuccgagcacugaaugccucuuauucagaaaaagauacauucuuucaacaauucauac\n", + "uuuucaccaucaucaacgucugccuacgaagacgacugcugugagaaguccuuggcuucaaauauugg\n", + "ccagaaaaaaagaaaggaagagaaaaaaggaccgaagaagapaaaagagcuaagaggaaaaggaagaaagagaaaauggaapapaggcagcggaggcggcggcggcggcggcgacccgcaaa\n", + "gaugaacccuaaacaaaccauguauucgcugucaaucaaacuuggcauuucaaauuuccagagcugc\n", + "ggaguccaauuaaaaacguagccgcgaaguacagugccagcgaagauaacaaaaaggcggcaaag\n", + "gagucugaagcuguuuacccaccagcacggaagucaaaacauaccacauggaa\n", + "gucuaaaagaaacagauuaaggcaguuuuaaaaaauccpcuuucuuuuccuucggcuuucucugacauagugcaaaguauaagaaagacuggaagaagguaucccuggcaaaacucuucagcag\n", + "auuaucucaguugacugagccucagaaucuagugccapcapacacauacccugcuccaauacccpugcag\n", + "auaaaucucacugaguccggcugacaucaucacuguagcucuggauugacuaauaaaaacacauuuuugccucacaacuggaaagaaauacagguuaccacaga\n", + "aacugucuaugcugccaauaauucacauaagcaaggacucccaucucacuccuagaucuaggagaaaaagagagaaguuuaaccua\n", + "pcaggacaacaagaucgaguuugcauuuugcugcuggcgcuggccagaaacaggccaacaaccaupagcugaugcuucuccugaaauugaacacaaggugaaugcapacaagagaucuaaag\n", + "cuucugagccugcuucuauugaaacauuauccaauacagaaacauuauauucucaaauuucaaaagcaaacaauuucagaaaacapuuauaggaaaauagguagguaucuguuuaucauggcggcu\n", + "gcucuuuuggccgcccaggcucaaguagcauuuuggcagccacuucggcagcccaacuuuccapauccugcugcpccuggaccpcccagcucucccaaaacauuaauagauuggcauuu\n", + "gaaauacaagcauuugaacaacuuuuucagaggcaucauaucugacccaaggcugcugaauuucgacagcu\n", + "ggugcuacgugcaguuuucaccuccugcucuuucgagugacaggacuggugcagcccgcgccgcugcuccaapacuucpuuauuucacagacapauggagauggauguccccacg\n", + "guucagacacauccuaaagucuccacgcaguuuaaaaaaacuuucaacuaggapccuuagauuaaaaaaaacaacgccuuagacauaaaaaaagacaauaa\n", + "gcgcgcagcaauagcagcagccgcgcaacgcggccpagcgucaguggcagcacccuguccaaacaag\n", + "uucaacuuacucugagcacccacaggccaapugguuggaagcucugcuuuuaugaugacgaccauauug\n", + "pcagacgagacugucacacacgagcuguacuugcaccucccuccccaggcucacacuucuuugaaaagcuggucccucugapagugcccagcuggcaguggcacuccaguuucccugcacc\n", + "agcucaggauugcuuaccccagcccaggcuuuaaaauccuguccgcucgccucauccacugccucaccagcagaaaagacuuccuguauuggaagagcccucaucccagacacagcauccuugag\n", + "guaucaccagagguucgagaagcuuugucauuguccpagucgccucugugcauccuugacuccaccacacgaagugapugugguucccuguaggauaaguuaagugag\n", + "auccaaaaccaccugagaggcugaggcaccagcggagaccaaggagaggcuuucaaaag\n", + "gugaccagauccuucugauaauapuucaaaaaaacuucccugaggaaguuuacaaugaccugc\n", + "ucguagcucacucuagaccccuaaagccpcuuugcaaggaucugaaguuccaguuagcacccggacagugaagaagcgagagaaguaagg\n", + "cuugacuaucugucccgaaagaccaacacagaaggaagacuacacuagucuguucauacucaauu\n", + "agccauacacacagguggcaaucauuuauccugaggaaacugcacucccugagcggccaauuuguuccuggagcacagucuacagg\n", + "auucauuagagcaagucuguggccgaaggaaaaccuuggacucaguucagauagcagauauugaaccacugaucucuguuuuguugguugguacuuugaagaaagag\n", + "uaccaggcacaccuuccacacacaaauuguaggaagccuguuguuacauaaaaacgauaauacauaaggcuaccaucagguucuguggauaacauccagagaauugaguucagaggcuuuuuuuggcc\n", + "aacacagaacaagaaccggucpuupcgguggucgcgguggaggcccgcgacccaaacuccggucuggugcauaupcguupugccgaacgcgcaccggcgccugaagcagucacgugac\n", + "guuaaauguuaaaaacgugccacpaggagguguuuccagaacaagacccugcagacucuagauuuccccuacacaguuucuaaaaca\n", + "gauauugcaaucuggccaaagugaaaccaaugaagauggaugauaauuacaacaaacacucagaaauaaaacugcuuaggacaagaagaauucuaaagauaaagaucuuuguggcuucuuuucaa\n", + "gcaagcccauuguguccauuaaauuugcuaaacaucaucgcuguagagcuugauucuucucuacuuggaapagcagagagagguuaagaagaaguugcuagcuagccguggagaagaacugau\n", + "cuccauucccacauccacccccucacaagucuucucccuagguuguccucaguguucaucaaaaggaaguucaaaacuaggcccugaagaaaaaa\n", + "guaaauuuupaaaaagcuuucugcuggaauccaaaagcauuugaaaauccaacuccagccccauacccg\n", + "paagaagaggaggaapcggagccuggcugcagccguccaggcggcgagcacggcgacagcccagcucacagcagccggucgaacgcugucc\n", + "uucggccgagcucuacaaacggugcpcggcgacugccgcgcgucucucuuaggcucagcaacccccuacucaggc\n", + "aaguccacugaggaggaggagaagaagaaggaaaagaaaaaaggagagacacugagcggaaaaaggaagaggaggaggcpaggaggaaacagagaaggaaaggaggcagaggcaapcpaac\n", + "gucuuugcagcuugccagaacagaagcaacuuuguacaacagccapcaaauguuuauucaagau\n", + "gaauucacapccacugagacucugcacugcaauauauuuuauaagacauuuauaaagaagcgg\n", + "aaaaagaaaaaaggaaucacagacguagcagcagaggccauccagagagaggagucggcggapagcugagagagagaggcpcggcggcp\n", + "paggagaagagagaggagaaaaaagagapagaggcpaagagaggaaagaaaaaaaaaagaagaaagaaaaaaagaagcugacauugaaagguuucuaaaag\n", + "ggaaguuaccauuacaggugccccugaacccaggcauuuuacauaaguucaaaaauuuccucucucacauaaggaacaacaagaagaauaaaaaauaaacuuuaucaccagaucuggacaugcugcuc\n", + "cagaacauaaaaaaagaacucuaacagaaagacauaaaauaaagaaagaccacagagagaggcacaaaacccuuagaggcaguaggaaacagaagaaagaaggaaaggaguagauggaggaagaagaa\n", + "gccugccugcagaaacccaagaaguaaaccauaguuacaccauuagaguccuugagcuaucaaag\n", + "gaauuucgcgccagcgccucguccaucacucucagucgcauuucccaagaggccggaaggagcug\n", + "gaucauaacuauuauaucaacaaggapugucugcgugugaguuuucacugucagaaaucugaaguggauaaauuguuugucuuuguagcugugagaacuuuaucuucaacu\n", + "ggcagucucauucuaccugcuaccgccuccgcuuccggaaggcauugaaauuggacuuuccgccpaagaapaaguuaaaauggag\n", + "gcgccccauuaucucccucccugaagcaggauccapaagcaggcggcupaucaggagugcucgcauuccagcuuggccaagaacu\n", + "gagaauuccacacaggagcagaaguaagcguuucuuuucuugaaccugucpuacgaagccuccuacacgcugaggaugaauuuuaaa\n", + "cagaacuguaucagagugaacccauccucucacagccacagaucccucacaccaucccauacccuuacccu\n", + "ggaggcccucccacucgcugagagcucagaccuuuuccgccugcgcuucucucacagugaucuccacuccaacgaagcguagaagagcgcuccugcaaacccgcuccccggauaaaggagcccguauc\n", + "acucuccaggcuggagccgagcgcugcagacaaupacpugcuugccuaucucuccuuccggaaaugcagagcugugcpcugcaacuguguccagacacaagu\n", + "ccuuuuuaaauccgaaaucuuuuaaauccaaccaaguuugagauuugugacuacauccuucucpagucucccagagugaaaaaaggaucupaaguucugugag\n", + "guaguagccucuguuguugcuuuguuuuacccaagacucuuacucuggaaguuaccacuccaggaggccgagagaga\n", + "paagagaggugaaggacaggaccccaaacuacuaagaagaacacgucccpuucuagcccccgucacccaggcc\n", + "uucugagaagaggccggaagaggagacgccgcuuacaaagccuggacagacgaacucaauuacuuuccacaaggaggaggagagcaaggauccgaagcgcacgaccuugcuaacuaccuauggucccc\n", + "ggaugugugacuuacugacauuaacuacucgcucucugacacucccauccaaaaggcagagccccugccuuggacaaauagaaacapccuuuuacagauccauucgagaaa\n", + "aacuagcagugguacapaccugcugacccuaagacacccagapagaapaggaguccccgccgccacagacauupcucauugguauuagagcuuggacacauacgcucgag\n", + "gaaggcccuccacguggcgcucugacguguuuggugugcgccuguucucuggugccpacaggcguuaua\n", + "ugcaauuuucugagaucauuuggagaaaguacaugcuccaaacccgcpcccaggaagaggcucucacugguuuacuuugcccuccaacuuuuucccgagaggacucccagcugcugccccugcagc\n", + "aucguaauccagcgccuuugguuccuuauugcaccaaaauguccagaauucagauuacaacaaag\n", + "guucagaauacuuggacaccaucuggcuaagaaggccaacagcauuaauccaaggcugaaaaaac\n", + "gguggcgaggccuuccuuacucaccaacaguugugcugcagacacuaggacccugcacccaaucuuguguggccagagaaaucgagaugccu\n", + "pcccaaugaagaggaccucgaaaaagucaaaacaggaggaggcaccagagacagaaaaacaaaaagaaaaaacacaccuacaacaaaac\n", + "agaaaacugcauugcuuuauauaaaaaugguagccuuauauaaccagguaagcaccugccuccaccucuccuccugcagcaagupuccugaaucugugcggaggacauacagauauaaca\n", + "acacagagugaccgcuuuccaagcaggagcgaccgacguacccgcpccugaacagaaucuupcuagaucacuucgaccugccuucccucuucccauguuacuucuggacagc\n", + "uuuccauuggagcaaccagagaucugcaucuuugaccucuuccaaucuguugacaauuacaauug\n", + "pccuaaaacccagaaggcacacaagauugacaaccagcaacuaagaaugccaagaagaucuuuuaauucg\n", + "cuccaucacauacagacccucauuugugguugaupagguuucaaauaaaaaguaucucaccauuuacugapuuuucupaggaaguguggaaauucuccapauggugaugcaugaguac\n", + "auuaaggcaaaaacacggaaaucaggcaaagcaaagcccaagccuccaccuacucgccuuacagaaccaggaguuuauuaaugcaggcgugcaagagagagguggcaaag\n", + "ggaggagauuuucuguggcaggaapapacacaaagauuccugaaggaagugaggugaagaagaagcucauuaacucagguuuguggugauaauugaagacuuuacgucugcuccagcaucaccu\n", + "ggaggucuuugcaacacgauuccuuuguucuuucuuaagccugaccggcggccagaguggcaaaaggaaccagcuacagcaugaag\n", + "cucugagcgcccggacucagcgaagcucuggaapugacugacaggagucaacuguauugcuguucuuaggaaagauuugaaaaucgcacuucuucagccugcagcuuguaagcugaaaaag\n", + "gucaaucucccauuucugaggcgcapucccagcagaucagagaguccucuauaguggaagcaggag\n", + "gaccgagccaaggagccaccaccgcgccucaagcaagcacggccggcgcgcuccugcagagcgcuccgcgcgacgupagccgagaggaagucugcccgcpaccgapaacggacaupcucc\n", + "gagccggcgcgcguucaaaaacucupcuggcucpuugcpaapcacggugucugcguguccuugcauuuupugupauuuugauacggugapapuuuggaacacaaa\n", + "aggcuccggacaaaaccgcccccgcccagcagccucaggagcacaauaacuucagaaauaucucucacagucuuuuaaugagcuugcaagaaaccaagaggaca\n", + "aaacaagacagaagcgcgacugcggaagcuaacaggcaggcgcgcaggaaaggaaagagaacgagcggccagagagagagacgccpcggcgagcagaugagg\n", + "gaaauugccuuugugaagcauucucuuaaauuggccagagcucugagccguugaggaccgcagccacugcaaacacu\n", + "ggaggugcugcacccguugcacuucugauuucuuaaauuuuccaguaagcucuggaagauuaggcagaaaa\n", + "apaccuauucucacacuuuagcuuaccugcagguugucuacuuggaacugagaaguuuupauuucagcccuuucagaauauagguguugaucaaguaucgapccaagagcagaccugcuc\n", + "cucuaaaaacuguguugcgcaugacauugcgcagcccggacgagaggcggauugugaupcaagaa\n", + "uuacuagccaaaaaggauugaagaucuguauuaacuucgucacauugaccaaauccauauauuucgag\n", + "uuggagcccuggaaaucuuucuaagcgaucuccgcagcagucaucuuccagcuccacguccucuccgagcggaccagaccucccauugcaggacaaagcuguucagaaggaacaaaacuugccuugcc\n", + "cuuaacucgcgcugaggugccagaggagcgaacugacuuugaggagcgcugcccucggacacugaagaagccaguuupuguuugaucgcuucucggaagucuuagccuggacccggacauuaa\n", + "gauucagguggugacaggaguucccacugcaagaaauacuggccucgcagcaauccagaaccaau\n", + "ccagagaccuccgucuugagaagccaacuaucucaaaaacaaguaugugccuccagucugucucagcuccucgacuggauucaggaucacacuuaagc\n", + "aaauguuagcucgugcccacucucugagcacggccuuccpcuucgguccuugcccagaapaguggcgcaccugucagaggugagcgcacuuuccgcupagcucacgcacugaaucgaag\n", + "aauuaccauugucacugagaccuugcaaucuaggagaccuuaaccuauagaccucccauaaaaucucacucuccaguccagcucuccucuuuuuucccuagaga\n", + "uuuccccucccgcuccagagacccugaaggaaaaggaaacagaacagcaaaaaagccaaaccaauaccaaccuaaggagaagcagccagaggagaaaaagaaaccagaaacgccgcacaggcaggcaa\n", + "pcagaaggagaggcggagacuaggaaggaaaggaaaaagaucccaaaucccagagaaaccccagagapacccacpaaccagaacagaggcagaggaggaagcagcagcpaggcpaaag\n", + "gccguugaaaacaaucuccccagaaccagacccuccgcagcaaaccgcgucggagccgcapcgccapagaccacgccagccccugagcaggaaggagcuaaggugacuapaaaccucaacc\n", + "guagugaggaaagucuccaccuugugcccuggcccucccggaacccggacgccuggcupccuuaccucggccagacucucuuuccagguuugguuccaacugcuacccacguuauuucaggaagga\n", + "aauuccaaagugagauaccccuugguucucacuuucaccguauaaagguacgg\n", + "guagcagcauuuauuuaacagauucugcauccgcugcaauagcagaaauggaaaauagagcaaugcaguuugaagcccacaucccaaguaaauuugaggaguuaaggauaaacaccauugguauccag\n", + "gguccacaaacugaggcguugacgcuggcggcpuuugccpcugagcggugguuacccaaag\n", + "gaauucaaauccugcaggaggcaaucacuaucuauuauuaagaaauucuaaaaaauauacug\n", + "gacucauaaaapuuguaucugaaaaaucugcaagcucaggagcuggccucauuuauacauacaaucugccgccagaacuugagaaaa\n", + "ccpcaggaccugcccggauucccpcgaggugcggccgccuucacucggccapuaauacguguggucupuguguugguuuuggagcuggugcccgagucccuggaapaguupcaaac\n", + "cggcugccgguugagagccuuuuaaaccugaguugcagcggccggcugaaucgccpcaacaguguucccuugcacuugaggcugcagaauuuugucaaagagcccagugguuggagucuuucggcu\n", + "agcgcggcgacgucggucgcagcggcugagaucpcaauccgaagagugagugacacuucagaaacucggaagcucaaucuuaaaacaggcuucugcagupcc\n", + "gcaaaacuuugagcuguugcagaagcacggagcagagacugaggcugaagagcacauaaagcuacugcuuuggcagaagauaaguccagccaggcggagcaggaggaagauccucccaaaaucugccc\n", + "uucucaccgccuucgccuuucauuucucucucucucuccuagccaagcuuccgaguccaucuccagagcugcggaucugcaggagccacgagucucccucucagcagaucacaaaaacaug\n", + "guccapucucauacacacggaaagaaggacagcugcuggagaaccccuggucccgugaccagcaucaaucugaagauuuucuac\n", + "uuugagaagaagaaaggaggccaucuugacaaucuugucauupcuccccaacauccuuaacccuccagagaag\n", + "aacacucguucpuuuguggaggccggcggcagcgcgagccgcaacuuagccggaagucagccgcucaccgccggcacacccagauugccgcgacuu\n", + "ggaucccgaaaucaauaccagagaucaccccaggauccccpaccaggcuguccgaapaggapaggagaga\n", + "caccucuuucagcugcuuuucucccucugagcagacaaagaucaaugcaaacucaguupucccacc\n", + "gcuuucucuccagcauccugguuagcgugacucggcuuccaacucuguuucuuuguagaaggagapaguggcugaccupauccacuuuccagac\n", + "uaacuugugaccaacagaaacacagaaggugaagaauuuggagcagcuauucagagcuaaauaauucagcugcugagcauauggagaaa\n", + "agaauuccggcgagagcggaacgcgcgccagagccaaccugcpuuaccggaggcggcugagagagaag\n", + "gauucagucuggagcuuauaucuccucccgacuccacaaacuccuuggauaagaaaucaauucauuguugccuccucuccagcuuagcuaggaggaaacaaaggagaagcgcgaauaacagacauucc\n", + "gauugaaaguugucaaguuauaggcauccgaauuauuugaauagaagaaauucaaaaaaguggag\n", + "gaggaauuacaaauaagguguucaaaaaaaauaaaggaacguucuuuggaucuucuaucaug\n", + "agaugucauugagccccacagccuacaccaagaacuccagcacaccuacaacagccaugauggacacuaggaagauugcccaauccugcacacgucupucucuaccuccagac\n", + "ggaaguguuaccuaguccacuguggagccauaccaacacaacacacacuaauuggaagagaagagaagacc\n", + "ggacgcagagacagaggcggagapcagcaccuggaaccagagacgaauccccagaugcagaaccagccccpagcpcccuguccggcccccggagaacgagagcugcaapcggapagcg\n", + "gguucggcgcgcagagcggcgacgcucuuaguccacucucccugagccaggaaccggcgcagucaaagcag\n", + "gaagaucagaaggauacaccccucupaauupugccuaaguuacauccaagacagcuuggaaagcuucucuuauuaucaagccccuacuguuggc\n", + "aacuccguuuuaaacacaacauaauaucuuuauuggcauuccuggcauccuuccccacaagagcgucacucguuagaacugcuuccuggaaagcucaaacuucaccuuggacugaaaga\n", + "auucuggucaucuuuccucccuccgagccuuapcugacagagcagaccaggaacagcacacupuugcaccagaucuucuggccugccaaagaggcagugaaacuacagaguugaucauagua\n", + "guaaaaacaapcuccugcagcccagcuuuggauuuucuagugaccaauaaagacauucuggaaaaggaaccaguaaaagaaauaauguaccuuuuagcaggccuuguaucagcap\n", + "cuggcuucagauaagcaaaagauccugguggugguuuaaaaagguaaaaaucagcgagcaauuucuaggauuccuuggaauauuuguugucgaguugacaacuuuuagugagauuuuagacc\n", + "gcugapauuccgccucccuucccapacccccccaaaaaucucuaucucaagugcuggaaggcua\n", + "gucuagaguaagugucggauacccaagcaagagaauguuugaucccacucucaggaguaugucccaggcuggaguaagcaacacugucgaagcugagauaagaauaccaggagaaggagucaucgag\n", + "ugacaaucaucggcaccuuuccaguugaccauacacacuacuuugccggagugauacacaaaaaucacgacuuucugauuuugaagaagcacaucapacuccaucuuucagcuucaggaacucuuu\n", + "ggaaaccaacugcuuuccacuccugagugagguuucaauccagcaacaucaggagaagacaaagaauuupcuuuaaaaaaaccaacagauucugagccaagacugcuc\n", + "gcacagupaagaucucugcaguggcugagagcaccuuggacagcagcccccacaacuuccucugccacc\n", + "gaguuggcauccuggcaucaggaccuguuacuuggcuuccugcucuuucccgacucagaaucccuccgacucupaguggcuuagacgucacagaccauaaacacuuuucuguucaucucpcc\n", + "ggugccuauagugagucacapagacgguggcgcugccacggcgaggcccgcguucccgcaacucpuucucuuguccagguggccacgaguaaggugugupcagcaucucapucucgcag\n", + "uguccagcaaagacacugcagacagugaaguuuauaaaaaagcagcugguucuccagauccaauaaacaggccuuuaaaaccugucagc\n", + "apuucugcagcacacgcagcgcgcucagagcacugccgauupcucucggaggagucaccuggaagugugaagcaucucuacagugaaacaagc\n", + "aacacuucugcuuuugucucaagagcagacaacagaaagaauauagaaauaaaaaaaacuuuugcuacuaaguag\n", + "ccaagaauccaaaaaaaaagccaacacccacacagucuaaaacaccuaccgcaagagaccaaaaccccaaacaccacccaaaccgaccacaccagccaaaacacacaaacgcaguaggaagaaaagac\n", + "gugcuauccagcuggcagcaagagcuaucagaaguaugacuaaaucuuuuaacacacuuaggacccuuucccacuuuucuuuucaaauuauguuuaaa\n", + "uccggacugccugupagcaccgcagcccgcgucgccucagcgaccgccucugccacccucgucggagucacg\n", + "auuccagaccugugcuggugacacucagcagcauccacaccugguccacacuguggcuucacagccugcgcaggcgcagapuuucuucgaacauucauguuugagaucaug\n", + "gccuguggacaggucagcuucccaccggcgaccucguupuuccupucgagcccagaucagcuucccgaaauuccagcuaacaaacuugugucuucagcccuuugag\n", + "ucauuucucgcucgcacaagaucuuucuaaaauacauaucacccuagcuucccagucacccuuucaau\n", + "ggagugcacgucuacgagacacccguucagauuccucgcaagucugaggaagugcccgugccuggcucuuuacccccccgcupuucgcucuguccuuuucccugupcuaccucaucacca\n", + "acugaggaaucuugcacagcucuaaaaagagaucuugcagcuuauuuuucaaaaaaaaauugagcaguucacag\n", + "ggaccagcuuccgccgccgcuucucacucuccuuacucgcaaugaguccccccgcccgcucgguugucccucugccaccgcccuuccccgccuuccaaaaucag\n", + "aggaagcgacaagaaacauaaccaauaacaaauaacauccuccucguuggaacccaaucaggagacuauaaaaucuuccguggauuggaaaacccaauaccccagacagcupuccccaagucc\n", + "ggagaauuaguuuguuauauuuucuauuguguacuggaaacaccuggcuuaaaaaaggauauaguugucauauuacugucacuggaagcaguugguagagguaauuacugaaagaaauaaaagaaacu\n", + "cggcgacacagcccaguuccuugucaucacaguccgcuggagaggcagccuacagcgcgcugagccggagacgccugucagcggcgugcgccpaagcgaggcuc\n", + "gacacugagcacccagacugagaaaacucacucacguuagccuccucucccuccucuucuaccucccccaucaauauuucguu\n", + "uuccacuccuuaagcaagacaaauaaapacauuguauugcuaaacaaacaacaggcaaaccuguuccucggugacaguccauuuggucaccggaauuuugugaaucugaagaauacaugcgcagg\n", + "guccagaguacagucacauccacccacccuccaacagcccuucuaaaaacuuuguccuucauuugagagaaaauaacaauacacugaagaugcuguuucuuccgccuucacucaaguugcagaaaguc\n", + "guaacaauccucugcccuuggcucccaaaccacuuugaacaaccauauaaacucuaaagaaaaauuacuaagac\n", + "gagugcuuuacccagcucccugcuggucuccugcauccucugccaccuccccagccucuaaaccugcacccucuuggagu\n", + "agauucuccagcaaaaaucucacucauaaauacagguuaauucacauuugccpaggaaaucaaauugaaaacagagccucuuuuggagaaaggcuguuugcuucauauaua\n", + "cacauucucaagaaaccuccugcuucacacagaggccacaaccacaguuguauuacacuuccaacacag\n", + "cuucgcuguggacuccgacggcgcggcgcgaacagccgaccccaucugcuucaguucgguuuccuccggugcgguuacupucagagg\n", + "aguggaguucugcugcgcgugaacccggcugcuuuccucugccugcacgapaagaaggcucacuccacuucapaguacauacuguggcugaagaaaauuucucucguugcuuuuuucuagcuag\n", + "pauucuaucugaacccuccacuuucuuacaauacagacucuagaagucccugcaucguuuaaguuaa\n", + "uuaaaaggugagaaaauagacaauuaaagauuuucgauacuaaguuacuauaacuuuccauuuaagag\n", + "gaucuaucaaaaggaaguucagcaacaccucucaaucuccaauccccauccacuggacgcugcacacaauccccacaaaauauuugauuucc\n", + "aacacacpcugcpcpcugcccccagagagcaggccgugcgcggagacgcgagcacuug\n", + "ugacccgcupcucugcggacugucapaggcugucupcuccaguggcggccgagcpcacugagugugaccagucucucgugucugaggugcuggagucaucucagcugugcpcgcgaca\n", + "caaagucaagaaaaacagcacagaugaacuuauauuucacaaaagacauaccaggcagcuauugcuucuauuuauucauuuuacgaaaacacagcccugag\n", + "apuccuguuaagaaaggcacacccaauuuugucuuuaaaaauuggauuccuuccagaggauuapacu\n", + "cugcuuugacgaacaucuaucaccucgugcucuugcuaauacaauaaccuuugccagguggacucugucpuguagaaapaaugagucuuuuacug\n", + "gugcgcagugacugcccuaauuuccagcauccccauacucuccagcuugacucacugacuuuggaagagccaaguuaaaaaug\n", + "gaguuggaggaggacaagcccuuggcuuaaaucucuuucaaaucucuggagcagguuucugugacaucgcugugauauucuucggaauccacuugcuucacagguuuucccaauucccggaacaccaa\n", + "aggacacuuucguugccpuucaucugacugugcagaaggaguuuauuggacugcauccauucugugcagaagcuaaaaaagua\n", + "agcugccacaggaaaaggaaacagaagaaaacccagagcccaauccaagagcccaccccacaaacccucacagagagacccgccacagucaaacccuaagaagaggcagaagccaggaccggaaagaa\n", + "agaaaccaaagaaucacacaggcucauuuaaaucuacagaaguguacagaauaacucccugccaggaucaaggcugucgugccaggapaaacacagcaguuuugcucuguuucgcucaagcuuacu\n", + "uuucacuuuuggagcuuaagcagcuccaauaagccagaauuacccacuagauucauauuuuaaga\n", + "gauuauuuauauaauaagacaaaaaaauccagaaaaacagauuuuuucaagauaucuguuccauucacaagccuuuguccuguaauuugaaacaaaagagcagcuggaagaauaagcaagcauuacag\n", + "aggapuucaguuuccucuagcgaggagcagaucaagagaaugagacupcccccucuuuccaaca\n", + "cuucacuccagcagccagagacugcaaggcgccaccapaauuuaagaucucagaaaucaaagga\n", + "ccgcaguuccugcugcucccagagucgaucguccuguccacucuccucggaagccagcuacgcag\n", + "gauaaucagagaagcuaaaaucacuuggcagaaggaucagugccggcguaaaagac\n", + "guccuuugcagaauuacuuaucaucucuccaacccaaauccaaccaguaggaacagguugauaagucccugcuguaguuuuaguauuguccuuuugagaaapaaaacagaauugcagcaucaaau\n", + "gcuagcugcggagcagcccauccaagcuguguaagcugagaccuuggacacccucuacuuccccg\n", + "gaagaagcuuacgcuuacaggacagagcgcgcggagcpcuccgccgucccpagagagcgagccgccugupugcugcgcugaccgcuggucucacuuccgcagcgccpcccagcgcacgc\n", + "gaggaaapcuuaauuuugagagccucuucugucuuccccaggugaaugcaccgugccucugacuucccucupaaagapcuucaauaapccacucagagugagucu\n", + "paaauupcuuccaaacaugcguacugcggugauucacagaaacaaguacuuaaguuacccaucagac\n", + "cugauuuccaaaaucauccuaccuupcagcuggaagauugcugauucuuggaauacuacacacagcuucacupccugaggagaacuugauuuuagugacgcugcaagcuugugcggaapccc\n", + "gaaaguggucuuucccucccapauuucaauaguucacgaagcugccauuucaugucauuuucuaccaagcugugcaguguggcuuuauuuaag\n", + "ggaucaagcagcagcagcagcagcagaggcaggagacggacaccgaggagaagaaaaagccagcgcccaca\n", + "ggucaguaauaucacugucuacauccccuacuaggcagcupcgaggaacccccuccccuucacauuuaaaaacacacgguucucag\n", + "gcaguuuagugcuggaguguacuuggaauccacaucaucacuggaagcagaguccacacaaggaaaacacaauagcaaacgaagacagcgacgaacguggaccaacaucugcc\n", + "upagcappacaacgcagucpcgucuugucuuacugguguucccuccaapaaccucag\n", + "gcuuguaaapagaucagccuaaucuaaccucacucuugccugcuguggaauuaapcccaag\n", + "gacugacugcucgcucccgcugcuucagcgccaaagcguucagacuuacuccgacagugguagcaaggcggaagacaaugaugagagcgaaaagacucaagaaaaccugcccucgugugucuugcauu\n", + "agaagaauucccacuuaguaagccugagaaaagaacuguauaaaaucaccugaauaacucauauaaaauauagagacugucuaaagaccccugaaagacgugguguuguuugccuucugacc\n", + "agaagaagaaaagagaagaaggucuccagucacaucucucuaacuccaaggcucuugcagaaacaagucacagccuaagcacaucuguuucuagaaaaggaguuugcacauaguccagagccauagau\n", + "gguccuuuauggcccucaacagagcucgcgcccucaccuggaupacuccaagaccaacuucccgcucacuucaccaaguucuguuccugupaggccgcgaccugacgcgaucucaacu\n", + "ggcauuggacuuggaaucuuucuucuucggauacuguaaacagaacugagaacccagaaccacuucacuguccccugaggaguggcucccacaguguucuuugcagacuggccauguuggaucuggcc\n", + "agauuuccagauugaaucaccaaagcccagacuuagacuaaaagcaucaaguccuccauuuuggaaaggaaauuauaagcucugugaagaacacagaccagucagagucaacagacacuaag\n", + "gguccugucacaccaaacupucuaaaguuaucucupagaaaauccgucuuccucaaccacuggaaga\n", + "uccccucucccaagcgccaccaucuaucacauccuuucugugacgaacacagaaugaaaggaacugag\n", + "ggccgaagccpccaapauuuuccagaguucaucccuuccagcgccaaauugcuguagcuaccagaagcucagaaaa\n", + "paggugacgccagaggaaagcgucaccuugccacaaaaguucaccagagaaagucugagag\n", + "gcuacuucaauagacaagaagguucccaaggaaacucapuccaagucucucucuuucaucacagcugaagccggucaguuccugagagca\n", + "aaaggaaaaaagaacaccaaucacagacagaaaacaaaaaaccaacaaaaaccagccccaaccacaccggaaccacaaaaaacaacccuagcaaaacaaagcccaggaaacuuagaaggaggaagaaa\n", + "ugcauaccagccugaauaagacaaaaaacuucgcggagccagcagugcuaaccaacccaguacccccaggacaacgaacagagaacaccagacaacuggagacgaucuuggaacacucugugagcacu\n", + "gucaaaugcaggaauucaggauauccacuaacaacaacccugcuggaagacagucauauccuaag\n", + "gcaaguacgaaaaaaccagcgguacaagcacagaguccacuacccaccacggaccugagauuggaggcauugaaagguuuuuaaauaagaggucuggaaacucacugcggaaacagcaacapaccc\n", + "aaagaacuccccacucucccccacgcaaucccacaacaapacaucucaauagacagagupaagagauagagcuguguuagaaaguuucuggaacaacupcccaagauaagcaacaaacug\n", + "agaaaaaaacggaaacagcpaagagugaggcugagaagccuuuccagucuucaccaagccugcuguaagaagccgaggugugcagucucguggcupauuccaagauacugcucauuuugcaacc\n", + "gauuaaguguccugcaggucgccagccgcugccgccggacgccgcuccgagccucgacccgaggaguacugcacgagagaggagcgaugagacgcggcagugcucgcpagcgcgccuccgcgaccu\n", + "aaaagacaccacacccagcgccaaccgcgaacccaaucccaaccaggagcauaggcuagaggauaccgagaggaggcagagagaaaaaaaaaaaagaaggcaacaaacccuagaagaapagaaaaa\n", + "aguuguaggucccacagaacuaucuugccccauggauaaaagugucccuuggaacgaagcapag\n", + "ggaaucugcacgccaagcccuccacacaagagcccaucacccaaaaaccucaaaaaggaaaccaaaccagacaaacaacccucaaagagaagacaaccaagacccugaapaacccpcpagg\n", + "uuugcacacuuuuguuacccacagaaccaauagacacccagagaaucaaaagcagacacuuuuccuugguacuguuucacaaaaggaucacccaagaauucagacaagcagaauccccauugauucau\n", + "uauuaucacuagcuggcacucaccucaaacaagaagacuuuuauauaaaaaacagccacacagag\n", + "guuggcgacagcgcugauccuguagcucagagccuacgcagacucucgaagaggcccugagagacupcucggaacuucgguguugguugaggauuuggagaccacupacuaaggagacuucagc\n", + "ggcggaupapagaagagagagapcapucgcaggaggaggaagaggaacaaagaccuaaaagaa\n", + "gaggucuauucugcgagugcucgugaguuuucugucuugaaggacuguccuucapuaacaucaguugccccacguucgguaag\n", + "paggaaaggaaaagaaagagaaagaaaagaagaacaagaaggaaaagaagaaaacccuaaaagagaaapaaaacaaagcagagaaappaggaggcggcggaggaaaapaagaggaaa\n", + "ggauacuauuauagauccuugucaccaucauauuucacccuuagcuuuuuguacucuuucagagg\n", + "cccugcccuccpcugupccgaauccgagcaccuccaccgccgccagcugcggacaacccagcgaggcgcugccucgcgcgcugcugccacgacggagcuacgccgccuucucaaaauc\n", + "cuaaaauuuaccguuuuuccugcacagacccgagaagagcuguauaauauaaaauugcccaaccugucucggaaucccuggcg\n", + "ugucugccuuacgcuuuguuaacauuuccaccucacuuguaaaacacguucacugucucacucacagc\n", + "agapaaugagaaggcucaaguccaggaagucgcuuauugcuuguucaacagaaccuuucccauucucccugauucuguaucuaaggaggacacagauuaguaaaguuggaucuucg\n", + "ggaagcagcaauuccagauaucuccucaagaggccaccauuguccgaaaauucgcuggaccaaaacaaggaagcuucauguguuuuguagcucccuggagcccuggaaaucaucuguugaaagguaac\n", + "acuuugauaaauaaaccccccacacaaucaguuuuacuucuuuuucaacaucacaaaauaaucugcuaagauccuaaguguuccuguuuuagaaguagguugugaaggauuucagaaauccagagau\n", + "gaaguuggccaauguuuuucccaaagguuuauucccuucucgcuugccccacuuccaagccaggaagagaagaaacuggacaucagucugccapaaucgguuguccuggagccauucauugcacu\n", + "pccgaaauggauucgagucuggucaccagcacuaaugugcaaggucuauccuuaguguaccuc\n", + "auuccauauucuccacucucuccacacccaauagaaaacacuauauuaacacacaguuucaaauaacaaaucugccauagaugccgaggucucuguuccuacugacagaaagauuauuucuagaucuu\n", + "pccuaaagagccugcaapaagagaucagccaugguaaacuuuuccaccaccucauacccaaauuug\n", + "gugacccacaggccuacaccuuuaauucuugcaucauucuauuuuccccapagaggagcugauaucaucaaggaagagagacgcaggcugguagcuugugaaacucucagaagcucccuapcuc\n", + "ggccucapacggcaacgccggccgucaccaaccgugcgugugcugcgugacccgcagcccaupcggcguggagauuccuupaguguguuguguggugcaagauggugaagapagccggaa\n", + "ugauugcacggaggaagcugaccaagcugagaagagucuuggcccggaggcccagcaucaca\n", + "aauagcccugagacagaaaagcaaaaaguugaggaauuauaauaaaauuacaaaaaauggugaaaaua\n", + "cugcccgccgcggcuuupagcugacccacugccgucgcggapaugccagagacapcugagc\n", + "gauuucagcapagguucauucucugagucuuccaauuaaggaacaagaaaaauaacacuagcuuuuacaggagcaaaccugccaauuacauauagaccaagaaagccauaggcccaggcucuaacc\n", + "gucucgaapucccapuucggaucagcuugagugcgcgcggccuguggccpcgcuuugguuacag\n", + "aapaagcagguacugaugcuauccauucgauuuacugagcuugupucugacccuaaccaccucccacagacacuuuaauacaaaaguc\n", + "gaauuuuccgguugacuuucagaaguccaaaggaaagcucaaaaaacaaggaaaccuuacgaauaccuugaacaagauauagugcuauucuacuuugcuauauaacuaagucuccagaguuacac\n", + "uugacuuacuucagcuacuauucccugaagccugcaauucaagaaucuuguggauaaaucaauauuuuucuuggagacacauagugaaaccaagagaaaaacuuggc\n", + "aaagugcccgccagcacuaccacagapauucuccuuuuuccgguccgauugucauuuuaaacacuguuuagcagcccagcucugauccau\n", + "gaacaagacagcuuggugcaaguccuucuggauugccucgagaaauccagcuuguuucucuggaa\n", + "ggaucapcuuuuaaaaaaucagcupaggugguugaagcagacaggccugaauugaggaaaccguccugagaagcaauugucauucuuugcgaagucauucucuupaaaauuacug\n", + "cucucauggucaccaagagaagccacuaccaaucuccccacaapacugcuuaccuuccuucgcuuucagcagc\n", + "uuucagaucucugaagagccccuacaacaaguugccauacccapcupccggaaccuucacccguuccaaaaaccuuacaauupcauccuguccagcacugaaagguaccacuuucaccuc\n", + "aggagcagauuugcuuucauauuaaccaaauuacgaaauauaaaaaaccaggagupcacccuaaaauucugcuuagcagapcuuacccaaucuucaagaccuccag\n", + "agauugagacuaggccuccacacaggaauuuggagcaggaaguguuaguugcaccpauccaccucaccacuucauacaguucuugugaaucgcugugcuguucagugccaguaaaucaaguucuag\n", + "gagaggupccucuugccucccggacucaaauccucpauapagcgccpaggccuucggcuccuuuuccaaaaaacaggaaa\n", + "uucccacacucugcccagucucccggagucucuucggccucucpacccgcguggccuuucaaaauccugucaagugacccgaaagcugag\n", + "auccugcaaucacagaauacccacaacucacuuucauuucucaaggacccucuucgaagcuucauaucacucugccccugcapcuucuagcuaccaugauccggaucuccauccaggaaaccauu\n", + "gcauucaucagcgcucacagaggucaaggaaapaaccguaucgcuaaacuccaaucugagauucacauucapaggcucpagagcuuuuccucgcuccuagccccugaguugaagugaac\n", + "guapacucggcucuguggccugugccucupacauuggucccaggapcapccucgaucuccaaaaauugugagagcgugcgugcuggccauaagcguugguacccagcaaau\n", + "gaagcccaaccagupuuuguggaguguggugaucagaagcpuccagauacccagcauccaucgcauuugacagucaccupcuaaaccaaguggaaaagaguguugagagacacuucuag\n", + "ucacuuccacaguupaucagauaaugaguccuagaagaccagccaguaua\n", + "auuggcupccccagguacugcuguucuacacacaagcugguugcugaagcccugagagcuuccggcagagcgcuggcaucgcugcugauuuagugaguuccaaccagugugacuuacacuugaggc\n", + "cacucugaagcacagaacucuuacgucuccacggagccuccuucacauuaggaccaaaaauauccuccugcacuaggaucuggacuucauugucacuugacacccuguuggacccuugaaggaucaug\n", + "uauagguaucucaggagagaacaucacagaaguuuaauuuaacccuucaucacccacagcacaua\n", + "ggcacucacgugaaguuaacgcacaggccaaacauaagacucugaucauaaagaaguccucacacccuucuaagcaaagugaacaagcucaagaauuaccuggcagcauacagucuaaa\n", + "cuacgauapaggaugaggagcagcucuuuacuuucagcugcucguucgcaagugcuugcacgcaacucucugcggaagcccucacccuuaaguguuguugaagagagagcaggccaucgccggccc\n", + "cacacugaauggccuccacaggcggaaggccguccuccaaaguuuugcuaaaaaccagcacacccuccugccaggagcugccpagucaapuugcuucuguggaauuacguucgaaucagacu\n", + "uacaaggcaacagagaguauccaaauauuuuagcagugcucucagaccuuccaccaccaaggucg\n", + "gagacucacaaggaacaagagugagacuuugcugcaacuaauguuuuccauccaccucugcacucgg\n", + "gacacccaaccucugacgcuggauguuagcaaucuagauugagcuuuugcuugauuagcuuuggauaauuuaaugauuaa\n", + "accugaucuccagacagcccuuuacuauaauuuacacuaacacucccugcgcagagcucucaagugaacacuuggcaaaggaaacacaagcagaaaauaccaagcuuagc\n", + "ggagagaauucuauccaggcccgccuucuccuauaaccaggucaaaaauuuaggcagaucugagagcuggccucuugaagaguucaaggaggagacccuaaccugacpugauucuagcgg\n", + "guccpcugagcguucguccugacacucucccgccgguccpcguccagucgcagcguccacggucagc\n", + "ggcugagucaagagagugccgccuguggcpcugupugcugacuuuapagcgucugccuccuugucgcuugagugcucapaacggugagapucaucacpccuc\n", + "guuggacgguagauuucuauucaccagauuguagagauauuaagaagacgguaagc\n", + "ccggagagagagcccggcacacucucccgcagguuccaccgaccgagaaaagaggaggagaagcagcagcaggaagaaaaaccaaacaagaaaaa\n", + "cacuuccccaaguuuggapaaguacugcuccagcaccaauccaagagcuuuaaacccuccuguugcuuaugccagaggcuuaacauucagcaucuagagaugacuaaaguc\n", + "agcuggcggcuucgaggccugagacgcuacgguuacgaucucuaccaacccucuuccpagguggaagagaggcug\n", + "ggccuacaguguguuuccagcuacgcgagcugaggccacuggccggcaggccaagcuugcacgugcgccgucgacgu\n", + "gaaaauuaaaauuuucaaucuuacaacaguauuuuaucaagcaucuucaagcugcauaaccaaauuaucuauacuaauugaucugguaccagugaaaagaaguacgguaagucaaggaaccaacu\n", + "aguaaauuacacguucuggaggaccauugucauuugcaccuugguggaggacucaagcagcugcaggaguggaccaggagaguaucagagacaguccupcugaacugcucucugacaggcuccauu\n", + "auugcccacacacuuggacuacgauggaacgcccaaguggcuuacccgcgacucccacaucugag\n", + "aagcugaaguccuccaaaacaaaggccggcuuuagcugagaagccgacagagugugaggacaccaguacca\n", + "gcagacgucagaggaacagcggccpaggcagcucagcucagcggcagagcgcguggccacucuguccgaguucggaguucapcagcpagapagacggcagaugucauccugugcc\n", + "gugcuuagauucccucagauuguggccucauucuucccucaccuacaggucgcagaacagaaucccug\n", + "uaccaccuccgccuuacacccuagagccuacgaauucgccpacacagauccauggcauucugcuuuaagcaacuaacuuua\n", + "gcccggagagagaacuaagcucagccggacaaagaauccacaccaaacuccccucaagacccacagaaguagcaagapagaaaa\n", + "guccuggaguuaucucagcagguaggugcuccaacuccucucuuaggaaauccuccccugucuguucuccucapagccgcc\n", + "aaaagcaacagacacacacacccacaccgagccgacaccacccgcacccgaagcacacccagauuccaaacccgucgcauccugaaacuccaccggcaaccacagaccagaaggaggaagagagaaaa\n", + "pcugagcucagaaapaagaagugagagcaccapcugcagcucpcucccuggagcugcuggcugcugaauccc\n", + "aagcacagagauuacguucuaagaggaggcguuucagacuccaagcacuacauugapaagauuugcugupaaa\n", + "gacuuacaggcguugguucugagaagcucccguugcgauaucagccuggcucaggaggcuuacgaggacauacuaugapuaaac\n", + "uggccugccggapaaauucuuggaggccacuaguccaacacuugccaauuacacguucuccacacagcgcgucagcguuuaacauucucguuacc\n", + "gacagagcacagaacuccaauaccaacaaggagcccgacccccaaccaaaacacccaaagacgaagaaaaagcaccugaaaaaacaaaaccaacagaagaaacccpaaccuaagcggauggagaaa\n", + "agcggaggaaggaagauaaapacucpaaggaggcagcapaggagaaagaggcggaapaaagagaagccaaccgucgacgucacc\n", + "gucacacaggaauauuuccugaaggauccaaauugagaaaaaguaucccauucuagapuuaaccupcucacucacaggcucaagcugcacuucaaguaaucagagcu\n", + "gcugaaggaagaagaggaaaaagaaggagaagaaaaaaaaaaagaaaaaauaagaaaaaaaacaaaaaggaapaacccaaaaaaagaaaaaaaaagagaapagapaaaauaaagaaggaag\n", + "gguucgcaagcaagccuaucaccuuagcacgagcgcacgcuccugcuccucugagcuucagaacaaag\n", + "guauupucaaagccuccaguucaaacacpaauuaaauuaauauauugaaucaaaaggauuuaucuuacugcauau\n", + "apaacgcuugccaaccacggagcggucupaaugucagapacpaagacgaucguuuguccuuuuaugaccagcacaugagcuguaagaaaacaaguuuguuguguguguuuuguguaggc\n", + "pagacucacaapaacuuagagccgguuccggccaacucggagacgugcucccaacacccagaggagapaagaaaacggacgaggcuggacagaagacaaagaaaccagaggapaagac\n", + "ggucaaugcucaguucupacuugcuucacucuaguuaucucgaagacagugaguuccuuuucacucauuacacuuacgaauucagaaaggugccaaaguaauagcauuuucacu\n", + "gguuuacggagucuugupcgcagaaaauuggaggaagaccuuucugaauucgaguaaaguauuccaaggaucagagcaggcaaacagupauguuuaag\n", + "cuccaccaggccccgcagcacguuguuucaaacagucuccgucugguuuuaaagcccagcacacaacuccuuggugcaugugcpaggccuuuaaaa\n", + "gaaaagauaucauuuaagacacuuacgagauuuagaauggcuagcuugucugcuucagcuapcagaacuuucccuuucaggccucugucaaagaagaacagauuacaccaac\n", + "ugacacucacgaucaaggaaaucacugucggagapaggccaacuaaacagcuaucauuucagcupaguccaguggaggacaggagccccugaagacuccguggaaggaaacacgugupcgcu\n", + "acaccaucccaaguaggacauccuggcaccauuuuccagguggagacauucucaugucuaguccuaaaguaagucaggaaaag\n", + "gacacaugacagcugcagugagccuguauuuacauaacuuggauucauauuccauaaaacucuccauucaagcauucaaaaaa\n", + "aagaaacaaaaauaagaaaagaaaaagcaagaggcacuaaaaaacaggaccacaaagaccaaagcaacccucaggaapaaaagaaaaaaaaagaaagagaaaacaaaacagaggaggauggaaaaa\n", + "aguugaauaaaggaauugaacacagugcapccaaaaauaaccaacuaggaaagaacuccucccagccccuaaacccgaaaacccuaauagacugugucagugagaagauaccagcaucuggacug\n", + "ggcggcgucggcgcccuagaccucccccgugccgugagaugagccgagcgccucagagagacgacgcgupccuggcgcuuucpccugagcuucgcugagaggcggccgcgaccgcggaag\n", + "guaccaaggaauuuccagccagcgcaaacaauaaagaccccauacucugguuapaagccc\n", + "aauuaagagaaaaagaaacacaagaaaaaaaacagagaacucupaaccaauagaaaacuccaaacacaaccacacccccaaapaagaagaaguagaggagagagaggcagaggcgcccggagcc\n", + "ggaggaaaaagcgccucgcgcggagcgcggacagcacaggccgaccggagaggucugugccugac\n", + "guucacaaauuucuccaggaagauuuuccacuugcucacuugaucuuuuggacuggaaaagaggagacgauuagcagcacacaaagcauuaapugcacagaaaauuaacucacuuugaaguuacag\n", + "guggcgacgaaaacugcagccupccuucccauuaccucupcagcpagagaguugcuuaccapccugauaguuugaguucucaaucuuagacuagguguuuguuugugauc\n", + "agucgcuuaauugucugacugcgagccacaaaaaacaauuuggugaaggugaagapaaacagcaaaggccc\n", + "cugaagagagccucagucacuugccgccuaucgagaapuuupuuuuguugccacgcugaucucaagagucuaaaaa\n", + "agcagaacuguaucccuccagaucupauugccuuagaaaacuccauccugcugagagguuaaacgguccucguuguguccapccuuaccuucugcagccugaguggaggcucugccguucacuu\n", + "paaaaaccacpuuuacugcggagauccaguugcaugccccaguaccuaacgcuugacccugccuuccuugguaggcacucagcaucagauccagaaccccuuacuugcaagaau\n", + "ggaugagauucuacaucaacuugguccuuuucccuuccuugucccuaggagcuacgguucugaac\n", + "gcauuuguagcaucguuauauauuuguauauuuucaaagaacagcaucaagucugugaagaauaagcaaaaauacaaaauaacaaaaccucu\n", + "uuuccuuuagagacaucgcauuaacccucagauucugcagaacaccgaaaggcugcugaaagguacauucacauucacagcaccggagguucacugaacugucucugugcupuccauccagcu\n", + "agagguccapagaaggagcagcggcggagacaguccgagagaaggaggaggagacagaacuacgcgaaaagaaagaaaagaacpcggagcpagagaacagacacugcgcguuuucucggaga\n", + "uguaauaucuauuuucccuuauacugaaagucuuugaaucaaaaaaaaacaacagcuuuuuuacuucacuuaaguuggccaaaaaaauaaaaaucaaucuagugaugaaaaaaaca\n", + "agagacacauuuauauucuggauuacggcauggaauucucuguuuauuuccauauuauuggaauuaaauccagc\n", + "agaagguuaccauuuaccccggcaacauagucucacuuggcccccuccacggcaugugcucgaaaccacuaggaggugaagaucuauacgcagaagaaaaacaucuccucuuuaaacgcpauagac\n", + "aagaacaaaacaaagacccuaggaagcacccgccacagcuaacccagaaagcpagagcgacagcggcacaggaggcggacapacupcgaagcgguaaagaggccucaccupagcpccc\n", + "gucucacacccucccaggaacagcaggaagaacaagaaaaagaaacccuagagaaacaagcaccuccgapaagagaaaaaaaagaaaagaaaaacagaggaggcacaacgccccgcggaccpaa\n", + "ggaagacauacuauuugaacuauucccaaaaagccaguucugcacuagcuggccagguuucacuccugauguuaaag\n", + "gcgcgagacgcacucggcpcgcpcucucagaaggcgagagacgcguccacgccaccaacucucaaaggaggaggaggcccagccpcacggugcpuuugcupcupuacauaaaaaac\n", + "ggaagugucccuccagagcacuuagcagcagguggcuugcacaaguauauaaacugccacacgcucaagaaggccagcguuuguguguugccaugaccuccucugaagccggcucaguggagcaaccc\n", + "ucacaucucapauuucagaguaaauugccucuucccuuagcuccagugcaccuaucaagaauccacaggcugcag\n", + "gaaauccuuauacagucaucauugcagacuuaauugccauucauagaaccugaucugguguaaaaaguuaaaaauuuguaaaaaccggc\n", + "caguccacagcgcagacuuacgauugaagagagugcgcgaacuuccaggugcaagccucucucccucuaaccucaggaugugugcagaugcucupaggcucccgcccucugacccugagugcaggc\n", + "agcauccugcagaaagcuuacuccuccaccuuacucacguacuuggagacaugguccucccugcc\n", + "gaguccacaucucucacggcuuccaggaacccacugcaagaaaaccgaauauuugagacagaaug\n", + "gagaauuauaucuuaguuuccucggaagaaugcaaaaaucaagagcaacggauaugaaaagagcacccacugag\n", + "uucucggcuugaauuacagguccccacaaacaucggagcuccgguuguuuccaaaaaacaug\n", + "auaaguauaacuuuaauuaaauuuuacagaauaacaucuuguugcuuuuagagagagacauagaaaaaaaaagaaacugaacaggaaaacagagaauauuugcccaguaucuuaga\n", + "gauaagcugaagcuguuaacgcagacaaagcagaucccugcuaagauaaagccaaaacauugcacagaagacccucaaucuuaagc\n", + "aaguagaagaacacapaaguucccacuugcucaaggucaacgaccccucccugucuggaaccuacuaccaggcaacapccccuuuccucucagcucuuucccugccacuuccg\n", + "ggagaacacacaaacucuacuccuguaccaggaaagaaaucaaucuuaucaaaaaaucugcgcaguuuaaaaaaaagucccuauagugccaacugguuuauugccugucuuuguagcgcaacaaa\n", + "gguuccucugauugaaaaccaccagcuuugguggucugguauuuggccacucguggucuuaaagaauuuaagagcgcuguaagccgg\n", + "guggagacccucaccuguggauucauauuaccugcugcggcacupacaggcuaaaucgauuag\n", + "gagcugccaagugaguaagcuguuaccugaccugguugcuugcagaaaccccagcccugcaacgcagacaaaaaaau\n", + "gcggcpagcgguucacugcgcacgcgcucuguuccagccgcguggupagcuuacacucggucugguucaaggugccaaacucpaaaaca\n", + "gauuacauauugcgcagacaggaggagaagaaaacpacacggucaaggaacugcggaggcgaagccggagcugucagcuguccgcuuacuguuggcacuuccuacccaaaagcacagauugaaucu\n", + "ggagucuaguaacaaacuaaacauuuugaccucauagauauuaacaauaucaguuuuuuccucagaaagauauaaacguuuuguugaaauuucauauugucgaaucauuguucuacucugcuagacuc\n", + "gaggcgacaagaaaaggcaaagcaacacuaagcaagaaggaaaagaagcugcagucguaaucauagccagaagaaacauccagaaa\n", + "cucgcacaucccggcacacuacugugaggacagaguccuggaguuggcguuuugucacccuaucgaauucccuguaa\n", + "ggccccgcgaaucagagcgccagcaggaggaaacagucauuggcagcaacccaccaaugccgagcgagcggaaggagaccapagcagaggacacagcgccggcgccgcgccagaggcuccuacca\n", + "ggaugaugaccagccaguuggacacucggcucacuupacaagcugccacucuccccacuaucuccaccagcucccugcuugccaaacupucagupuaucuguggcaag\n", + "cgugguuucccggcucccgucagcagucggcagccpaggacuuccuuucagauccacucccucugcagugaguugacagcucggaagcuupagagugagaguagcccggagcuggugcugcuc\n", + "cccggcaaagagccaccaccacccaaacccaccaaaaucacaaaagaagcaagcaccagcaccaaaccuuagagaggaaaaaacccagaagcapaagagagcagagcpaaccaaggagagaaa\n", + "agcgcgccgucgugcgcaccgcacagucaaaaacuuuuuuuccuaagupcuggcggucgcpucag\n", + "ggaguaaauucauaucagauucaccauuucauaauuacccugcuguuaaguuaagugaaaaucaaaaacuucugguaacacggaauaugaaacaguguauuggauucagugugccuuucacagaacau\n", + "gaggacccugagagagcaggagccgccagaagcacaagaagaggaaggacapaagaaacagaggaggaagaaaaccuaagcaaagcccagaagccagaacacgaaaacaccagacaucagaggcag\n", + "aaaggaggaaaagagaaaggaacaaaacaagaagaggaggaaaaaaaaagaaaaagagaagaaaaaaccggagaaapagaaaauaagaaaaggaaaggaaaaaaagapaaggagaggaagcaac\n", + "ggucgagacauuucuuugaucacaacccaccuauaaaccuaacccacaacacacauacacuuga\n", + "guacauugcuguccccaggcacuaccaugccugupacgccaaucauugaacuucuccuccuccucccugcaaaccacacucagagcuccuauuucagau\n", + "gccaccagaccaggagucacuaccgaggucccugaggapagaaggaaaagapcggcgcgagaggaggagcaaapagaapaaag\n", + "acgagcagagaaagagccaccggagaaggcagagaaccgapccgagcaggaccpaaacaaggaggcaaucgagaaaccggaacuuuuucc\n", + "guuuacacgagapucacaauuauucccupaaaagaauugagaccucacagaccggcacaacaucuaaaacuuagc\n", + "gaguuuuucaccaggacacaaucuaccaacgaguagcaagagauucccauuuugucgguggagagucucaccccaccgaguucccagaauuugcaguuccacauccuaaagupuugguucucuuag\n", + "gaauaucuccuaagucugaaauauaaccggcuucagaacuuuuguaacauuguaacagaauaaauaaauaaauaaacauuaacggaguaacauucccagacaacggaaaguaacugcacuucaacgcu\n", + "aaaagaaacacgcacagcagagcgcaaggagcagaagagcgacgcggauacpacaggcggccgcacpaagagcaaaggaaagaggagaapaggaggcaacaaaagaagacguaagaaaaaac\n", + "guauaaccgaggcugcucgcuguccagucgaaguuugcuggagacgcugugapcccgcggucpaagagagcucuaacuccggaaacucgcuggaagaacuuugcuguguccgucaccaugaca\n", + "ggagcuaacucccgguugccuuuacuuccucacucugaggucaguaagaguugucuggcacgcgcu\n", + "ggcuuuaaaaucuuccugccccucugagagcugcgcagagcuaggaucacaguaggcaucaucucpaaaggauagacugcapaaaagugguguuuugguagcuacapagcapuuuacag\n", + "ggcuacaccugacaucacaccaaaaaacuuaccucuacaggcuuucucacuacgaagugaggacgacucuaacugucuggagaagacucgcugaacccapaapaaaguggaaauucucaag\n", + "pacaggaauacacugcuccapucugugaagagccguauaucagaagapaaucuacaaaaacccccggcggauuggugugagguucaacguucucuccaacuuuccggaaauugagugcacc\n", + "gacacauccugaagauuaacaauaaaaacgagugccuugagagaauugacacccacaacccauugacuacaacuucaaagauuuuacagucaagcacaauuucuugcugcagaucucauauaagg\n", + "gagcuaucaaauccagcaagcagaagcuaaagaagcuuacuuaucaccucccucacuuucacuuacag\n", + "ugaggcuuugcagagagucacauugccuggaagacaaacacaaacugaaucuaagagguaaaaaa\n", + "cccggauucgcuugaccgcaggccgcagcucpagugagugaaacuggugaacagaaucaaguaucaggagagagagupaugcugapcuuuaaggauugcucuccagapcagguuugaac\n", + "auaucugcupcccggagaggccugcugaaauucuccugcauuuggcgaaguccccacugcacacugagaaaaggcaugcaaaacuuacaugucugg\n", + "ggauuaacacuuccuuccaagaaaugacugcauacugccccucagcagagccuccgcuucuagccaggcagcugaagagcauccaggccuucaccaggacucacagccacagucac\n", + "uagugacguucucaaugcgagagcgcuuacggucucugacccucaggaucccgcacacuucggagaagccacuugag\n", + "guaucugaaaagacagcupcuucagccugaggucuaagaauuaaagagcugauaacuccupacuacgaggaccaaaucuccugaaggaaucuuuggcaagcaggaaccccugaggaauucuau\n", + "guauuuaccucauacacacagcaaaaaaaaaacaaucagaacuggcauacgaaucaacauuaaugucagcagcccccucaaucaucaaguacuccapcaaacgaaagcacu\n", + "uucuuccgccaaccccuuugacccuuuucccuacaggaggaagccaggaccucuggaaagguuuggacaggaaagaaccugccupucgacuccacugacagcauc\n", + "pucccucgccaccgccguuggaaccucaguccugaaggccpcuacccgccaccggcuccucuaguagaguucag\n", + "ggacggugagccaagcggacgacggugaacaaucacgcaguucauagccggacaaccugcuccag\n", + "cpcuggucacgcuucpccucuccguguggaaaccaccccgcagccgcupcuucgguccaggagucugcpcucggcacgaaaccagguugguaaaucuuucucagguggaggaaaag\n", + "gugagauuguccagcuucaaagccuugaagaccaggcagacuccuuccuguacuccacucaaacuccaaggcuucaguguuucucuggugaagaa\n", + "gugcugauaaacaggaacuuguccuugucaacaucgccgucuucgcccaaggaucaucauccucaacgcggagaaagacgguaggugcucacgaccgaucucguaag\n", + "uccgccauaccuuaauccucagcagagcuccpaaguguccuguuugcaguaggcaggucgugcuagaguagaagaagacaaaggaapacuaccacacagaacuguggccgccagaccagcu\n", + "guuuacaaauaaaacauucaauaaucacuaucuggaacuuucagccuauuaaccacauaguagaaauuaaagauuuaccuuccagcauuuucaccuaaaucuaagccacagauacauucauaaacaac\n", + "agugagugaaagaaaauaaaaaauuuuaccgcagcuuugccagcaauaacauucucagcucuccacugcucgcapaauuucacuuguacugugaggaacacugcuuugguccagucuuuggccagu\n", + "ggaccuggcaguccccgcuacupcccgcaggcagaccpacccacuuccupcugccuguguggcuuggaapaacacgagaggccugaguccaucccgcagcugauggagccu\n", + "gcaggaggaaaaaaaaagaaaaaaaaaagacgaaaaaccaagaaaaacagaggauaaagaggaaaaggaaaaaucauaggaggaagaaggaaaaagagagaaaggcacuagaaaaggapagaggcc\n", + "gaaaaacagccuccugacuuuagcauucuugcugagauuugcapcacaagugcuuguggucucgugagccccaagaug\n", + "gaaucaucucgguucauaaaaaaaaacuucaagcuuuuagagcaauccugcacuuucagacacuaacgaauuacaga\n", + "acaaagaucuuaaauuuuacaaauugcagugugguugaacaaaaauaaaaauaggagauaagcuauugcaguguacagcaaucaau\n", + "gaguccaggcacaagaacugcuuacgcagaaguuacagacuuaccaagauugcgagagaccaggcacc\n", + "guggcacuuuccgagcuccuaagcuggagaaagucaapauuuacugaaggacccaagcagcuuaagaggaacccacggacccguguucacuuccuuaaccuaaaaggcaag\n", + "gagaagcaaagcucugcguaggcaagcguuugguaucugccuccgguagcucagacaggccuucucacgcucagccuuacauuaccuucgag\n", + "agaagccaccagcuugguguaagaaagcaapacuacugagugguuucaguuauaaaa\n", + "ggaccaagucgacgugcuguuccaacccuagcuucaggcccuuuacaauccgguccugagaucgugagaaguuguuupuaccuugaucaguguguuagugguguauuacugccggugcaaccgcaa\n", + "caaguaaaagagagaagauccccagcaauuaccagcacagacaucuaaucacaagcauuaauagccagcucugcagauaaagcuugagaaggagaauuacaggaaau\n", + "gcugcauuugacccaugaaagcacacuggcccapagguuguuguccucacuupcagccaggc\n", + "pagagaaapacgagcugccggcgcggccacaaagaggacaagcgcucccggcgccaucccupa\n", + "ggaguucaucuugcuuauuccuuauuccagaugcuguaucagaguauucucccacccuugcgugacauuupcapagaaccaggacacaucuuaccaucuugguuguaaccugaaguuagaa\n", + "gcggugcucuugaaggcugcgugagcccccucuucagacuapcaacgaacucuuaacccpaccuugacag\n", + "ccuugaagaucuuccaaacuagcuguaagacauuucaagucagcaguagcuuuauaggauucggccaauccacaggauucuguguucuuuacagcauuaacacauccacgaaa\n", + "guaucauuugcugcacaacucggaucaaguguuagapcauuaagucucugacagagagguacaaggacuccagaaagacagguaagcagagacaccucuggaucagcugugguuaaagcugcacag\n", + "gagauuaucucaaaaagaucccugcugcggcuggaguuucagaaaucagaacacuguuucucaagccaggucuucgcaaacaaaagcugauuaau\n", + "apcaaccgagacucgcuuucgcguuuucgcuacccugcucaucugccugccuggcuaggcuucacucugcapccaucaaucugcag\n", + "auuacuggccuucucuaacccgguuuaaggcugagugaaggaaucagcuupacugcgauuugaauagugagcuccccaauc\n", + "ccugcucccpcucagcaccuaagcugcaguaacugguguggaggcagcauaucaaaaaauacucaggcgaag\n", + "gaaaauucpauucaauuaaaaaaacagcaggaaauuacuucaucaacaaaaacugaacaguauuuucuucuagaaacauauuaacuuauaaauuguacuacuaau\n", + "gacuuuuuagaaggcaagcaacagcgucaccugcaguaagaauauaccuucugaguuaccccuggagccccaauuuggagagauuucaacagaaguauaggcacaggugccugcaagagaacaccaau\n", + "gccgaacacccaacacgcaucccgapcgcaggcaucgucgccucgaguggacucucaaaacuuguc\n", + "ggucucaaacuacguugccgauagagacccugcgcauuccaaggccccacacuccaacccaggcucucucggcagcuggcacccacuccgucucgaagguugugaggcugaggagccgcpagagag\n", + "agaccuccaucacgaguaccccugacgcgcuucaggauuuugaccccaacgcucgcucggccaggcuucugcugccauucccpucuugccuguucccaaagg\n", + "gacaaaaaagccgcguugcugcgagaaauucacaaucuggaucacagcuucucucuaccugaagagcc\n", + "caggcagccuccucucugagaauuuccagcgccagcupagcugcuucug\n", + "acgugugguucccguuuauuggaagauaccccauuggcugaaauuugacuaaaauuaaguuuuauuuucgaggagguugauacacugag\n", + "aggugugcucagucuuaacauuucaacacgapaaucacugcaaaccagucuugaauggauacucagaccaggauucagacugccpugugaaagu\n", + "gaaauuggagaggcccaguaaauucaucaauauucaguggcccuuggagugucuaucaaggaucaaauucacaaucucuupaaucccgaacaucugagauuggaaug\n", + "uggcugagugcuugaauaucaaccuggacaagguauaucaagcccugcucaaccacuaccaaccagcuggauuaaaagugcuaauggcuggucuagaaggccaagauuuuaaagau\n", + "cggagaagaaggcagauacgcaguagcagccauuagagagapaggaaaaaagaaaagaggacgcgcgapaggaggaagagapagcpccupcaagaacgccgapcapagaaa\n", + "ggagaaggcgcuucguucuuccggcgugugaccagacguugcpcuucgugaggacccgcucguguuuccacgugaugcaaggaaaaaacuucaaaaccucgacuuugcpuacaggcguacucc\n", + "gcaaagagaaaagagaggccagaggaaccgccgagucgagcgccccaguccauccccuggaaaucacg\n", + "aauuuggcggauaucaaaaggcaacuagaagaaagaaaaacuucauccuaauauuaaaucauaug\n", + "gaggugccpuagcuggcucgagcapaacccggcuugcaccagucugcgcggcucagcucccgguagcc\n", + "gcugcgaagagccccagcuacccuuuccugcccpaacagagcuugcuucgaguccagcucagccgcuccguccuccaaccaucuguucgccucuucaaccuccgcgcuuucaagcaacaaca\n", + "agaugagucgcugcugccuugcguguuucaagauuucuaagcccaggcgagcaaaguuaaaacuacuaucuucucauaaaaccucugccagagaaauaaaacuagaagcaacu\n", + "uacagaucauuggcuggaaucauauuuuugagaggacaccaaaagcucuuguauacauuuaguccaaacaaguccuuggaagaaucugcauaucaaaaaua\n", + "gaagaccuguapcauuucaaaaggucccagauggacuucgauauuauaaaauucaucucucccagcucagaagaaggcacagcaucuaau\n", + "ggagucacacucggccaagcugcgucugcuccacucaaguuaaaguucuuacugagaaaaacaccggugcuguuuggauaaaggcuaaaggucugacuaaucugucagcaagucugguugauagcaac\n", + "aguggcaaggucaguuccauaacuucccugacucapagcugaggaggccapacuugugguucaguuugugagauuguggauuauuaucuacucpcgcc\n", + "gccggccaauauauagugaacccpaagucacccacaacpcuggugacaguuagagaag\n", + "ggagcaggacauucuaucagaaaaagcauuucuuggacacucaaggugguccucaccaggucacu\n", + "aauuaccaagagugaauucuucuacaaugauaauuuguaucuacagaaaaacuccaauuaccagc\n", + "gaagcauaacgccuuuugcugaagaaagacuaccuauuacccagcacgcuuagcagugacauugucaccapagagaccgaccaccuugagugcucacugacccagcaggagccacucaccuacauc\n", + "aggcugcucgccuugugcucggcggcggcpuggccgaaguuggcugcgugauggccaggacaggcpacuagaggaaaagupcauc\n", + "gugaccucagaggcguugcucupagcuuugaggaggaauucccguggagcagapcugacg\n", + "aucagcucccugcaucaccagagagcuacuaacgaagcauaaaaacagaauucugacauacuccugugaucagcugcagauaggugaaucuaacgcugacc\n", + "pcugcgcagcgccpcggaggcugcugccacggcggcagcugcgccucccggaacpaagcugcgcugccucugccugucccugguguuuccuauaacaucucucuccaacucuggag\n", + "ggacaggaccgacucacaacgaccaacaccucagaacucccggcggagapaaagauaaagacaguccaaaacccccugucuugcacuguuagcacuuucuugaaaaccuuuaaaauagcc\n", + "uuccgaguuuuagaaggugcaguguucgcucucagucucucacccugcucccpauuucaccugcgcuuuccgcaagucgugcccacagcacugacagaa\n", + "cugugacuacuggcaauauggccuugagaacacauagaaaucucuuagucguuuacagacugcugcaccaggag\n", + "gaaagcaggapacacpaccaagccccagcgaaccuucaggccccuaguaccaggaguucacuaapauccaccuuuuauaaccaugcac\n", + "guagcuaccaauuuacacuggcagcauuccaaaaacaggccucuaauuuaagacagcuccugcuacccagaggugcugaagaggacgccagccucuucacgaggaagcuccauacuccagupccug\n", + "pcugaucaaaacuguugcaacggccuuuauagcaagaagauccauagagcupauuuauuuagcaucaaa\n", + "gaaacapcuggacugacaguccccagcucuccgcccccgucccuacgcagucccuccccugccucuucccuccguggcaccauuuucucuggaagccgccgcccacgcccgcgucagcucuccacc\n", + "auapauaaggaucauccagauuccccagcucuacaacaucccggucggagcuauccagaccug\n", + "agagcagcggagcuaggagagaaaaaaaagagcagaccagcccgaaccccucagaccgaaccccaaaccagcacaccccaaacccuuccaaacccaaagagaacauaggaagaagagcaggccuaaca\n", + "gugaucucaggagaaaucugaccgucccucccugaaccuacaugacgccuuug\n", + "auuuuaaaccaagacauacagaguaaaacucaauuucaagauuuuaaagagaaaagccaaaaacugccuuucaauuuagaacggugaacagcacugaaguaagauaa\n", + "gccgcagucgcaucccapcgacacagauacacucgaacugagcaggaaggagacgcgcgacuggagaggagaggcggcggcggucgcupcugguggaguugugacccgapcccuaagaaac\n", + "auuuggucugcagauaacaacuaacaaggagagaucuuuagcacugcuuuaaaaauaccaacuccccugcugagccugaccauauaucaaaa\n", + "uucacugagagaguccucacugcuggaucuuccacccuccagaaggagcgccucacguccgugagccacacaag\n", + "gcugccagcgcugcugccagcggcgagucpcggagccccuaccuugaaggcpaggcaggagagagg\n", + "ggagaagcggcpcucagcggcggcgcggcaccagccaggaggcpuagcuucuuupcuccgccauccagguccugcaaauccggcagucuccagcuuaaaaaug\n", + "cugucuaccgaacucugccaggccuacugcuccagaaacaccuggaaccaagucaggaaaaccacucccuguguuuuggagagagccagacuaggacaggaaguuagacgaagcaugaauccaaag\n", + "caaguccaggaagcacaccagaaaaaapaccaaagcauccacaacuuaggcuuuguugcuucuccupaggagauuaaacugaacauaaaguccuguuuauaucaagacccapagcauca\n", + "ggacauucacaggcagcapaauaauacucgguupaaauaccpaggccucugagcaccucaggcuccacagcugccaccucuugaagagcuaacpaguggagaggucucuucapaccg\n", + "cuaagguuuaaauuccaaacacuuucaggcagacauucgaggcuauaauaucucuccagucuggauccapacgguucuugugugugacapaaggagguugaaucuuggaaaagccucaggacuc\n", + "guuuaauaaaauaauagcaagaccacaguguuacuuacccaccuucuccacgcuugccaucuugcuccuugcacuucccacaacuccacagcaacauccuuccaguuucucaaguuuuaggaggagcc\n", + "ucuuuuaccaagugucucaagcuguacggagaaagcuggacgucuuugau\n", + "guuaaugcugagcacaaaagucacuaagaagccagaucaacgucaucugccuccaauaucauug\n", + "uaggcgccugguguuccgcapaacugugauuuccgaguuccacauugucugcguguugcucuaggugcaaucucapccccgcugcgcguucgcgcucgcuccaagacuggcuguagcagcu\n", + "caagugcuaaagaaucucaaccacaggcccaaaccacagcuauaaaaaucuauagugucaagcacucucuuuugugccuaaacacapaugauucugcuguggucugaggccuuuuuugaggcaaga\n", + "guuaguauaccauauuccccagaggugccagugccaaaaaaaacccccaagugaacuguggagaagacugcagaaacugcugcuguuuucguaugaaaggacaguuaaucacaauaacagaagcaacu\n", + "gucuuaaaauuauaaaauaauuagguggcuauugcucagacaaaagugcaaguuucaggucaguaauucaucccaacupcagauaccugucaaaaucaaaguaggcaaggaacccgguaaguaaug\n", + "ggaaccuggugaauuaaaagagaagaacuucaguuggaaucuaucaggccagauauccaguuagcagcuauuaaggcauuucugaaagauaagcuaaaaaaucuuuaauuaaaaaaaugcuc\n", + "aaaaaaaaaaaaacacaaagaaaaaaaaaaacccaaaaagaagacaaaaaagaaggaagaagaaacagaaaaaaggaagagagagagaagaapaggaagaagagapagaggaagapaaaa\n", + "aaaggcacacaaauaaaauuaagaagaagaaaaaagaaggaggaaaagagaaaaaggaagagaagaggaggaaagagaagaaagaagaggagaaagapccauapaapaaapaaggaag\n", + "ggaguuccagagugucgauuccuaaggaagaggugaaaaccacccagcgagacauugucuapuguguuuuupaaacagccccupugaguaguuggauuaguagagugaauccggaaaccag\n", + "gucuauuuuugapaguuagauuugccauuaucacacacagacuucucaauuacaaaggcugccaauuacuuuuggag\n", + "ggaaucagauuucauuuggapcacgcugcuaaauugaccuucagacucacuugcaapcagccaaaggaaccagaucauauuggaggaaggacugccguaaucupcagcaaagcucaaaa\n", + "caaagcucuguguccaacaacauagucguuuucgugaaauaaaaaaacuugucuccupagguuuggupagupagcgagcgcagcaapaggcuguguugguggcupugaguuggagcuc\n", + "ccgaaaaaccucacgcgccgcggccagaagcaaaacagcgapcgaguguuccaauccuaggcugcacugagaccaag\n", + "gaauccaacgagcucacgaaggagccgccccpacggaagaagaucgccpucugucgcugugagguggaaagucgucuccacauuguggcaagagugguugaggagcgaccugcguuucuugca\n", + "ccagaucuccacuuuuuucagcaggaagacgcugucugagcgaagugagcgaaaaucccugugaaggaguuuggugugugcgcucacucguguucagaagccuuaaaaucaug\n", + "cagacucaaggaucauguacuuuapagugcuuapuuucacaauccaaaccuaucaaugaucuggcaaaucaaccuaaauagagucacacaaauauacagacaaguuuggcag\n", + "guucuuuuuacagccacagcugaacaucuugcaagcagagapcuccacacauacacacuggacaucaaacauauccaggaa\n", + "ccaaaacaccagcgccaacaacaccaucagaaccaacaccaaagacaacccagaggaggaagagcaguaaagagaggaggaaccugaaaaaaggcaggaagaggagaagagaaaaagagagaggaaaa\n", + "pacuccpagaggaggagcugcgcccacagcggccggcpccgcaagaaccgcaaaccccacuaaggacgagccac\n", + "gaaagagaagaaaggagcggapagapagucaguppcapagcggcagacccuaaaggagaagg\n", + "gacucaaacggapauuuucagucgugacggaagaaapaggcagcucaguugccacgaggcuugacuugcucuacacacuguucauuucacuauaguugcacgcugaaggaauuuccacuuccc\n", + "aaaaaaagaagaaaccaacaagagagaagcaaccugacaaaaggaggaagaagagaauccacuagccgaccaaaccagaaggaagagaagapagaaagccagucggagcggcggagagagcggacc\n", + "paagccucuaaaucpcucugcccuuapagcuapcaccugugucgaccguguuaccuuuuucaaaauucugcaggcuugaagaaucuugcaaaaaau\n", + "gcuauaccacucguuaaaugauaaaaaauccuacucacacacuagcagcucccaaauaucaagcu\n", + "gcaggacugaucuuacaccauuggagagcggaguaggagguuacuuaaaaaaaauuuaggcu\n", + "gaggcuggcuggccucuaacugaggaggagcpaacgugagcccagcpcaggcaggaccuuucccpauuccuucagucguuuccuaggccuccucuggacuaaggucgcuucgugacugaca\n", + "agaaaccaagcgcaagcacagcccucugugcugcacacccccggccgcuacagaggcapcgccccaaucaag\n", + "gcuuucaucuagcuuuaacagccccuucaccuaagcuucuccuaaugguuccaauaaauuaccag\n", + "agucucagaagapaacuuucuguaggcuccaggcpucaccauaagccaagacuuuacaag\n", + "gcuucccaccuguuucaaucuaguucccuaccaucacgugcugapuguugcggagugaag\n", + "gaaaagcucucagcapcugcugaaccaauccaggcucpuccuggagagccgcuccgcgcgucugcag\n", + "aaauuaaucauagapaucuguguccacaagaauucacugaacacccagagcccauucaaaaucucauuauuaaagugcagcgagaaaaagcccagauuuaguggaaucagaucuccuguugaagau\n", + "pacauaagccagagauccacuuagcagcccaagaaaguucuaaauccggcaccuacugucaca\n", + "gaggaaggaccggagccgaguucaauuggaaaauuuaaaagccuugaauuagaaaaccuuuuucucuagca\n", + "acaagcaucccagcuuguuaggaaagccugcuacugacagaaaaaagagcaagaguauuucagcaacuuagagaaguugacuacauugagacaga\n", + "gugaguaaggacacugauaucaagaauagacuaaauugaacacuuguccccaaaauucaccucagauuuuuguaugagacaacuucaucuaaaag\n", + "aaauccaggcagcuuuugugcacugcacagaaacacaaguucucucacuguccauuuuccagagacucugaagcggagucagcuaucaaguacaa\n", + "ggccacaagagcagcuaaaaaugacagguccagauuguaucgauuccccucuaagaaugagaacaagauacaga\n", + "gcuuaggcgcugccuuggaccagcuucuuacggugugcuccgcgugccucccauuccccgagucccguucgacucgagcuuagccgcaccuggcgaaccaggaguggcugagccggcccugcggagcc\n", + "auuaaaaagaggucauuucuaaggagcuauauaaaaaguuucugaaguaauugucucaagaggcugaa\n", + "auauauaaguccuugacccgaacucuuacagcacccpagucucuugacacaggagcagcugcagcucucaaacaagag\n", + "aaagcacuguggagucugugaagcagauacugacuggagacaacacugauauuugcaccacuuccgaguguccupcaaggaaggaggagacguccuuggugucuacggugacuggacugucaucuu\n", + "ggauucacaggaggaggccaggccgcgacpuccucacacgagaaggcagaggcgccgcpcaacaguauca\n", + "aguggaagcacccggaucccuacgcaucacccaagauucacaagcuacacaccaagcuccupcucagaaaa\n", + "uucggaagaggagccaccacgauaagagcccagcucccgcuuucaggcaacccucugguucaaggaaacagaaagacagcauggagucapagagcccacaaguuugcauacuccugugaggaaaau\n", + "gaggucccgaagaccccaccauacccaaguuucggcupcuuucucggcuugugccagacauucccuaaggucuaaaaacucaggccgccugaggaccuacggagaccagauaggccacag\n", + "pagaggccccagaggaugcaggcgagaagcucuuuaaaacuuuuuucccpagacgacagcu\n", + "gccgacugucugccugcaacccaggcaacaguuggugaaggacaucagacggagaccuggcaccaacc\n", + "guugaggaucaucucgcpcuguuccgagcgccugucaccagcuucucacccccauugccuguu\n", + "gaauucaaaacaaaaagguuuuucucugaaaacuccaggcagaucccgcugaaauugugaauuuugcuccucagcuccgccuuuuuaacccugugaagagaguauauuauauuggaccugaagccaug\n", + "gcugcuggcgguucacugaccgcucagccgccaccgucacggccucggccucuuucccucgccccgcgaccuca\n", + "gaaggauaccagacauccaauccucaaaccaaccccgcacacucaccgagacgcauccccgccacccaggcccgcaggaaacggcaaagcggacpaccupagcgapcagaggaggcggcaac\n", + "ggucacgaaccacagugccugcacugaaagagauccugagaucggagagauugguuauccag\n", + "guucacagcgccaagacccacacucacaggauccgaaaaaucacugaggcagcagccagagccagccgagcggucggagaagcagcggaggcpcacguagaggagcugcgcgacgccgucucgacc\n", + "guugcaauacuguuccgagcaggccaauuagccaaauaaagauacgaaguaaaguaacaaaauaaaaagaa\n", + "ugauauuccaaguuguaucauucaaaacucagaaacuucacucaacuagaaaauucuauuauucaaaauupaccaaggagaauaacuaggaguaucggaggaggaaaaaaucacacagcccuacag\n", + "uguguguccaauacugcagucgcaccuuggcgcggaagapcugcacccgcguccgagccacucuugac\n", + "uguuagacugcagaaagaggcuucccagaagaacugaaaapauuucaacuuacccagcuugacugucccuuauuguugaacaaaaguaaaacgcaauaucuacuacaucuuguuuauuuuuguggc\n", + "gagagugcaguuauacugccaugucgcuuucccaccagacacaacagcupaguggucaauaucaguaucccagcc\n", + "ggucagagacuuggcugaacuuccugcagaucuguugcaauagaaaggacaccagguccuuaauu\n", + "uggcagguacucgucuuuuucccucucacagcugcccaguucacaucccuccucgcuuucucccpucagcagacg\n", + "agaagaaaaggagaaaaaauauauccuaucuaagaauuuugcucuuacauacuguagaucuagaaaauucggucggcacacaaaaauaa\n", + "paagagaggaaaaggaaaaggagaaaggaaaacagaacccagacccgccgccccaccccucccauccaaacccccagacaccaacacugacaggagacauapacaggaagapaaaggaaa\n", + "gccgcgcaaccgguuucgcgaugcccgcaggucuuucccagcuccccuacauccccgcgucugccucg\n", + "guacacaaaggaagaaggauuuagcuucuauaaagcaaaaaucugagcpagaaucaauauccagcucugaaaaugagagcu\n", + "aggaguggagagaaucuaucucugaggaccccacuuuccaacagucgcgcuuuccucgcgcguccgccugccacgucccugauuuucacpaggaccagcaggccagcugccgcuguupuccaau\n", + "guugaccaauuuucuccuccaacugccccuaucagcaacgccuacacuuuuccaagaugaccacagcucaccacaaccaguucaaaaucagucag\n", + "aaaagucgcguaapagcagcaucaagcuucgaggagcggcugcaguugaagguaaagaagaguuuucaaagcugaaccgacucaaggapaaacacgagaa\n", + "cugacggucauuuuauacuaucaccagucugucccaagaauccagaggauuuuguuuccacaaccucacuccaucagugacaaaacugcugguguuuuuugagguugaguguuuguaupaucaagg\n", + "auaaaccuccacuuuggugacaacaucucuucagugaguuagcuaguauaaaaauuagcuuucuggccuugccuupaggagaagcagcugaagcuuuugcuguaagccccacaagcaguaaua\n", + "gguccaggaucguccguccgccgupcccugcgcagacgucguccagucupcugcuccgacuguupccaucucccuccccuuccccgcugccggcggaaaacgcgguc\n", + "gcaacupagaggaaaauacacaaaccagcagcguapaaaaaacuccuucaaccguuuacuuccgaaacuccagcuagaucagaaggaaaaagugaaagaggcagagguuucuuaaaaaaaa\n", + "pacuaggccuuggccauccccgccuguccaccucucugccucaccuccucgguccaucuccacucpcagccggaapccuggagacucucugugugcacccuaaaagauccucugcucagacc\n", + "ucaaaaucuacuucaucgaaaacagaauccucauucugaguuuaaggacuccagcgcugcaggagaugaaaauacug\n", + "ggcuuaaaaaaaacaagucuuguaguaggaacaaucccaacacacuccagaugacuucugauugucuugcagacagaacc\n", + "cagcgaucccucgcuuccagcucccaccccgccaccgccguccccuuuuaacgccaggcucgugcaccaggaucgucguccggcccucccuucggaccgugccuuccgagcgugaacucaagccc\n", + "guaaaacuccucuaggcaagaauacaauaucccuggaagccauugaaguuacagaagauaucccggcuuaucaa\n", + "agacaaucuccggcacucagagcuucauuuaccgcagaagccgguugucucuuccaggaccuucacacacgcgucucagugacagucuaaacccacucaacagaaccccagcuuuccaaaau\n", + "guccugaggccucacccggccccuagagcaagcagcagcugaaccauaggaggagaagcccauagagaccuagcagcccuuuuaaagcucgagag\n", + "gcggcggcggcpagaggaagaggaaggaagacgagcaaccagagaaaaaapaaaccacacccaaaaccaaaccacaaaaacaaaaaacuuaggaaag\n", + "ggcuugaaagcapacuucuuucuuuugccuacagacaaaaaccugucuuccuugcaccggaaaccgaggucuuuaacuguugguguuccucguuccaauuacaca\n", + "gugaucucgagcgcugcuugcpucugcgcgucugcgcagcucggagugccgcggccgucucggagcgcacguucucuuucgauguggaag\n", + "guucuuaauauuuucugugauaaucuccagagcagccauaaacuuauauccuucuuucuugacacauaaguaguuuucuucuuaacuuuauauuucaguauuacauugugauaaacugaacuuucuag\n", + "gucacccuucugguuggcugcugguuacgcucccugaggucauuccccuccaucaccucguucauccgcugaugaugagccac\n", + "ggcgccgugaagcccuggcucuuuuagcccuuaugucaccaccagcuaaaucucuuugg\n", + "uggaccucuuuguauucauaaagugcugcauaacuguaaucagauuacaaaucuuaagacaauucagccuuupcauuagc\n", + "aggccuuacaaaacaucucugcucacacuagcgapcauccgaaggugauucccaccucgaggaggagcagaggcuucguguguauuugucccpuuuguugaguucuguccucupcccaacc\n", + "ccuggaaccagagauuccguggccgagaagcaguuaagaaaaaaaaaaaccuuuucugcuacaauacuuggacaaguugaauaaaucgugauugaaaaccaauauaacuguuuuuuggugguuaguac\n", + "gaaaucaggagauuuuuggaaauaucugaaauccgacacuuccaagcaucaguucugagagacug\n", + "gugcaguuucauauuagaauagccacgaguuaguuggcugucuuuuuacuacagaagaacacuaaaagcugcucggagcagaagaaagc\n", + "guapaauugcuccucaagauagaacacagucuaucaccugcucccagaaacccaucccaaaccacagcaccaccuauaccaaacccagacaucugccaggaucuaapaaacacuugaccugacc\n", + "aagucuccaacugcacuaaagagagacccuacuggupcugapcccuccuccaccgguucugucacggaaucaagcucguaagagcuccacauacucacuuuugacagaagcaucuggcuggauc\n", + "guauccacacgaagcacauucaaaaccacaguaaagauuuucuaucugagaccagcuagagacugacugcaaucggagaucugcaaguggaucucuucggaguguguggauuauaaaauauauag\n", + "guuuuccccgagccagcgauucccucccucugcaucucacagucuuuauauccaacuucgccgucccaacauccagcgcgugcaagaag\n", + "guucugcaguugaagcuugucuauccagucugugacggacccaagaacccuugacuuaucucaacaaguaggagaag\n", + "gaaggacuuaaucuaacuucucuccccgcaccuuuccugcaccucccagcauuuccuggcugugucggaggagccgcacacauuggaauugccugaagcucuguggcuagaacauugaaacuaug\n", + "ggacaaacacuuacaggccggugaagupcacuuauuguucgauccucuaccaguagcggagac\n", + "ggauaagagaagagaggaaggagaagcagucaccacagcacccauccccaaaacccgaagcaccgcacgcaaccccaaaacccccaaaaaaaaaccagaagucagagaaacgagaaacacagaagaag\n", + "agaagcugaaauagaaagagaaaaagaaaaacccuaaaaucaagaagaaaaaaacaacaccaaaacccaaaccacagaaaaaccaaaggcagagcagaacaaacgaaaacccugaaacaagaguagac\n", + "cgcagacuccagccgaaacaaccagcaagagacaaaaacccagcagcaaagagagcacacaucacaucacagapapaagaagauagagaagaagagaaaguapagauc\n", + "aaaagcccaugacacugcgcggcccaaggaagacuuuuacuuacaaacuuauggcaccugcucuugacacauccaggcugauuuuggaauuuauauccaugaacuucauaaauuguucuacaggaaac\n", + "acuuagaaaacaguuaggcuguucagaguaucaapaaagaagucccugcuuucaguuccuguugag\n", + "cuccaggaagcaagaaccauaucaaggucagcaaaacacacaucuguagcugcagagaccuaaaaaaaaaauuucacaaacuguucaagcagagcauuucgaag\n", + "cccaacccgcgguccucucacupcccapcccuguccacuucucuuccccaccgccccuccgccugcuucgcgcugcucugcuggacgcacccucpcccaacagaagccccuguguccccag\n", + "guggagagaaggccacaguaaccauuccagcugucccugaaguaaaggaacauucucuccucaacccaccccaacacaggccauugacaggagucaaacucccugauauuguugaaaauaaagaaaug\n", + "gugucaucaccauaucacuuguccucuucugaggucauacugaacuacagcaccpugaggaag\n", + "aagaaaaauaucaccuuccggaagucaccagagccucaggcagcuagacucuaaucucucagaaggagaucagaacaaccagagaacaguguaagacacaguguuugagagaaucaaggauucacaag\n", + "ggaggaaaguggagaaaguugcucacacacuuuugacugcaagacugguggacuguaacagaacuucugua\n", + "ggccgcuccugguugcuaagaggcuuaaacccuuacccaaggauccuuacuuggagauucccggc\n", + "guuauuccpaagaaaaguuuaaaacuguugaagagagcgccaggcccupaaccugcugaggaacgua\n", + "agcagagagugapccucuagccaauuuuggaacuuuaaggaaaaccugcauacggaauaguuuucggcguuucugaggagcucucuuucguccaggccccagcgagcucuucucacugcc\n", + "guauuucugcagguuucaccuuccaaaaaaaacagaauugcggagccgcugugaggagcauapaag\n", + "ggugucaggaaccucacaaaagccccaaagaucgcucagguguccagcapapaacgaccagcucaacaucucucugauu\n", + "pagagguggucuuucugaaagaaaagcuuagguauucuuugcauuugcuugaacucgagaaug\n", + "guauugaaaauuauaacagaagcuagaucauucaaaaaucuucagcucuuacccgaagucaaaacaucuauaaaaug\n", + "gguuuugcucpauugcaacaucaaucccggagagugacaaacccagaccugaaacaucagccacc\n", + "aaagaaaaccaaagaagaagaaaaagcagaagucacaaaaaaagaaggaggagapagagagaagaaaaaacaaaacccuaagaaagaaaacaaaaaaggagaagacaucguaggaggaaagacc\n", + "uucaccagauuuacgagacuucaaggccaggcaaaagaagauuuaauuauaaucccaaauuucuaauggucacauugauacguugcauuuugagaacaaauugucuauucaaaccucagcacccugac\n", + "uuguccgcccccuggcuucgcccuuuaucucaccuuccuuccccugacapagugaauagauagcucaccaggaauuccugcauuagcacapagcaggaagcugcagugaccguguguuccugcc\n", + "gaaaagagaauucuguacaggcuucacuuagcaagacugucacuuuggcccagaauuaauucaggcuacuaaug\n", + "gaaaagguuaauugacaacauuupcaacaccaguuuuauuccuauuaccagauaucauaauucccuggagacaguaaauugucccaggaauuaauupcaucuguaaaagaga\n", + "pccagaaccucauucgcgccgaggcuggcguucgccuccccaguguaccccpccaugacccagcccagacuuaaaaaucugcagccagucuuuucaaca\n", + "auauuaccuacacuauaauugcugauugcauuuauaaagguucgcaaacuguaauggucugcuucaguguaucaaacuuaaauugcggagacuuucug\n", + "uuccccaguuuuucuuuaaagcauugacuuuuuguagcuuaauucccaacauaaaguuaauauucaauucuuauuuagaagaagaucucaguuucupaauacaaaga\n", + "paggaagaaacaaccguccaagaacccaccccagacccucccgcuucccaggacccpagaacagagagcgagucgcaacgucccggucaag\n", + "ugcacuugucguccggccccauuauauccacaaccucuuuagagcugaccuuacuucccuccacgaaggauuuuguaauaccaaguuugcuggacaugguauucuac\n", + "ggaggcaagagucacccuagccgaaggaagaagacaaaaccaagaacccguccaaaccagcccacacccaaaacacaccaaccccaccgcacaucccagcccccccaagucuccagcapaggaaag\n", + "gaacaaacacuggcacuccagcagaucgcgaaucuccuucugucacuuacagaaagaaguugucuaaaguuagu\n", + "ccgcgccgcgaggagugacuagcgcaggacuugcgccgcuaaaaacaccucagaguuuugauuccuccgupuuucugcacaapaag\n", + "gguacccgagugcpaaagcuuuuuaauacaaacuuuucuccagugauucaccagccuucaaccaua\n", + "gagagaaguaauagaaaucugcaguugugaaauguuguuuaagaagaucuuagagccuuuuaguauucag\n", + "auucuucuuggaguuupauuucuuuagaaacucapaaaacaacuccauaaguguugaauucucaaauugauuuggagaacauaaaaccagcaauccauuuauaaagcugaug\n", + "uuccuaagucccgccaucaacaccugcagcgcuuuacucgauaauaaagauaacuuacauucaggagguaaaaaacugag\n", + "aucaagaguugauuccgagcucuuugaccgcuguuccuguuugcacuupuccuguagagguuuguguuugugaaguuaacuugcaccuccaggaguugcacaguggugagaaaaaggaaggaaaug\n", + "gcuuuucggagacucacugaguccccggaagccucucccgcguccgaguaccuggaguuucaccacuggugagaguuuuucauuguguacgcagcaucuggugagagaagcauccucuccuacuggca\n", + "gacaauccacgaggaaaguucuguuacupacgcugaauacacuguccgaccuccaaguucagc\n", + "gagacacucacagccagcuaaucagugcucauaguucggagaccaacagcauccuuuaaaaacaaggc\n", + "auacagcucuaaauaggucugagupcacuucauagcuuaagacupcauuauagcugcuaua\n", + "ggcuauaagaacuauugguuugucuuuaaaacagucugcaggagauuaggapagaaagacauagaggaguucuucaaggccccagacguapagaaa\n", + "gcugcauaauaacaccugccagagagugugacuguuccuuacuaaccuccagaaugaaggcagcccuccuaucaaaccuguucuuacugaugacccaccag\n", + "apaauaauuaaacauuccuugucgagauuaaaacaauauuauccgcguguuugcagcauuacaucucaacauaaccuacuccggaguuuguggaggaacagagagaagugcaguagcaaagaaaag\n", + "ggaaacaacuacgugcacccauaucaagguuucccaagcccacccaguaccaaagccugaaagccaugcagaggcuuugugagapuccugagcagcaaagcaagcaagcuuaaaauuuccaauuug\n", + "auuuaguuuguggaaaggucuaaaaccauugccaucacucagaaauagauucacacauccaucaug\n", + "aacgcaaccagaaacgcagccggagucaccaccaacacaggcccaccugccpcgacgagcagaaac\n", + "gaacagugccgaggcagguuccgagagcgacaucaacaacucuaaccaguccuagaaccccaccuucgacgccagcacuuggcuaggaagcc\n", + "ggauugagcagccucccaggucuuuaaccagcggcgcupcuguguuagucgcugapcupaaggacaguagucccggaucuaggugaucag\n", + "aggagcacucugucaauaaagagcuuuuaauuucccucagcugugccaaucucaagagucug\n", + "cuuuuuaccacacaaagauucguuauaagacacagucucapaaaggcauuggcagacucuucuuuacacugacccaguucagugcaacacaaggccccagaaguuucupuccccucugcacc\n", + "acuppcgaacgcuggucccgaagagucuguuuauuuugcccuucgacuucuccuguccuuugcc\n", + "ggucugucacuucuucuccagcugugcucgcuggacguauucccgcuaggaucaguucacuccacgcagaccapaapagaugcacuucuggucgguguuuguguucauagagacu\n", + "gcuuccuccauccuuucaaauuuacuaggaggcugaaacgaauaucaaauaacacaagcaaaaaggaaguucccauupagugguguaucaagaguaagaaguugugguucuggauuauccaccagc\n", + "gauucugaaacaauuuacaagcuucuguuccagaagugaaucacaagauuuucagacaaaaaauucagcuucaauauccaccuauagagaaccaggauauccuuacuagc\n", + "uguguucauuauuuacagcagccgagcucccugccacuacuugcccacucauuuugcagacugugcugagaaaagcagugugccaaacacuagugucuuggacugugaugacaagaaaucuggaacag\n", + "aggaggagacagauacagaaaaaaacuuggcuaccaaaagaaagacggaagagcuuccaggauacuaaaaaaauacuccucaaucaauauuguuuauaaacaauacauaaaaguugcaapacgga\n", + "ggcauuccaacuugcauaagaagccauuaucaaacuucuuuaggaagguggucucaapugccaggagcaaaaaucuuacugaacaccapaggaaucacuuuggagaagcuaccagcaucuuagc\n", + "agacacuccugaggcucggucuccugcuccccgccugccuccgcagccgcauccagcgaggcguuggugagccaggcucuuccauccugaupagccucagaauauccupcucagacccpcuc\n", + "agaaaaaucuucaucccuauaucaucagagucuccauguugguuaaagaaaaaccaacaccacaguuuguagaagacuuuucggaaauugucuuugucuggauuucaagcauucaucaaacacgacag\n", + "cccgccacauccccucpucaccugcaagagcccagaguccgauccgacguaagcagauucccacgcaucggcgcugcgcaccaggcgcagucacccacaguccapcgaccccuggaggaggc\n", + "aagaaauuucaacucugaaaaggaaagaggcuggaauaaaauuugaaacauuauauuauuugaag\n", + "gaacupcccaggagucaccucuugucaagcucaauuaacauaucucccagcggaaugapug\n", + "capaaguucuucaaccuucucgugccuggccuaccagcaagcaauucacugugcugugcggcugcucgcuuacccucugccpcuaagcgcggcuaccugcgcacpugaggucucucgag\n", + "gguauaguucugagccuuuaauguugacauacacacauuuucucaaacugucccagcagaacaaaacuauu\n", + "ggagugauccuagapagaaggaaggacagaacaccgcguucugacuggaaupcuguucacaaacacagcgguguucuggcgaccucggcaaacacuauucacagucgccuccagcc\n", + "agacaggaggucgaagcguauccccaaucacuuauccugcugcuauuccaaggcaggcaauucugcagaaguucaaggaggagcccaggaaguguggaaacugguauaauaua\n", + "ggucugcaaagaaaucugaauuaccagcaccccagagaggacccaagaggcaagaagcgcgaaua\n", + "ggaaguuacgcgcguccggagccauagcuuccagcucgcaaacgcauuccugugccgccacccuggag\n", + "pagaggccuggaaacuuggagcaggacauccuuuaaauacagucucugacaaacgaggaaaca\n", + "paggagagcagcaggaggagcugcagccgagaccgaaccuuacgaggcucacaaaauccacgcucapaaacacccaaccaagapaaaggcacupaagcugcucgaggugugccgcggc\n", + "gcggaagaagagagaggaagaagcaaacugagcgaggagcggaggaggcggagaaggagagaggaaaagaaaaagaacacacacagcgaccucuccucugcacg\n", + "gaagcuauaaaaucugccaggccugccuaggaggcugcugagcugaggcaagaccagaagcuggugcaguacugaucugugcuuuugccagcuacaccuggugcpaaaagccuucggacaucacug\n", + "ggugugagaacccucaaaauuguuuggcupcuucpcupuugcuaggucggcagucugugucaucuacucaccugacuggupugucupagagugcccaguggaauuucucagaaacu\n", + "aaaagugugaguuugccaggaaagaaaaagaguggcpaaucuccagcucugcagcccaaucgccuccccauccggauagaagcuauc\n", + "gugcgapcucccggapcacgaaaguggauucccgaapcgaaaupcuucucuacagcu\n", + "ggcgaggaaggaagcagaaauaucucucccaguccaagcuuuucacuaugcagcupacaacaguacuacaaaaaacgagaucuuguaaaguuaaaauucucc\n", + "agaaccaucagcuggaacaaagauacagaagcacuguaagagcugupacucaapccccaccucapacccagcggcapcagaaauucggcuuuaagcacagaagcucaguaucuuccaccu\n", + "gaucccaaagcgcaguuccgccgacugagcuagacuccuuacuagguuaaagaagaccaaaaaacugcagcagucccagcaguuga\n", + "gauucpagauaaucgccauaucuuguuapcagcguuuuucacaauauacaaccucucacaaagccaagagcua\n", + "apaacccgaggugacacggacuuggaggcugcuguugcucacacgagcapaacuaccugucuaucuacgguaggcuugguguuuucggaaaaguuggucccagugguuuggcagaaguuacc\n", + "cagagcuggaacguccuuucgguugcuuugguauccuccccucugcacccugcagcuguccaggccapcccggaggcpucg\n", + "auacacgcugccuaggaccuaggaagagccagcuaacccggaagaaacaaaugacacuggcagag\n", + "ggcgucaaacacugagacucpagaggupuacguuuucccuggcacccuugcucgcugugaaaaaaua\n", + "gucacuccagcagaagcaagucuuggaaguguuucugccaagaaagaucacagacaugcgcgugcgc\n", + "gccuacacacagaggaguauuugcaaaacagcaauauacaagcuagcuuucuaaaaauuuuaaag\n", + "auugccgacgccgacgucaccuggauaugcggucuggacgugcccauucaggugguuggcaapcuupcaccggaagccugcpaggupuugcaguguugguguuggaagcuggaggca\n", + "gguagcuaauggagaucaauaucucucgccccgaccuccgacgccgcgguguuguugccucaguucaccaucuccuccccggccucupcaggagagagaagugaagagccucugcuugaccgcgcc\n", + "acaggaagagaagaaaacagapagaaaagaaaaggaagaagaaaaccuaaapaaaaagaaaaagcugaacacaaaapaaagaacagapaggaggagcpcapaggapaggap\n", + "auucuccaucgcuagugaggauuucagcccccauaacgagcagacagucucuaagacagguugaaccucuguccgcuuccagagugcccacc\n", + "guggauacagccagaaaaauaacuuaggauugucagaaucuuccucuuaccuaccucaucucgcauacaaaguucaguuucuucgagauacaagucuuccugccacuucaagaaggagacggcuggcu\n", + "uguugagapaaagauacagacgauagucgcupagucuguuaucgccauccgcaggaaggcuaaggaaguccag\n", + "auuauaaccauagucucagucuuauaaauaggcagccucuuggaacaauucuaggcuuuaaaaacuuguauaaagcuuauuugagaucaaugagugcugcuuucagaaauagacauccaaaaaau\n", + "aaaacaguucagaggagauucaguuggaggcuguauugagagagcacuuuugcccucagugaucagag\n", + "gccuuucuacauupcugaaagcaaaccaauagcagauaggacccaagaauuuugaagaguggucauuugcaccucagagaaag\n", + "ggaaucuggcaggaaauaauauacaaucucuuacauacugcagaauuucauuccauacacuaauagcg\n", + "cccacugaucggaggcpcaccgcacggagccccuggcggaggcagcgagccccaucagcgucagc\n", + "ggagcgcuucuacaggaguggccugucucccgcuagacgcuugcgcugcugcgccgcccugugcucgccugccucagccugccaagagcpaaaaapaaguaaucuguuccagaaacug\n", + "gucugcugaacccagccacucccucccuucuccucccccucuccaucaauuucccagcccguuuccguggaagugugucggcu\n", + "guagagcacuugagaagcuaacucccucccaacagagaaagcuuuccaucuauuacugcuucaucacacuugcugaagacagucaauuaacagcugcccaagacauu\n", + "auuuacagaaaucccugagacuuuuucaagaacuacugaggagaccuauaaaaacupaagaccuuuugcaccuuggugccauacugugugugguggaacacauccuggaugguuuuuauugugaac\n", + "ugagagugcccagcaaacccccaccuaaaccaucuacccugaagcuuuauuacagacaacucucugguuucauaaaggcuguuuuuccucuguauauuucupaaggcaaaggccaaaucg\n", + "gugugaapaauuccccagcccuucgccagugcuccccagcacuucaccucggcuuccugccgagucuccugacccucccapagagcgucggaacauacuccuuagauuccuggacuuuggaac\n", + "aaauccagacuuugupauccuaaaaucuauucucacagaucugccuugaaaauaaaaaauacuuccugcugaucagauuuguguguucagcuuugugguuggagucagucuucuugcacugccuag\n", + "cauauucaacuuguagcugcacuapaggucacgcapagaacagagcccaccupagcaucauacgcaagaacuugaag\n", + "agcccucacacggcuucuggacgcaauccuuugaaccpuuauuggccuggauucucuaaccuagugugugccgcuuaaagguugccagaggagcupcucccaggagaggagauccuggacc\n", + "apccucugaaauacaaaauagagcuugccapaucaaauuuaccgauupuuacaaagcgcuggagguguugauuugag\n", + "pacggugugucaggagugaggagccagcucagauauuuaaaaccagugcuuggauggcuucu\n", + "aggcggagcapaccuuuaaaaacuuugcugacauacpcupapcgccggacaggaagugcccgacaucccuucuucupagugagguuuaaguaaguggugaggagacacacugcacag\n", + "ggcugcccccaucaaauugcggucuuaggagacacugguuccuuuuaaaacugugccagcacaccagc\n", + "agacaaaaaacauucaaguaagacuaaaacccaguuuuauaguccuguucagcaaaaaaauaucacaaaag\n", + "gaguccuuuucaapaacaauccccuuacuuccugauaauccccaaaaacauccaaacuuaguacuaaccuuuuuaaccaggauuccuuguucaagguuuaacaaaacucucagacuauuucucauc\n", + "gucacuuuuugcgugucuguaggaccgacuucuggcagauggaacaaacucggccucpcuacgapccucagauc\n", + "agaccuucaacgcccguuuapuccagccgcacccccagccagugagucucuaaggauuccaccucagacacccgugugcugcgacaacgcacggagugapug\n", + "ggaagcupccgcugucgcggcaaacggucgcucuugcucuuucuaaguuugaggaaaacauugcugccuguggaagccacguc\n", + "upcaggccacccgcucuccgagugccgcucauuuuaaccaguggacgcauggccagaacggcagcucucacagagaacuucuuggcc\n", + "gagaucgcacgcuuucccuccacacucuagcgcacacagcuacucaccugcucucacucucacucuccgcc\n", + "aacggacagaggcaaccccgccaccccgccgucucaccggaagaaagccccgaguccagcccugcccuaggaguagccgcapcaauaaaaggaugagcacaccgcccagucccggagcagcgacc\n", + "uagagaaauccaaccaagcccaacaucuacgacuagcucccuuguuagccagupucuaucugcuaaguuacacuaacauuupcaccgccaccuuaaacacagc\n", + "gaagaggcuucuggcaccacuugccgugcauauaaaaauuugucuuucuaaaaaaaugcaaucugag\n", + "gcuggcugcguaucaguagcacaggaaaagugaaagaaaagcaggagacuguauuuuaaagc\n", + "gaaccaagaaaaacucuuaguaauacaaaauuugaagaaccuaaucaucaaaaauaguagcaaauuaucucauuuucagauuucuguugacuuaaucaaucccaacugaagaaaaccaggcuuuaaug\n", + "acuugaacacacccaucucuguuuuugauagaggacaagaaaucuauauucaaaaaacaaggaaauuuccugucaacggcuuacggaauauuuaucaccaaaaucuccagucugagaag\n", + "guggaacugcupcaggcgccgguagcgcaggucgucccgagucaaccagguccucaggcuccauc\n", + "auuacaauccaaagucccacccuuucuucaugcugaaggauccccaaapauaaaa\n", + "gacccagaaucacugcugaggccccuacucauauugcccuuacaccaacucccagauauuggagaauucuuaucauc\n", + "gcaguaagucacuucuucuugcacapaagcugaguaagaagucuucuuuucagucaaacacaaucagaagcuggucuugaguaaccaaaagaaguuucuucaaaaagguauaaagagccugugac\n", + "agaagaagacaauaaaaaaagcaccaaacaaaccgagaaaccagaagauaaagaaaacaaaaaaacaacaggagaacgaaaaaccucggaggaggagaaaaagapapapapaggagaagc\n", + "ggagaugagugcagaaguuuggugugaaguugaagagugcugcccugaaaagcuuucagaaucccccggcuuccuuggccagaacaaa\n", + "cugcuucaagagaaaaagcuucucguaacccagcaaguuucauucuguucugaaaggacauuuguccccacuucagcgucagaagaaug\n", + "ggcccggcaccuggcuguccugcuguccugcuccgaggaaguguupuguuuauucgcuuagccucgccuuucaaagcuagcaggcgagagugaguacuuuuuaccagcpaaauaaaua\n", + "gaguccuggcucccagaagauauagaaugacuacugcgcagccuaaguuacauuccaccacuggcacccucaaggaaagcaucugccucggagccguugacacgacc\n", + "aguuuagaaaagcaaagccgaugacccagacccauacacaaacgaagccacucagaaagcaccacacccagcaacaaccacaaaccaaggagagaagaaacagagcagcagagccggagguagaggcc\n", + "gagauccaccuucaccaguauucaauuacagaccaaaauauuuaucaucauugcaaaagauugaa\n", + "acaagaaaaaacacaaacacacaccaaaacccucaagaagaaagcaaccaauagaaggaagaagaaagcaggacccagaggaaggaaccgauagagacacaggagcccupapapagacc\n", + "agcaaguguuggaucaggagccaucaaacauuaauuuugaguaggcugguuucugagccuccauccaaccucaaccugupuaacacuaug\n", + "gcaucuuuuucacaaacccaaagcucacauuauagcuccauuaaaaacacguuauuugguggagccucupacugcggcucaggugcagccaaaaggcauccacuucagacccccuaag\n", + "cgapuuuuuacuccccagcucuugcgcuucccgcuccaaccucucaguucuccuucacacuaggcuccpucgugccugccuaapcaaggcugcuggugugaugucacgagcuggacgucuc\n", + "gguuacaccaaacacccagcgacuccaauucugcacaacgaaugccuccaauaaauucuaaaaaagauaugguaaauagccagaauacagucagaagacagaguguguugauuaucuucacpcagg\n", + "aagccaccccugucuguuguggcaguguuaaggcuaagccacacagaggaagagupcuuuggagauuucuacaaguugcapucuuacapucugcagcggagcagcucaaggagcgucugc\n", + "gcaguuucucuucccaucucaucuccagccpaggccgaaggagaccuucaaaaacuucagcgguacgcg\n", + "ggcagaggccggupagcuugugaaupucupacguuggcggcgucggagacuaaguuuaaaagcccugag\n", + "aguaaaaaguaaaagacagacccaaguuuuuccagcauauugcaauuucaucgcgaaaagucaaucuucaagcacaauauaaa\n", + "guucucacgcucggcaacupcggcgccuucgacagupaagaacacgcgcuccgaacuucpagccpcaguc\n", + "gagugcaguucagcapagaucgcuuccuccacccacgauucuucuagcugagaagagagag\n", + "agucaggaaaaggacgauacccguuucucucgguaggucagucuuagcugaagccucacucaguucuaguggcacccucagaccugauuaggauugagauuauuuupccauuguucacucaupc\n", + "agucuugaaggaaucaaaaaagauaaacuacuuuuggaagaaggagcugcaaggaagaaaacagccuggagcapaagaagugcaugaaug\n", + "agaaacuggcaaaagcaccaucagagcagucgcaaaaaaccccaacgcaaaaacaacaaacccaaacgacccggaaaccacaacagaugcaggccaggaaucpcagagagcapagaap\n", + "gucaagucuguaacucaauuuaauuucuacaacuuccagauucgaaaauacccugauaagaaug\n", + "gacauugauuuucagcggauucccacaguapcugaaaaccgcugupacuccccauucggcguguggcgugaacgugaccacaggagagcucguuaggaagug\n", + "gcugaccaccucauacuggagapaagucccucagacagaaggaagcucgguaagaaaagauaacag\n", + "agccgcgccccuccgguccuuugcauuccucuccucgcucuuucaccuccuccgugucuaucgcagcuggacagaaaaggaagcuucccucccagcaggacugugcuuacuguaaggaa\n", + "gaacuugaagaagaacgaaucuaaagaggcccagcauaaauucuaagauacacacagucaaauug\n", + "gguuacuuuggaauauuuucugacaaaucacugcaaaaccaaauuccacugcupaccauauuuuacccaaaauaccaaagagauacagaauuuuacaguggugaaagugaagaaggaguaggcuug\n", + "caagcuaagaaaguuaaaaaucauuuggcauucagcaagccauagauuacagaaaaaaaacuggugacacagaauaaaauacaaacggc\n", + "ugucagccugccugcagacuuuuaaaaaccaaagaacacuccaggaggaagacaaaggagucuugaca\n", + "gaucaaaguucgapaaguauccccccccgcgcccggaccuccugccucccuccgaccuugcag\n", + "uuaaaacugcagugcgcugacugaggacucgcuacggucuggaaaggcugcuugaagagcagaua\n", + "guucuaacaacuaucuuggaggccaagucacuacgacuccaggaguaggagcugcaaacccucuuucugcgucccccucggauuugguggcagagcuucuucacuugcccuacpcucgugagaccc\n", + "uuauuuucacaauuucaaaaccaggaagaacauccagcuguagcaaauuacucggucuaccauuugcaguucauuauaucuacauuuuaacaucauauaagagaguuaaaauauca\n", + "ggaauaugacaucucccucagcuucugaggagaugagcaagcacaguaaccagccuccaucccgaguuuugagcugucug\n", + "guccauugcagcauuuaaauucucuccaggagaccaaacaaapagucuuucacaaguuuucuucacugcauauuacuagacugagaguuaaucacacaapucugaaaaauaauuauagaaag\n", + "ggaagugcaucuccgauagcucaagcuaggcugagcagagguuuccaaccacaaggcugccuuuaaagccaagagaucuugcagaggaaggacaggaagcuuuggaagag\n", + "gaggagaaggaggaagaggaaacaaaagagaacaagacaagacaagaaccauagaaagacccacagaacacccaagcccaaacaaaaccaaaagaaaapaaagaagaagauagagapaaagaag\n", + "caaacugucacuccugcucucacuuucaaucugcggagaaggauauuaacaacauccucacuuucuuauuuggagaagaccccagguuugugauguuguucuuaaaggaaaaaggcucuagcccggcc\n", + "cgcuuguccuuuaccucccucucucuuccagccuauucccagcuuuucuucupcccaggaaaac\n", + "aaguagaaagcagagucacugaapccuacucugaucacucuggaucuuggucccgcggagacaauggcc\n", + "aaucuagaagugagauuucugagccgguagcgcuagcgagugugcuucuggagaaaggaacugucgcagucuuaaauucgcugaagagaaag\n", + "gcaacaaaggaauccuuaaccagaguuggugguuaaggaagaacaccaaucccagcaguucaacacuaaaauuaaaaaaacuccuguuuuucacagcaucaaacuuuucagcagccaaaacccggagc\n", + "agacuuucagccccagaggaapagugcuuaapaucagaaaaaaacccagcuugcggcugcuuaauagaagaugcagagc\n", + "agccacuuaccccaaggaacggcucaagcaacucacuccagguccaucaucaccuggauuuguuguuuaaccauuguuucauugcaaacaccacccauauagaggaguggagc\n", + "gguucaugguggagccuacacaaauacucguugaaacagccaaaaacaucccgacuccagacacugaguguccgccacgaccuugucugcugcucaaaagagcugauuugacagagagacuuuggacu\n", + "uuuucagcuggaggaggugaaaaaaacugcuuacucaaccaguagucaccugacucccggugguagcaaagagacugaggcggaaagccac\n", + "uaccgagacgcagaaagugcaacccgcapagcagagcagucuuucuaacauacauucag\n", + "agucucauaccaaagcuuccuucucuugacaaaaacacaaaucaaucugcuguauuauucauuuauaaaguagacugcugaaggccauuccuugaaucupacaaa\n", + "aggaacccuuugagcuuccagcucucucagaaucaagcacggcuguagcugapuggcugauauug\n", + "gaguccggccccguaggcguccugguggacagaccccgcapucucagagugaupcugcccacgcggucgcggcgcgugcggcugcuacc\n", + "uaagcugcccgcgcccgcggcugcugccacuggcacggacgcucguuacugaaaaggaggaagacgugcucuucagagugcuuugucgcuugagaaaaaccuucacaacuccugugguaggcgagcuc\n", + "gaucucuugauuagagcagcuagguuguauauuggccugcuugauuucuggagcagcaacuaacaaucaug\n", + "aggugagcgaggcgcggcgacgcuupagaccgaggcgcccgagccgaguccacggccccggcuaccagcuccuggaccugagacuuccuguagacccucupacucaapaguuuuugugagcc\n", + "puuaggcauagugcapaggaaagcaucagcagcagagacgcacuugcggcuucugccuuccgcc\n", + "gucuauuaacuaccaaguggcugucgccagcugcupcgcgucccagcugcugagucgapccuccpuccgcucucacgguguuuauguccggagcucagcacccccagacacuagccucaaag\n", + "uggapauuaaagguagcuucagcuguugauuuugucauaguuuccgcagaucaggacuccagucca\n", + "ggaguauuucacacccucpccggaaaaagccgcugauguguggugag\n", + "guuccauuucucuccugcccgcggcccugcguuguucccapuucaggaaggucupcuggcggcgugcucacgcacgcgugugcggagcggaucugaguccaggaguugagguuuuugcuag\n", + "uugcagaacuucaaaagcaaguggaccccccaaguuaggagaccaaacucacugauuuaagucaagag\n", + "acaguucuaggauuccgccuuggagacaucaaacaagcuuaagccaaggucucagaacaacaauugaucag\n", + "cucugugccgcgagagagaggauuucagcugccaacaaccaggccuggcaucuucuccgaaucggaguguaagcagg\n", + "gaagagauaaauucucuggcaucacaaacaaauauucuccaaagacagcccauccaacagagaggagacucacccccucacagagucugacacugacugacaacacaacaacaggaauuaaaggacuc\n", + "ggaagaacaagaagcuucucugucagccaguuugaaaauaguggagcgaucuguguaaaauacuggag\n", + "gcucuccaaacuucugagacaagauaccaguuggapaguuccuaggcccaacccaaguapaacaucuaccaacucugcgaguccuugucucagccuccacugccpccgcuuccaaccua\n", + "agcacapucugcuguuauccucccaggaucacugacupaacaucucucaccaucgccugcucagacuguggaaaaucagaagccuggacagaucaaguug\n", + "gaguaaugcgucaacuggagucgcacuucuccccucagccuuccaacggcgucaaccuguccucuccuaccccagucagcagugagaaggucucuaaaucucacaaaccaaaggaucapcgcauu\n", + "uccccaggacugcccccagcaccaccucuuuaucauacccugucuugccacacgucaccgcugccgaggcc\n", + "aaaagagaauugacauguuucacacacaaguuaaccaagccuuuguuggaaagagugaauucacuuucacauuaggagucuuaaaa\n", + "aaaagaggagaaaaaaagaggaggagagaaggaagagaaggaggagaaagagaagcacacacacaacaccagagacccagacagaaaaagaggcpaacacpcagagcgappapaaag\n", + "gucucacuggauccucauaggcagcauaucacauauuuuaaagagapagcagcagcagcuagagcuccagaauaacgacacucaaucaggaagcaggaguccuagcugucugcaguagcugcaccu\n", + "gcpapaagagaggaagagaagacagaaaaagaaagagaaggagacaccagccaauccaccaaaaaugagaaac\n", + "ucuuauccccauaucaccaaucccugaagaacagaaauucagguuucaaauuguggcuuuaauuaucc\n", + "acuaagccuauauaaacaucuaggaucaagcuguagacagagauauaucuuguucgcaggccagaaauugcuacccagaggugcuugguuggcacucuacaaagaguagcugaagaaagugaguuaac\n", + "gaaagguccagaguugcuguggccagaaaauaacuaacacagcuccauacgaggacaucuccguccucucpcgagaau\n", + "ggaaacucuguuccccacucucgucuccaacgcaggcagcagaguguccugucgucaugaggagugcuaaggacaacggaagcucccagauccagaaucagcaccagugccucguaaua\n", + "gaauaaaaaaaccaaguugccacagcaaaacacugaauccacaaaaaguuccaaaaacugccccgcaggaagauaug\n", + "guggagauaccpcuaccuccucucagccacaaauuucugugcccaacaaagcaacuucuuucuaccaagauaagucccggauuugucacuucagaguguugcuggcaguucauuuuggaaggacau\n", + "gaguuacgccuacccagccaaucagcaaaagugaaaaccaaacuauucuaauugagcuuaaaaaaucagucagucga\n", + "guugaacuguucagaauaaaauaaaaaaagauuccgugagguugcagcagagguaccuuauaaagaacuuuuugcaacaggauacaauupcuucacacauuaggaaguagauuuagaaauugaaau\n", + "gaagaggaaagaggagagagaagaggagaggacacaaaggcagagaagagaggagagagaaagaaccagcacccaacacccagagaccggaggaggagcagucggacacuaccguccuupagcc\n", + "apagaacucaaaauagccgaaggcgacpcacuucuccgacuuccaucgauuuccaaacaguucugugacuccuccucguucaccuguuccuccucgapagcacugguuugagcugagcc\n", + "gauacuucacgagacauaacuuaaacaguuupaauucgccapcaccacccucauuuccagg\n", + "gcaagucagcuauuuccuacaaagaaagcuucagagccuccccugagccuguggugagaacugcccacaauacaggaagaapacucagcauccuagcucgcuggaacugcugauaaucuuggau\n", + "gaaagugaucaggaacucaagcuugacuugcgacagacugcuacaguugccguacgaguaaggaaaaguugcuggcauuaauccaggagcugacaaggaucupapagaaaguagguuuucacu\n", + "gcaguaagcucccgagcuccgcaaccaccagcuuccuggcucucccggcuguguccucgucacag\n", + "aaaugaaacccagaaaacagaaagagaaggaggaaguaggagaacccgaaggagapaagaagaacagagagaaggagccaagcaagagccaacacaacacacacaaacccagacapagagc\n", + "gugaacacaggaaagcagccccgcagaaagcaacgcuuaccaaucccaccapcgcgugccuagaacuucauggucaag\n", + "gcaagacgcggcagaggagcuugagucaggcacuuugaagaaguccauuuuggcugcauaaguaa\n", + "ggucuucuugucuucuaggacaccuggcpauuauaauaaaaagucuguacaggcccuguggacaaaacuucuccucccuugacgaaucacuacggcccugugcgcaaccgagaggcguag\n", + "gaaucucgcacaccuuuaauacaaucuaacuugugaggcucuccaucugacagagaauuucucag\n", + "ggccacugcuuggaaauauuuaaaaaaucuaggacaagccaaaguugagcagugugacauuuaaaaacauaauugccauuugauuuaguucccpuaaauccacagcuaaaucaguugaacuuaaag\n", + "aggcaggacucacacagcaccaagucaagacugugccgucugucaaaaaaacuagucauuuacucacccuggaacuggaggcaaaggaaaacagcpuguuuaagaaaaggacuagcagauacaag\n", + "agaauaaacacaccagcuugcuggccagaagugaguauuccucugcaaauauacuaacuuuccagcagaugguaucuguagugacc\n", + "gaagaagcaauuucgguaccacucagapagcaaggaaaagcuucuccagcuguguuaaccaacugugaacccaggcugcugaggagaagaaguggucuaaaucaucuaggcguuuggaacagaauc\n", + "gucauugucaaauaguauaaagaaucucuugcagaauacuuaauagcaaucugcugcaaguuggcuucuauuguaauuccuaggcuauggcucuc\n", + "ggcuauuguaacgguuugcacaaaccuaauugguuuuuaagauugcugccuuaggcguuaagaagaaggcccaaggagaaaaacauccauauccaacaguugaguaaaguagcag\n", + "gcugagacaccagaaapaaaaacacaaauccagauccuccuccgccgauucccucaagacauc\n", + "aagcacaaagaaagaagaagaaaaaagcaaggcaccaaccgcagaucagapaggaagaggcugagagapaaggagaggaaapagcaguggaggagaagcggaaagaaaaacagaggaggaaa\n", + "ggacugcaguuuugacuuugccugugcccacguuuuuuuccauaaaaauccugcagagccgcucuccugcugccucaaagaapuuuguuuugcuaccaaaauacaaaaguaapucauggugauc\n", + "aacccugcagacggauuucagaucacagucuguuuuuacacuuaacacucucuccugugcguggccaccaggaagcagaguuggauucugag\n", + "ggaccaggacuupaguccaggapaggagcuucaucagagcugaccuggugugauuaaauaaaauacacaagc\n", + "cpaagcagacgaaccauggcapagaggagaucpaagcagaggcagaagagaggcuggaagaapagagccaapaagcagagaggapapcgagapagagg\n", + "cgcapacuuccucucugaaggccacuugauuuauaaucauaacuauuucggaggauauauccaaucucccacugauuuucugugucaaaaauugaguuccaauaaccagucuuaauuuguupac\n", + "agapcauacuacugccaaguugapagaaaccuguguuuucuucacacagccuuuggccuupcucggugaagaagguguuuguuugguacuugaugaggcugcagccuaguuuggugauuaac\n", + "ccaguuuuccacuucaacagcapuuggaaauuaaguaagcaagcgagugcagaagaagcugaagguggccucagupapaggauaguguggaaggcaugcucapag\n", + "cccaagcucgagccccgcagcagcugcuagacaagcagaggaaggugugagcuuuuaaaaaaguuucuuucgcguccgcpcggacgagaccgagacgcagucaauaaaaucugacg\n", + "uaaaagaaaccaugaapaauuuaaaaaaaaaacuccaaguggauacuguccauccaaccagcacc\n", + "guucgaggagcacauuagaggaacuugaggcuuccaaaaccgugagccuaaupaaggcaaaucuuuaaaaaauucuccaug\n", + "agagacucacggccacggaggcugugagcagupauugaaucuugcggaaaagaaagugcccaaacucpaagaaaagucucag\n", + "gcucucpcugcaggaucuaaggaaagucauugcagaccucacupaucaacaccaccugagucccucccaaugugcagg\n", + "ggcagugugaaaacucccaacaagccccugcupagccagucacaguaacucaacccggccaacccauucucagugaagugcccuaagaagagcuacugcuaacuacaucgaguuuacupaa\n", + "pagcuagucpcuaaaagagaaaaugaaacucaggcucaggagcacpagcaaccagcaacacacauccaaaaagccaaaucagagcapcc\n", + "agauugucaagucuguuucagacaauuuccuccgccapcuguuauacugaagaagccaaucacucapacauuuguagauuupaccugcaacaucauupaaggcagcaagaaguaaucuug\n", + "caggaaccgacacgaggaggcagccagagucaucuuccaaccugcugguccccacccggcgaagagagcaggaaagaaaaaaaagagapaagaaaggaaagagcccgaccaaaggaaapaaaaa\n", + "guggaagucaggacgcaguggccacgccacaguuucaaaacucccggccccucupccacuagagaauccuuccagucuupcaagaagguggccagapaaggagaggauuguugaggccg\n", + "agacacccacucguucaccugcgacaucugcccacuuacacaagaacuuucuugagcaaccagcgguaaacucagcccugugaaggaggagucacccggaaauccaccag\n", + "guggacaagaucuaaaaauucuguuguuagccaccucauccucacuucaguuccuaaggauccguguccccuuaaaaaucgcuugucaccacucccuguuaaacuaagag\n", + "aggacuacacacauuucgaaaggacacugcugcugaguupuaucaagaagugaagaaguugagaaucuugguaugaaaagaagcagcacauugaaggcuguggcugaaccc\n", + "ggagaacacauccagugcuaaaaaaacagguaacuuuacacaaguuuaaaaaacuuugaauuaaaucucaaguuuaaaaaaacguggaagcuucupccu\n", + "gugauugcacagucauuuccaagucugauuuuuuauuuugcagagaagauugccauuuugacacuaucaagaauauaaag\n", + "uaaaacaauaggagugguuaaagaacaucaucuaacaauucuuugcggugaggaag\n", + "guaauucguucgcpaaggagaaaggacgguagcggccuccaguugupacauagucgaaaaauuaucuccucagaucacaagccagagcugugcuuuucaaucuccugucucucugaupcauc\n", + "gugagagcgcgugucuaagaaauuuuaaaacagcuaaccggagagguucuuuccgcagccugcacugacccgccgaaggacagcupcgucaaa\n", + "gaaagccuupcaccugcagcagagucugaguuccaaucuccacagacccucuaggucaccucucacucucucugcuucucagacuucuggaacuccugauuacuccgccauuucccaccuucagcc\n", + "gcaauaacagccaacauugcuugucggcacuguacgaucaccguuuuuucuuuccucaaggugcg\n", + "auguuggacccgagaagcuggagaagcuggapuaaucuugcuagaacagcaggaauggcuguc\n", + "gcpcucaguuuccagucggcuugcucugaucuuccagccuacccacgguuugccaggacuguaguccugguuguggagaagugauacpaaucgccgcuggacacgaaguccagagcuacacag\n", + "ggaapauuacguucuagugacauugccuaccugaaguccacaaaggaccccauggcuuucaag\n", + "agcaauuuccagcauuuaaagcugcaguaaaaauucguguguaauacuucggaauuaaaaaaauuuggaaaauuuuaaag\n", + "ugcuccuuggagaacccggugcgguagcaggugaguuugucggupagugccauuaacauuuuugapaucucapcggapaaacucacacuupaaagccaau\n", + "gauuaucccgguccuuguuuaauuaccuugagucggagccacacaaaguccuucaaccacugccccaguuguagagcccacccaggcaacucuuaucagucugcacuacaggacuaacu\n", + "ugccagguccaacccgagcuucucugacuucagcagccguuagucaucccuguaaaguacugcugacagagauggaacucaaucuucacuuccaggagaggupuggagacaaccaagaaagcagag\n", + "ggccaaguupaauugagccacaaauaaaaaaaagcauuauuacauauauucaaggcuccaauagcaauccccagaagaucg\n", + "uaagucpucccagacacagaagugugaaucuccucugcaccacagccuggccuaguagcagauccapagacagcgaagaaauuagaaa\n", + "gacauuuucacgaacucgcuuccucacacacuggugcucuuccuacaggcpcaccugagagaggucapagaccagcgaacu\n", + "ggaguucgcguuacuuaaccaccauaaggugauuggcauauuuaaaaagcaucuagaucucaaaaaauuccuugagacaggagucugauugcucuuucagaguaucuauuggugaacauaaacucaau\n", + "gaauaacguugcagccucupagacuauucugugcagccuccgugaauucacccuccacauccccaccccaucccugaagcaccugaguuuaacuuacuuucuacauaagugaaaaaugcucaag\n", + "acugccacacuucgugcugaccagcgacupccggcgaccgguuccgccacucuccggcgagugcuccgugguupuggccgcggcggapaagccggugaucacaguucucagguccugacacc\n", + "cuugugguaaauuaaauaaaaacacuugcaucagcuuuccuguuuauccaacaauuucaacuuaucaccagguccaccaguugaaucuugauuuuuugaggaggauuuuuuacagaacuaaagaaggc\n", + "gaaguuuguagcaguuaauaaauucacucuacaagaaaaaaaccagcucuguguuguaaagucaaacagagucugcuauuuuucag\n", + "aacucugcapcaacuuccacucuucucugcaccgcagagaguuagcccacaaccuccupagaaguaucguacagucacuucguccacccuccggaggcucggugcuagcguccug\n", + "agaaguuaaauaaacauucaaggcgugauuaggauagaauagauccagcuuaggauuugugaagcugcuucauacapcuucuguuucupauauucacagaauuucagcuuuacucuguauucaa\n", + "ggaacugcaggaaauuuccaggcuacgcugguguuuuuaaaagaaaccaucccggucucuuuuacuuuugccugacugucaaaacacucuuauauaaaaacuuccugaggaggaaggag\n", + "ggaaaucaauggugacuaauauaaucuccgucuauuucaauaguguaguauuggaagcauuuauagaaccuucc\n", + "gcacuggauucuugaaacccagauagaaacacacgcuggccaccagugacuucauuuugagccccccuaccccaguuugaagcagauacgaagaaccuuccuggucaggauuccgcagugucuguacc\n", + "aaagcaggcuucuaccuuccaagaacgugacagcucucaugacagcucgcccuccuaacucaguuaaguuccugaaagaa\n", + "guggccggaggagaggcgcuccucgcuccggccuaaucuugcauccguuucagcccgagccugug\n", + "agauaauuguuuaaaauuggucuggaagaaguuuaaauuaacaaccugcuggaaauucuauuugacaguagauaaauuuaaaagccauuuag\n", + "gcaaaggagcagccgucggagcgagccggaagcgcaacgaccccaacacccapcgagucaggaggagcccgaggaaacuccccagaagaggacccucggagaagaaaacgccacaaccug\n", + "acggagccggagcgagaaggcaaauaagcggcgacggcgcaagagcgagaguugaaaaagacacacauccuaaaacccccaagcaggaggaggcagcggcagcgapcagucguaggcaguaggcag\n", + "gaacagcggagagcagaaagaccauaacuuucagcupugccagguguccgacggucuccugcacggccgccccaucuucaacgccacaaacucgguucaggagag\n", + "pagcacucagccpapuccucgcuuucgacagcccucpuccgucapuuccugcuccpcccguuucgcuugugagacucpagcguuaagugaagucugcggaucgccapcc\n", + "guggaaugapagagcagccuggcupcuuuucuaaccuucucccpacccgcgaucucggcucacaccagaccuuagugaagcccupcuagaccuacagaccucaggaucgcugucacu\n", + "puucuuauuaacaaagcagaacuccuuacgugcacacuaauguccucggaguccuggucccuggagacccacuuacgcuugugcpccagcuacagccuggaagcagccgugacacaagagacu\n", + "gcacccagcggaggaguccccagaagcuaggcgaagucggcaccucgacuucccagccgcugcugcaaaggcapcugcaagcggcggcucagcagagcccagccaagucccacgcggcggacacc\n", + "acucgccaaaacucagcaaaacccacggaggagucccuggaccuugagaacacacagcagaaaaccccacc\n", + "gccucgcgccgucccccgcucccucccuucagguggccgcugaagcccuuuugcacaggaguaagaauugauccugapaccpaaagucgcuucuccapacguguguuggacuacgaauccau\n", + "gauauugucuuucauaaacugcaagaauccagucccuaggauuuguacuugucaccagucag\n", + "gcggagcpcagcggagccgagcpacaggcaaggagagaggaggcacapacaacccuguagccgccuaggccccaagagaaacugcggapaaggagcagcgagagacccaggcucpaag\n", + "gaauuuggagauaagaaaggaccugcauaguuaaauccagucaaucacacaaaguagcagauaaauuuuaaaaaaaaccaguuucaaaucaaaa\n", + "gcugaaagacaggcacugcaacaagugcgugugaggagacgcuggcguggcauucccugaggaug\n", + "ggacagcccaaauccgcacuccggagcauagauaucugucaaaagucuagugugacccagcugaaggagcugaaauaaga\n", + "pcuguggcagcaacagcuggcugcugcaguagcucguuucuugccucagaaccucuuacccucccagaggugucuccgagagcgcuapuagucuuuupuuuuaaacgcucagcpuccc\n", + "agccuuaacuuccaagcgguccucgugcuguacuuaaggaggcugaaauugcaggcucguguguuupagcpcgccgcugguugcuguguuagugaacag\n", + "auugacaucuccucagguucuaccagaagcggcugagccuuuaaaccuugccuuccagcucaacauccuuccuucggaaucaggaaaccucuucagugcguggaguacuguggacccugcaccuggac\n", + "agugaugcuuaaaaucacacuaguaaggcuguggaggaaaaauaaagacuuaaauguuaaagcauugaaaagccagaaucugcacaagucapcuuuuaagaag\n", + "ccaguuaaaaacauucuccugaaauauccagupcuccacuaaaaucaaguuuaaaaauccggaggcuguucuguuugaguuggaugucaccauugagacuuaaagagccaaagaaggacccu\n", + "ggaauuuuuuaaaaaauuucccaacauuuuccccagguacugaaacaaugaucucagaacauaaagag\n", + "cagaaacaauugaauaagccugcaguguggcuaaacugauugaagcacauuguauccauuccccauucgaaaacagguauuggauugucucuuagcuggucuauagaauuuucaggauuuccuucaag\n", + "gucacuccgccugccuuccgcuugagaccggacauuggcuucpaccapugapccuccuucaauagacaggaucacuuccacagcguuuagcggacaccauugucuguuccgcuggcaaucu\n", + "uuauauugccuagauuugaaauaaaacacaaggccccaauuuggaggccccaacucuugaaacuuaaauuucaauucagauauugauaccagagacaguuupuuaagaauaacaaaggcaauaaug\n", + "auuugucacaguugaauuaauuuauugugaagaucuaauaaaauugucuaaauuuguauuauaauuag\n", + "guuccuggcuaaaagaaauuaaaagucugucauauugcuacugguaaaaaauugaauuaagaaaa\n", + "gagaaguuccucacacacuuuccacuggaaagccuucacccagucggucaccuggcaaacuuuucauc\n", + "gacaaaaccccaaccaaccaagcccucaaagcuccagacacaccaccgaaagaagcaacccagagucagaacccugaaaaggaaagaggaaagaagccaaagucccagacaucucaggagguaaagac\n", + "agugccuuucauccccgacacagucuugccucaccaacccuccucguuuggugcugcccauaaucuucggauucaucagagaagaagguuguggaguaagaagcagguggauucuacucapauucc\n", + "guaaggaauuaaggucaauuagaaguuugcugaauuaaauuaggacaacugaggacccucugagaagaaagcuauauccauaccuacuuaug\n", + "agaaaaacacacaaagagaaaaagauuccuuuaaccagucugaacugauacagcacccugaauauuccccggcuaaagag\n", + "agaagaaauuuaaagugaucucuuagagauauuucccuaaucaccaacacccguaggcuuuuuacaauccaguucag\n", + "gugcuucuaagacucggacaguggagccccuagaucccpccccauuaacuuuggacccuagcugcuccucuagcuuucagugugaucaaaguauucuuccagcccuagacuccaacucgugcc\n", + "uugaaacpaguuuggaggaugaagauuaucucapccucggcccagucagaaacuuuaagaa\n", + "auucggaggcuguaauuucgaggcuuuucaaccugcuccguccgcacucaggaacacacapugcucccauccgugaggacacagagagccagcuaccugauguguggacgcagaucaaag\n", + "gcugccguaggcugcpcugcugaggaggcgccagcuggcucuagcgcucccacguccgcaccc\n", + "gugcugugccacgcggaacucauuugagcaucaaapaguccagcacauugcuggacccguuuucaaaucacugcagucaauuuccauauucuaaaggaccuaccaaauucagcugaccccaaa\n", + "gaagaapcaagugacaacaaacacagucagccaaauucugaagcuguucucucaccuuucuacaacaucuuccagcugcacaggaaguuaauaaccgaggccupaacaaggaaccuggugagcc\n", + "agauggaacupagaaaauaaacuucaauuguuaagucccgagcugacaccaaaauacauggacuccagaagguggaaguggaauucuaagucaccugcuuuaguuagg\n", + "agaauaaacuaaupugacacaaacccuaccaaagcaucagaacuaaaaaacuggugguacccauccuuuaucaucaucgaagaucaaaauuuggaagauucugca\n", + "ggaaggcccagugcugcuaccugucagagcaccccuaaaaaaucauuagucuggcucacaagucugugcag\n", + "guccaaggcucacgucuuugccuagguuccugcuugaggaaapaccccaggaggauaaagauccacggccaccauacagcucccgaccagccapaugacgugugcuggcgagcucuuagcacag\n", + "uggccpcucguucuuuggaugcagccccggapugaguggcuucggaagagupagapcauuccuggcugau\n", + "gacacuccaguauucucacacucugacuacaucaccuccuacggcugguuucaguuggauaacag\n", + "auacgugccagaagcuccgcugugcuccgcaucuucuucuaguacaccccuaccuugucgccugccgcgguugcaggcgucgcaaucuccgcgcaguucgucug\n", + "ggcaguaaggaaagcacagaacccucacaccugcuuaaaaaagaccauuucuaaaggccgugugacauccucggugugcagucagcagccucagcuccuguggaguggauuggaaccuaaaccag\n", + "pcggagaggaggcpaaagcaaaggaagaaaagaaagaaggaaccgaacggaaccuagaguapaaacacccugcagaggagcapaagagaggaccupupcgagcpagcac\n", + "gaucaaauugcaauuacuacggaucuucaacucugaagaggcuaauaaaagcuaagguaaagcacgaaauggagcaaaaccaucuguuuguaaaguuagcuguccaagugcugucuacaacgguggcc\n", + "auuggcugccucaagcucgcucucagcucccggaacccagagugucgccaucccgaagcuccgcupcuuuuaaaaaucuguuucguuccuaaagucucagcgugccapaaaaacapcug\n", + "cagagcaaccaaacuccccuccagcccaucccagacaacagaagaaggagaaaagcucaagccgcccuaaacagaaacucccgagagaggaggaagcagcaggappcggaggucggcggcggcc\n", + "guauuucuuauuuuccccgagaagcaagcucugaauccggccaccauuuucauuaucacauauucaguuccacagapcucauuuacuggagaaaaaacauuuagagaguguuguugugugauggac\n", + "agaaguguggauccagcuccugccuuccagaacaccauaccugucccggaaapacuagugagcagcgcaaccuccaccuggagcupcuaggaggaggca\n", + "gcpaaggagagagguagagugcggcgcagucggcaguuucacuuaguuccupuucgcuccguucagcagaaccucgccaguggaagugacagucucacupcapcgccagaagagagacc\n", + "uccapacugagaguacaaccagcagaaucacuaagauuucucugcaggcucccpagcuccucucuucuagguapuugccagaauuuugaacaaaauuuaauacgagupuuguugagaacc\n", + "gagaauuugcacguugccagccgcapcucugcccgccuucugugacccucccgccccuucaacccacgacapagcccuagucccaaguuagugapcucaagcagugcugcacuu\n", + "accgaaaacacggaaucaccgcggcgagagaacaaagcagaagagacugaaaucgcagaaaccuucapagagcggcggacagagaaaapcugcagaggcpaggacggupaccccgaga\n", + "gcucauuuccuggccuaaccagucuguucagaauuauuucccugcagcggugucauuccacagacauuucaagauauaca\n", + "ggagcagcgagcagaggaggcuucaggugcagagagaagaggccacugccacgucgguccgguaggaacaggaaacccccgcagaggapaaacuapcacaguaggcacagcagagcccgcc\n", + "aggaccgcggcaacccaaagcagcaggcggaaaagaagcagaggcggcpaaagagaagcagagagccuauagagaagaaaaugaaapaggaaagagapcpcpapagaggaggca\n", + "gacacaaguuuauugcuggaacuccaccaacaaauuuuacucuaaauucaaaaccaaaagcuccuccapcccuguuuccgcauuupuguccaagccaauupagaaacaugaaaaucuuacuc\n", + "cgcgucgcuuccuccguuaggagcagcuggcpaggauuacauucuccacgaauugcgcgacgcaguucugugcuccuguaagcggcupaagcccugacccuaaaggcugguacucacucaagc\n", + "gguuuuuauucacpugaaaccuccagcugcauagaucuccaauccugaaggagagcugaagaaaucacaauuaggauaagaaaaauaacg\n", + "auuugagacgagcagcagcagcaguugcgcggcucgccaagcgcgagaucgcacccggacccgccgagcaaaaucacaggagccgcgcpcgagcgagaccgucggcgaccacgcagapuca\n", + "ccgcuuuuugucagaaagucauuucaccuuccaaauccaguagaaugcggaagaucccucuaaag\n", + "gcaagcaaccaccaaagccaaacccuagagacgaagucgccaagucgcagcgagcagcgagcaaaaaggcaacccuagaggaagagaggaggacagcaggaacccaggaaacagcggcggcagugacc\n", + "ggaggcagauucuuccugagugcuuccggucacgguugcacpucauucacuggucucacccaaacucauccacaguggacagccaguuucupaaguugaauuguupacu\n", + "acugagcaucagguapagagcagcauuucaacaaggcagcucuguuaauaaaacuuuacuuu\n", + "agagcccggcpuugcggaaacacugaguuugcacgcuugcugccagcccuucucaacaucaggcugcag\n", + "gagaaaccapaucaccuggaacggaaagauguuugaccugccacacaucccucccccagcccgcauaagapaacagaaguuguuuauucuggaacagcacccauuuggcccacgcgauuacc\n", + "ggcgugauupuggacacguuugcccgaaagauaucaaggacauuugucacuugcaaccuucacccaggaauuuccucupugaauggugugguucuccuugucucug\n", + "ggaagagcugucgagcuuguagugagugcaccauggugaaggaccacagaaaccuuuccgcagauugcagaaacgugcugcagaaggcc\n", + "auccagaaaaaagacugaucacaaaacccagagugcucaccuauuagaagccaacaccuuaccccuaacccagauaacuacuuuuacaauccugcaucaau\n", + "acgcgcauccugagagagagacccagagcgagauggagagaaccaagacccucagaaacccagcucacaaacacagcaagcgccgcccaapaaaagaagacgcaggcugaccgcggaggcagagcc\n", + "caggacacuapaagagapapaacuuagcgcgagcgguagcccgagcgaagcgacgcagagucaacaccccagaggaguguucuaaagcagccucacacugcgcug\n", + "uggccccuccgcccagccccagucucacgucagugagucucgagucgucggcgaccuccgcucggacugcggcucagucucuuggcuugaguacc\n", + "gaaaagagaggaggaggcagacagagaaaaaagaggagagaaaagagacaagagaaaaaacagauuccagaaacagcaaaaggagaaauaagagaaaaaaagaaaccacuagaagappagcc\n", + "acaugacugcagcagcucauuauuucagaacaaaaagaaauauguuagacacaguuucuauuguccuuggaguuuuauauuuugaaauguuguuccaaaauucucuacuaaug\n", + "gacagcgccuggaaaaagaggagaaaaaagccaagucccccgaacaagaaucacccaacacacaaccgaguccaacaacacagcucccacccuccgca\n", + "agucugaggacagugucugcccucucacuccucugcuuccapcgaggacaggacagcuuccuaggugcaccuucaaaa\n", + "gugcagagcauuuacugaagaaaaauaaaaauuccuuauuucuagagccuguagaccucaugaagucuacaauuccacuaauuccagucuuuuacaauuaccacacu\n", + "gcauuaacaccgaagaagcuucuccacacacuccagccuccaccugcacccagcacauucugaauaggaaaacgcacucucguugguacugccucagcugagugguc\n", + "guccaagccaacauagaaagccuaccaaaaacuccucgucucccuguaucgaaaapcagcucccguucuucaucuccggagauguugccuucucaacaucuuccugaacuuucucaaucuccaacc\n", + "gauuuucuuggccgagagcaaauucuucaaagaagaagguucuccagccaapuaaccaacagacaggcu\n", + "gaaaagagacagccaacucuccaaggucgauccagcupuucacuacacuugcugcugacuucauucagguugccuaacccaagaacugcaaagcaacugcaccucacacucccacugucaaugcac\n", + "gacacagcaauuugacuguagcuucuacuacaucccagcucagucguuaaaaaaucuugaggaua\n", + "ggacccgagaagaagacaguacuucaauaaaacauauuuccuucagcuggacugagcaaaagagaguggagguaagaagugaacucccuacuccaaagauucagugcgug\n", + "cacugcuggcagcgugaucaaagagagagaauucuugcagagugaguuggcuuuaaggaagcauacggaauugcuucuugucuuacag\n", + "auuuauagccpaccugacaacauaccuagguaccacacaaauaaguucuccuccccagaaccaacccag\n", + "gcauugaguaaguaccguugcaguucgacacacuccaguaccacccuguuccagcucuuucaacaucagcaguaapaaacucauccacag\n", + "acuucgucagucuccacuucacgcugccgcgcaccucccucgcuuucuuuugccggcuucagaaaaucguucugagc\n", + "gaagucuccuguauuaccucauccaauucaaggcagaucaaaguucacacaguuupaagcucugaauuuuggaugcugaaagaaaaaccaggaggagacaacaguuuaggcauaguguuuuucuua\n", + "caaaaaagaaaaacauuuggcagagguuaaaaaaaacuucuucaaucacacauaauuuaaaaauacgaaaaucuccaagcagagac\n", + "paauaggaauaaaaacuccupccagguuuguguacauaaggaaaaggapucucaggaauccuucaaagugaacuggaag\n", + "uuggacaccuacaauuccagcuggcuuaaaaaucucaccuuccuggccacagauaauugcaacacaaacaagcauaaaaa\n", + "cgucccggauccgacgaacuccgaggcgcgacccgugcacugagccccacagagccugccgagcucucagcguguguggaaguguucguuggagcucaucaaacacaacuaggugguuguuuuugauc\n", + "ucccggcauugucucaucuagccagcccccaaacucagugcugaggaagccucccagagcugcuuaupaccg\n", + "gaauugaccugucccgacauccagagcuccaggaggcucccugcagccucuccugagacucuuugcucaaaaucccacgucccugcugagupcggagugugaauagauccacagccaaggauacag\n", + "guucaagcccagugacaguuucugcggaaggaaugcucaccauuccccgucupaaguaccaag\n", + "aaaggcgcagagacagaagaacuagcaagaaaagaaaaaaaaagaaacaccaagccagcaaaaaccccuacacagaggaagaagaaagaaaaaggaagaagaaaaapaggu\n", + "pagguagccgagcacauuuuucaaaccgcgcacaucacgccgaccccugccaccggcacccccucacgcccagccccccucacccauccccagacacuucaggaagaggaaaaagcccgaagaacg\n", + "gcuuggaaggaaauacugcuacaaaccauacccauaauaaaaauuccacguaucuuguguugaauccucuaaaaaacaag\n", + "ggagcauuuggagugucuacaaaaaccagcccaguuuuucuuccacaaccugugauccagacaggauggcuguuaagccacacccuaccaggagugugaguguagauuggagccaccuuguguuucaa\n", + "cagacaaagucugcgcugugacaguuaggucagcuacacaucaaaaccaguguccccagaagaaaaaaagcaag\n", + "aaaagagccgaggccgcagcacccuucccgagccaagcccgacgcacccacccuccagcaaaccccccggaacgauccuagacccaaccccuccgccaccgaaagcgcagcagcaaccgccgaaaaag\n", + "ugauaagcuucaccaagcgcucagugcugcupcucacaagcagcacuagagauaccuaagguaucacuaggccagccgguugcaacgcaaggccuggcucuguuugaagaaaucaggagugcagcc\n", + "aguuaccuucgucccccauucucugcuguugaagaaguuagauccuugcggugcuuccugauaacaaggaggccgag\n", + "gaggcuucuuuacuuccaacucuucccucguguuccugaggaagccguacacguguaggaaacccagccagaaaauuacagacucaguu\n", + "ccugcacugcuacugaaauaauagcaacaauuuguuguuucagaauuuaaaagaaaguauaucugcuauucaggaaaggaaguuaauguuagauuucuagauuuacagaauuuugauuuacccag\n", + "cacacuuucccuaucucccaaacupaaucccaagguuaaggauuagaaggaggcuguucccapagcagcucuugacuggagaaaauccgaggaaaaacagaaaaaaccucugagcaucaaaug\n", + "paagaacuacccacagauucuggugugaaaacagugcggcpcuucuuuucacaacgcggaagcugcaaauucuupacacuugugugcuccaagauuuucacaaguauagacacaucuau\n", + "pacuuccgccacgucccugcagugcapaaggaugaggaagcgapaggaaaaacaacagagaacaagacpaugagagcaagugacuuuucgucuacccagcacaauuaccaccgcgcucgc\n", + "ucacuugcggccgucgcgacuugcagugcagaucgcguguaaagaaaaaaaaguuaggcugcacuggugacagugaagag\n", + "gcggaggaaacaucacacaaauccgcaggaagaaagaaaaagaagacccuagaagaaauaaagaggaaggaggaaaaaaaaagapaaaggacagcagagagaggcacgagccccupcgugcuc\n", + "uugcauccaggacacgaauuugcagaaggaagaugucuaaaaauucccagapcucggaucuugcaccgaguuuuccapccguggaaaacgcgucggaaguuggcagcccucccagcucagaccc\n", + "pacgcuugucucuuacacacgaccpuccgccgccagcuuuaaacugccucuauaggacccuaccaccuggaacagauauuguaagag\n", + "gagaaaagucaaagcuuuauuuuaaaaucuccuaguuacagccaucagucccgcauccccaaauacuuccacugcucuauuguuccuggaagauuacaggauuuguauuuugcuaucuuguguucgag\n", + "gcucggcccaagcacacuccaccccgcacaagucccaaccccccacccuccagcucgagcccucgccccgcaaacgacagcgcacaaggcaaggagaaaaagagacagcggcucccacccgucugaac\n", + "gauaaacaaaagugagcacugcagacuuucaagcagccacacugcaucacaagaaagccauucaguuaaaaaaggaacucaccaaucuucagaaggccuauagg\n", + "gaucaggucugagaggaagcagaggauaauaucaacacuupcaccccuaaccaacagcagccuccaacagccccgaga\n", + "agugaaagcuuguccuacucaacgauuccccaaauuuccacacugaaagaaauucccucaacuucuccgacucuaagcagacacauucugagcucacuuggaggaaaagcuaccagauaaaaaaaaag\n", + "ucucuccucugcgaccgacgapcucgcgucguaagcagaauuuacaaaaccuuaaaaacuccagccagagagc\n", + "auugccauuacaaacauuuccuuaaggacguguucaaacacuucgaccauuauaauuggcaaauagaaagacccucaaugaagucacugcccaggaguuccacgguguguuauugcaggccacggaag\n", + "ggacaccucuauuaucaaaccggaagcuccuggucuuccucuugagaupaaacacagaauugca\n", + "ggaguuugugcucgcuccacaccagcuuuaaaaacacccuuuuccgcagcaacgac\n", + "agaaacaacaaaggaagaaggagagaggacagaaaggaggappagaagaggaagagaggaacugaacauagaaaacagucapcaggaapaaaggapuccaagcagaagcggcggcagc\n", + "ggacapagcgaaaguuuuccaaaggcuugaggucgcugcaggugaaguggaacaccaaccaccaag\n", + "aaguuucaauuaggcaucacugcacapaacuuaacccaaccaacaacuuccaccucugaagaaccuaucaggugauuuuaaggcuacugagagguauccaaccuaacacauaaaaguccagacag\n", + "gguccugcuccuuggaggaucagcuccuccuguauccaccaagugguggucacugagucuguuccggucgaaggccacpaccuccugccacccacagauauucuguccaaa\n", + "guauucagaggcgagugugacgacucguucuguccucuguggcugugcugcuggagucuuccguccucgcgucaguuccaguuuaaaaucugugaaaacugagaacg\n", + "gugagcguuaacucgacuaacuggcucuaagucuucuccuggaggagcugcuacucaca\n", + "acguucuggagucuaagagaaagcuuuuugcaacccuucucugaagagcugaucagaagaaaagaaua\n", + "agaccacggagaagcucaagaagcuuuuacauccuccgcgccugagaucgcccgccguccggagugcc\n", + "agagauuaccuuuacauacuuccucagaccccggagauacuauuaaaaccucagauuuggagccugaaaaauugcagaauuuacacagacaguuugguaaaagacccapugguucuguagugagc\n", + "guccaacupagcccagaggapcggcgguguucgcccgugucccagccgcccgugcacapagugugcgugucucaacccacgaguacuaggcccaggaacuccuacuuggucpcaag\n", + "gaaaggaacacuuuccuggaaaagguuaccaccaacaucucuugccacacaaucuagauccccagucacaggaagugcuucagaccacaaaa\n", + "cucuccugcuaccuccpaccuuuuuuaaaaacuguuuguugcugaaggagaaaauacucucaccccucguggacugaggagcgucgccuuucagua\n", + "gguccucuacauagcaccaucaaaagcuuucuguacggagaccuagagaaaacuauuacccuacaaua\n", + "agagcugucaaaaacucgaggaggucggagcugucpuuupuacagcgagapacuugcgaguuuugagupaaaaccucupaaauccugguguuuugauggaaaag\n", + "guuaaacaguggcugccgguaguucaagcuaacacuccuguagcuagcaggaaccuaaaagugaacgagcuugaccaagcaaaacgagugaaaaa\n", + "guugcauuuugaagauacaacuucuggaaagaccaggcauaaccagcaccaucaguagccapaagaagucpccucgaacugccaguaacugcuacaucuuguaacuuuauaaaa\n", + "auucauuauucuauacugacauuugcucuuuuauacacagcaaaguauuuucaaaaaguuucauuucacauuuuuuacaaaaaauucuucaaacaaaagag\n", + "gaaugacacuggauacaguagccaauaucacuacacuaaggagauuucpagaagaauucacacuuuucucaggugaucaggaaauuggaauuuguaauacuggaaaagcuuuucagagaaauuacu\n", + "ucccggcaucgcuucuggcagcuucgccacugacauucucuuaccuucgguacccaacauuacauaaccugcagccaaug\n", + "cacccacacgaaaaacacaaaaucaccaccaccaauacagccgcaaucgcaacagacaucacagccacagagccagaggaaacacaguagcaggagaaggacagcggcggcugagcggcggagcgacc\n", + "auucacuauacuggaguggcaguggaaaagupaacaccaggagaaagugagcucucaggcuauacaccuauccugugguuucugaguuugaaa\n", + "ccucggcgagaaccacacccagacggagucacggccuccgcggcgaacgucgcagacggcacagcagagcugagcgcgugcaggaaaagcugagagcg\n", + "gugagcacucucgguacagugupcccacagcggcaggugcucguggcucuuucauccccgcaacugagcucc\n", + "gaauucugaagucgcagccuccccaaaauuuccccgcggcuuucacucagccuaagauuuccccaucccagacuccaaacaagacacauaagcccagagcuccucaagagaacaugaauccacuaacc\n", + "gugccapaggagagcaccagacuuacacaaucuagcauucucacccapcagaagcuacagg\n", + "agugccuaacauuuccucucccaggccgccucaacccucgcacuagucacaaccucgaagcccac\n", + "ggagacugugaaaaauauucucuccagcuccaaaguucaaaaaaauuagcccuuguucacaacaucuuaggagc\n", + "starting optimus\n", + "aauuccguuuucaagagagaguuauuagagagauucguuuucupcc\n", + "uuggagauauuacgcuguaauucggaaccugaauugacuagauagauauu\n", + "uuggagauacaaacuucgauuccguuguacuuaccaagagaauucguguc\n", + "cccguuuuuauacuauacuuggagaaaacuuaucuaccauaauuauugcu\n", + "ucgagauuccguauucuauuccguauccuaaacguucauauagcauugua\n", + "gagagaagcguauuuccgaauucguauucagagaaaaacgaaapcc\n", + "gagagaguuuuuauccggaucuuuucagaguauaucuuggacgaaguguu\n", + "cccugaauaaucauauagacuaagaauccgauuaacccuuuuacuuugcu\n", + "uuggauuccgauuuauagcguauuuggagagagaacuggagauuapcc\n", + "ccgcguuuucaaauccgauucaagaauccguuuucuauuaccugaauacu\n", + "agugagagaauggagauccuaagguucaaaaggaagacagaaauggcugg\n", + "auauagcuuaucucgcggagaagagagcguuaucuaguaauagaauugua\n", + "uagagucaaucgagauacacacagaguguagaaagaguauaaapcc\n", + "uuggagauauuggagagagaauuaaucguuuuaaggaccugagcuacguu\n", + "cccguauauauucagagaaucggagaaaaaucgauaaccuaacuauugcu\n", + "uupaucccuauacaaggagagagaaguaucguuccuuuucapcc\n", + "ccguuauugcggauauauucgguuucauuuccagaaccauaacgauugcu\n", + "gagagagagaguacuuagauuacuuucguaccuaucucuucugcuuugcu\n", + "uaauucguuuuuuauccgcauacauacauuucgaacuaagaaucpcc\n", + "uagagaguauuacaauaauucgaauccguaaaccacaacuagaaagagua\n", + "gcagaauccguuuuauauuucgagcacuuaucauuauuauuauapcc\n", + "aauugagaggauauucggauuauucugcauuggauuuacacaucauugcu\n", + "ccgguuauauuaucaagaaaacuuuguccuucgcuaguguagacauugcu\n", + "auugcguagcuuauacucagagaaucgguaacaaaagacuaagaauugcu\n", + "ggcapuucccgagaugagugugcgugagcpagaacaugcugagcu\n", + "auugaguagaaguauugagauagauuagagaguauuaacuaagaauugcu\n", + "auuggagaucagaguuuccgaguagagagauuagaaaaacgappcc\n", + "uuggagaaacguuauuaggauauucggaguaucguguagagagcauugua\n", + "gaguuaaacagagaaucguauccaaagucguuuuuuacuuauacuuugcu\n", + "uuggaucccggaauauaauagagagaaagagaauccugauaaapcc\n", + "gagagaguuucuuggagaguguuguuuucaagaauccgauuacaccuguu\n", + "ggaguuuggagagaauccgauacaaguuuauccaagcaucucgauucguu\n", + "uuggauuacccgaauuccuaguuaucuucacaccuuccgugauuucugcu\n", + "cuucaugagugcaugcaggcccacacuguucccpugaauggcugagca\n", + "uuggagagagaaucgaauuggacuaauccuuuuuacuugacguaauugua\n", + "ggaaucagagagaacuagagaauccgaagacuaguaaacugagcaacguu\n", + "gcagaauccgauuuauagaguccaaacguaaauucggaaacguaapcc\n", + "gcgaggagccucuggaccugcupccgcaupcccgccuccuuccuu\n", + "ggagagagauuccgaguaucaauccacuuaccucaccuguaauuauugcu\n", + "guggaguagaagaauucggagagauuucpagaaucguuaggaaucguu\n", + "uauugcguuuucaaucagaguuccuuaccguuacaauugcpuapcc\n", + "uuggagagaaaaucuugagagagaggagagaguauauccuagauagaguu\n", + "auagagagauacuagagaguuuuccaaguuuggagcauacuuaucucguu\n", + "uuccgguuauauuaguagaaguuucaaguuuaucacucauaagcauugua\n", + "uucuagccuuauucagagcguuuagaguuuacuucguccugaucauugua\n", + "uaaucccguuucauaucagaucccuuuacacaaccacgauaauuauugcu\n", + "uuggagauauucacacagcacuaguagaagacuacuauaccaapcc\n", + "uaguuucccguuauauaauucaagugucuaagucauccuuaaagapcc\n", + "gcagauaccuagaagaguuauauauugcguuuccugucauaauuauugcu\n", + "cacggagagaaucaaucuucccuaucuaccgaaguucaauaacgaacguu\n", + "gagagagaguuacuuguucuucauuaccuaaaccgugugugaguapcc\n", + "cccgauuucugauagaguagagagauuaguagagaaucgugaacaauaca\n", + "uagcuuguuuuauauauuccguauucgcauccauuggacuaaaapcc\n", + "uuggagagaaucuuauuccgaguuuauccguuuucuucuacagauuugcu\n", + "auuupaucagaaucgugugucuacgaauccguuuucupaaacguu\n", + "gagagaguuuuuauauuggagaaguuucuuccuauacgcuaaapcc\n", + "cggagagaaaacaaaucuucggauucguugaccuauuagagaguauugcu\n", + "ccggauauacguuuucuauaguguagaauaccuaguccguaaucuuggau\n", + "ccgguauuacaauucagaucccuaaccguauugagagagugappcc\n", + "aggaaucccggagaaucagaguuacggagauuaaaauaacaaapcc\n", + "uugguuacccuuuuaucccguauacacucguuuuauuccuuagcuuugcu\n", + "uagaauccguuggaauagaagagagaguuucacuuaccuuauucauugcu\n", + "ggaggagagaguugauaaauaucgaacguuauaaccuuuuucppcc\n", + "ucggagagagaauucuuacccuauuuggaggauuaucguguagcggagaa\n", + "guuuaggcgauacuacuacuauuccguuuuaucucgcuaucccaauugua\n", + "gagagaggauuauuacguuucggaaaaguaaauuagagagauuaaguguu\n", + "ucggauccuuagcagagaauccuaucuucgcugucguuacguuaauugcu\n", + "guuugaggugcagacgguggugaaugaugcuguuccgaaggupaaucg\n", + "aacgcggauuuauauacuucguuaccuguuauaucaagagaaucpuu\n", + "ucggauauacggagauuccgaguuucgguagaagaauccugaccaaggcu\n", + "uuggagauacauuaauagagaauccuucguuaucucuuacgagauacaga\n", + "uuggauacuugagaaaaguaucuaucggauaucaaauucugappcc\n", + "cccguagcguagaagaaguguuuacccuuuuuaucuucuaggacuagaaa\n", + "ugguccguuucaauacggagucgaauagacuagucucauuaaapcc\n", + "uuggaggauauauauupagaauuguaguagauuaguaaacccuaaaua\n", + "auuagcuaagagaauccgauuacuaaaaauccguggauacaagagaaguu\n", + "guggauuagaauuggagagaaucgagauucuuuuuauauucucpcc\n", + "ccggauuuauauauauuccguagauugagagauuuuaacuaguuucugcu\n", + "aauucgcaguaaaaaaagaauccugaacuagaagaacuaguaacuaggaa\n", + "uuggaguuacaagaauuccuuguagaaguaguaguagagagagaauugua\n", + "auuccguucuuggauuaauagaguaacauaacuaacuaagugacuaggaa\n", + "uuggagucguuauaauuggagaaguuauauaucgaagcguagcagauauu\n", + "ccgguuuuuauauuccguauauucgguaucaaaccagaauucuapcc\n", + "aagcguuauauacuuaucccugaucagagauuuaauagagagacuuggau\n", + "gagagagaggagaaauucagagaaucguuuucuaucuccuaaaapcc\n", + "uaaacguuauucgagaggaagagagucguaauaaaauaauuaucpcc\n", + "aggagaaccuuauucagaguucagagucuaauagaauccugagcauugua\n", + "acuugguuacagagaauauaaguuugccuagcaaaucuuccaaauccgau\n", + "uagagaguuuaaaaaauccuuuuucuucucgagucucuguaaauaacguu\n", + "cccuaauccguuuucugagagaauucgcguauauuccgauaagaauugcu\n", + "ucccuuggaagaguuacacguagcaaggagagauucagacgugaauugcu\n", + "aauccguuguaaacaaagagagaacuagaauuaaucuggagaguauugcu\n", + "uaauagagagaauaacaaagagacgaaguaguagaguauauucagugaua\n", + "uaaauccguggauacuagagagaauucgguuuacagaacugaucapcc\n", + "uauugagagagaaucuagagaacuaguguaucuaauccguaaucpcc\n", + "gagagaauucguuuugcggagauauuccguuuaauagacuaagcauugua\n", + "gagugauuuguuaucuauuacaagcauuuucagucuuaaagauuagacuc\n", + "uuggaguucauauacuucguauuacacacaccuauaccuuaaapcc\n", + "gagagaauuccuuauucgaaagaacguuguaucaaacggagauuapcc\n", + "uagagaguuuauuacuagagagaauccguaaccaaaagagaagaggagcc\n", + "uagaauccuuuauuggagagauuagaagaauuagaacgauaaucpcc\n", + "uagaguuccgauauucgaguuauacuupuuuacaaauucgaauuugcu\n", + "uagaguuccguuuccaagaacguuaucuaccaaucuucgcaucaauugcu\n", + "auaaaagaauuuaauaaaucguaguaaucgagaucuuuacuauauucgcu\n", + "gagagagaguucaaaucagaaucuagauuauacaucguuagaaucgugac\n", + "uuggauuccuuuucgaguuuauccaauccguuacaaaaauaacuauugua\n", + "uaucgguuaucauaauucgaaucgcagauucgagauaccuaacgapcc\n", + "uupauuucaaacucggagagaauucgguauaucauuauaauuauugcu\n", + "uagagucuguuauucagagagagauuaguaagagagaguuaauapcc\n", + "gagagagaguaucagagaauaccaaaaguaucuaccuuaucaapcc\n", + "acgugaauuaccgacggaagagagaguuuucgagcuucauaucacgaacu\n", + "gagagagaauuauuauuggauuaguaguugaacuagagagaccuagugua\n", + "guauagcguauucaagcguuuaucucgcguuguuuauuacgaguauugcu\n", + "gagagaaucugagaaaguauuagaaccuuuuuuuauuuccacacugagaa\n", + "ggaaucauucgcauuuaccuuguagagaauuugauaaccuaaaapcc\n", + "uuuaauucpauccaaacuuauauuggagagcgaacuaacuuagauacu\n", + "guccuguagagagaauauuacgagaguguaauaaguauauaaapcc\n", + "uaauuucguuuauaguagaguagagagaguguagauaaauaacuaagaga\n", + "uaaucuugucccuuauucgagcacuuaucauacuugaccuagaauuugcu\n", + "uuggauacuuuuauucgaagagaauccuuaguagaguuacugauagaguu\n", + "uuggagauccagaaaaaauucgauuugcguuuucaauccuaggacguaga\n", + "uuggaguuuccgaauugagagaguuuccuaacaaacgcuuaaccauuguu\n", + "cccguuuuucaagaguaaauccuuggacuagagauuuaguaagcuuugcu\n", + "gagagaacauaaacuucgagauauucggaguuaauaaccuaauuauugcu\n", + "gagcugcugcaauugaggcaggugaaauguauggacaggcuauggaacuc\n", + "auuggagagaacaaagcuuuacgaguuauacaaccgugauugauaaaaga\n", + "uuuaucccuuuacaauuguggaauuuauuagaaagcuuuuaacpcc\n", + "uaguuugucauaguuuaguuucgagaguuauuuuauuucgauuaguuguu\n", + "uacugugguggaauuccagcacccuggaupuuuugaugacaaugaaug\n", + "aauuggagagagauuacuuuaucauauuacccaaaacacugappcc\n", + "uauuggagagaauuucgagaagauauuucguuacaauuaucgupcc\n", + "uauaauccuuuucaauagaauccuuaguaauagaaguccugauuapcc\n", + "uaauccguuuuucuaguauagcuauuuucauucccaguuuccacauuauu\n", + "ccguuauuacaguggagaagaguauauacaauccaagaguaguapcc\n", + "uaauucguuuuuuuacucagagaauccgaagaagaauucuaappcc\n", + "uauupagaaauauaucuggagauuupaucaauccugagcauugua\n", + "uuuuaauugauuuuacauuugcuaaaagaugaugaugcguuaacuguuuu\n", + "agaaaugauaguuucgguucuucagauggcugguaucgcugcacgugcag\n", + "cccguuuaaguauuuggagagaguguaguuuucgaguauacguapcc\n", + "upauccacaguaaacuggaguuuaacguagaacuggaaauccgaguu\n", + "uupauuccgauuucaaguauucagaguacaguccuaacaaagapcc\n", + "aggagaacuuagaguauauuggagaguguaguaguaaaagaaucpcc\n", + "uuccgguaaaaauacuucuguaguagauuaccuaagucguaacuaauauu\n", + "gagagaaggaaaucucguuuucuacaaguauauucgagcuaagaauugua\n", + "uaggaguccauuacuacagagaauucguuaauaguuuagcpuapcc\n", + "cccuuuauccagagaaaaguguuauuuaucgacgaaucgugaacuuugcu\n", + "ccggagauauauccgaaauuauuacgaagagaacaaagagappcc\n", + "uaaucuuggaggauauugauugaguaguuaguaaucccugaacuauugau\n", + "uauugcgguuauacaagaggagauaguuuaguaacuagaggaccuagaua\n", + "uugcucaucguuauauaaaaacuuugcggauccuugaacuaagcauugua\n", + "auauaguugguuauccaguaucaagcguauacuuuaccauaaapcc\n", + "cccuuuucaggagaauacagagauaauaauaaauuagacuaacaapcc\n", + "auugucgaggaucacugauacacguauccauauuaccuuggauaaauaau\n", + "uagagaauccguuuuacuuuacugcgcuuccuauuaucuuauucauugcu\n", + "ucccuaucgaguuuauaauccuuuucaauuuacgagagcuaaguauugcu\n", + "auugcgguuuuacaaauacgaagagaggagagauucuauuppcc\n", + "uauuagcuuggagaauuauucguuugguuauuggaguacuaagaauugua\n", + "ggauaauucgguuuucguugugcugaaauacugacuagaacucguaaauu\n", + "gcgcccgugagaugcgcgcggcgcgcgcgcgagcggccggaggcccup\n", + "ggagagaguuucaauuccguuuacuuaccucgcuugacguagaauuugcu\n", + "gaaauuuacaaacuacaagaguguccagcgcuuucuaagugacauaaguc\n", + "uuggagauccguauucaguuauucgucuuaaguaucuucuaagcuuugcu\n", + "uaaacguuugcaaacugauauacuuugcaucaagaauccugagcuuugcu\n", + "ccggaauuccggauauagucguuaacggagagagagauuuaguapcc\n", + "uccgcggaauucaagagcacuaguagagaguguagaaagaguacauugua\n", + "cggaggauauuauagagagaacuuuauccuacaaaucacauauapcc\n", + "aaauagagagcguuuccaaguucauacgcuaacgugaauugugcuagaua\n", + "uuggaaucccguauuacguauauucagucgauauccgauuaappcc\n", + "aauucggauccgauauaaacuucguauccuucgcguucauaaapcc\n", + "uuggaucacugcgaauucuagagagaguugauaaauucguagaauuugcu\n", + "auagagaguuaaauucgaauucagauccgaagcguaaacugagaacuguu\n", + "uuggagagaauuauacuucgaguaucaagagagcguucguaaucpcc\n", + "cccguauaaaacuuauucugcgaagucguaauaauaagagaacaapcc\n", + "acugauccuuggagaaucaauccguuacaaguaucuuggapuapcc\n", + "uagagagucaaagagaauauaccuuugcgguuaucauuauuppcc\n", + "gagagagagaguuggaauucggaaucguugaacuaauuacgaguauugcu\n", + "ggagagagagaauacuuuauacacaaagcaucgcagauacgaapcc\n", + "uugguuuggagauuuacaaagucguauuaccaaucgccauaagaauugcu\n", + "uuggagagaguaucaauucguaucgagucguuaucaagagcaaauucguu\n", + "ggauaauucgguuacaaagagaauuacguuauauaauuaappcc\n", + "gagaggauuuucgcauccaauuaauaguuuuuccugaccuaaacuuugcu\n", + "aaauuccgguuauauacuuggaguauuucuauauuccgauaagaauugua\n", + "aauupagaauuaguagaguuccuuauucgaauuaucuuuauaucgaga\n", + "uuggagauauuguauuaguagagaacuaguaguucauuaguagguagaga\n", + "aagauguupagaguuguggaugauaggaagguuacaugcaacucugcu\n", + "auuggagaauacuaguagauacacggauaccuaauagacuaagcauugua\n", + "auuggagagaaaacuuggagaguguuuuuaaucguuauauccapcc\n", + "ugcuaguucagucuupagacgagugaacuaagagaaaappcc\n", + "aauccggauauauaguagaguaguuuacucauacgugaaauagagcguaa\n", + "gagaggagagaaucuuggauauucguucuuucuuauccgcugcauacgga\n", + "gagagaggauuuauaucgcgaagagagcuaauagucuuaucaapcc\n", + "auuggagaguuuauuugaguguuuaggcaaauaacgugaacugagucuaa\n", + "acggagagauucaagagaauuccgagaagagagaaaaagaacuaaguguu\n", + "uugagagaguauuguguauuucagagcguuauacaauugcggacaggaua\n", + "auauaguupaaaauacuuguuguccuuuccauuccggauacuuugcu\n", + "uuggaguucuagaggaguagauagauuaguagaauccgcauuccuuugga\n", + "aguaauuguuuucccuuucgugaacuuuguguaccugaauuucaauuacu\n", + "cccguuaauagagagaaagaguuuuuauacgagcuuauauaaucpcc\n", + "gagagagucguaucaaaggauuguuuaagagaaucgcagauauaauugcu\n", + "uuggagagauuauacacggagagauuacuuucacugacgugacgaauacu\n", + "gagagaguuuuuacaaguuuccggaauccggaaaaaaucuggacugcauu\n", + "gaaaucgagagagagagagagaguugauaacgaucacuguaagaauugua\n", + "uagguauugguuucaaguuacagagagacguuauuagcgaacggaauacu\n", + "cccguagcguaaaacuugguuuuucaagagaagacuaaaacuacuaaaua\n", + "cccuuauupauuacgagagauucggagagaaccuuuuccapcc\n", + "auugcgguuuuaucaaaggagagaguaguagauucauuaguappcc\n", + "ucggaucccugagagagaggauauuacaaaucguacugauaappcc\n", + "uagaguuuucauugccgaguuuuaauaaguugcuaucuacuaapcc\n", + "gagagaggauaucagauauuguggagagacguaguagacuaagaguugcu\n", + "uagcuuccgaaaacuucaaggagagaaguauucgaaaaagaguupcc\n", + "acuuggagaaaaucauucaacuaguaguuaacuaauccgaaacguaagau\n", + "apaauccugagaauucugugauaguuaucucuucaucccugaucgaaa\n", + "uauuggagagagauuuaguaaucgaacgaucacuuaccguaauuauugcu\n", + "cccguuauuuggaaagagagaguagagagaguaguccuauuacapcc\n", + "uagagcguuuuacaaacuacaaauuaucuucuccuuugacpuapcc\n", + "uuggagauuucgaauugauagaguaauuuagaguguagacgaauuagaaa\n", + "cccauaucuuaauuccgaauucguugucaauuucaguucuugugapcc\n", + "uccugaucaaaguuucuuauccggaucccuauacuacaauuauuauugcu\n", + "acugauccagaaaacuaacgugaacguuuguauuugauagcuaauacauu\n", + "guuucaugaacaaaagaaauuguauucacugaccagaugcaupcagg\n", + "uuggagaaacagaggagagaguuucguucacuaguaaacuagupcc\n", + "uaauucguuuucaauucguuauugagagaguguuuaagagaauauucguu\n", + "uucguacccuaagacaaaucguguuuacgagaacaaagagaauuauugcu\n", + "uauugaauucggauucagaguauauuuaccuuuacccauuaacuaacguu\n", + "guggauuuauaaagaaguugagagaauuuaauaauccuucuacuagugua\n", + "cccguauucaguuucacucguagaauucuauauucuaauuaagugacuaa\n", + "aggauauagcuuauauucauuuaguagcuagagaguacuuagucgauauu\n", + "aggaaccuuuacuaguagagaauccuagucuguagugauugaccuagaua\n", + "uuggaaacguuaucaagagcguuauuuuacuaucaacccuaaccaauacu\n", + "ugucccggagcuuuagaaucggauucgauaaccuaccaauaaapcc\n", + "ccgguuauacgaagagcucauuuaagagagagcguaaacuaguaccuguu\n", + "uaauccguuuuuauucacucaguuauaccuuaucuucuauaaapcc\n", + "gagagcguuuuuacacguaucaauccgaagaguauacgcuaagaauugua\n", + "uguucgagucugcccaauauggagcuaauucaacucugaagaugaacugc\n", + "guggauuagcagagagagauuuaguaagagagaacuagaggaccuaggau\n", + "gagauaugauauuuauguuguccucuguuucacuauucucucugcaugag\n", + "gagagaauucagaguuggaaaguauuuuaucacccguauuuaapcc\n", + "cccuuuugucaaguauaucucguuucgaagcuuucgacguaaaapcc\n", + "gagagagucgauuauccguuuaucuucccguauuuagcugcuaauccauu\n", + "uagaacuugcguuauuaagagaguuccuuuccacuacuucuacuauugcu\n", + "gagacguagagaauaccgcagaaucauacacuaguaacauaaapcc\n", + "cccugauccgauaucaaucucguuccuacaagaaaagagcuagauucgcu\n", + "guguagagcaucucuuggauucgaggagaguuuuaccugcgaagauuguc\n", + "cccguauuccguauauaguaaguggagagaguauauacgagaguauugcu\n", + "auugauuupaacuaguagagagauuaguagagagaggauuuaaguguu\n", + "auucgcuuggagauauagagagaauuaguaguagagaccuaagcauugua\n", + "agaggauuagaauaguggagagaauccguaauccuuuuucuuppcc\n", + "cggaagaauccgaauuuuauauucagagaguuacaauuguppcc\n", + "cccggauuuuauauuauuuccuugcagcguauaccagcgugauuapcc\n", + "uauuggagagcauuuacuaagaagaguaguaacugucuagcagauuugcu\n", + "ugucaaaagucuuggacacacauuuacgcgagcguaaaacaappcc\n", + "uagagaguuuuagaguagauucggauucgauuucaagagcgagauuugcu\n", + "guggauuagagauuucaaguugcuuuagaggauuauuuaggagauuugcu\n", + "cccuuacccaguuccuaaauucauuuaucgcgaaaacuauucucauugcu\n", + "ccggaauuucgaguauauuucguuuccguuauaucuuaccuagauuugcu\n", + "uuggagaucaauucauacuaacuaaccuuuuuaagagaacuaguagcgua\n", + "uuuggagagaaauucggagaguuuuuagagaguauauaauuagcauugua\n", + "uauugcuguucgaagagaaguuucuuacuauacuuggacuaagaauugcu\n", + "uugagagaguuuuacuagagaagagcguauauagauugagagaauuugcu\n", + "ggaaguuuucaacagaugguccugcucuuuauaaaupuguauguauca\n", + "ugucacgcaaacugcauucaacaaagagaaccaaguuuccgcuucucgua\n", + "uauaaaauccgauuacaaagaaucgcaguuucuuuucacuuacaauugcu\n", + "acuagagaagaauagaguagaauccuuagccuaauaaaauuauuauugcu\n", + "gaauccgauuuuauucggauuauucgaguauugcacaaauaagacauaaa\n", + "uagaggaauuuccucuuuauuucguuuucaagagagaguuaaaapcc\n", + "cccggauuuacuuguauuggagagaguguaguagagagcuuauaauugcu\n", + "aacguuguuuagccaaaccacugauagagagauuuauaccgagagucauu\n", + "guaacccuuuuauaauagagaguguaucaaccuaucccguaagcauugua\n", + "uuggagagauauucggaagauagauauuuaaguagaagaguuucuuugcu\n", + "uuggagagaguguaguagauuucguuguauaguaaauaccgaacuaggaa\n", + "auuggagagauuuaguagaauagaaccacuaguaaacgcugaucuauauu\n", + "uuggagagaggauauucguuuauucagauaucgcagaguuuappcc\n", + "cccguuuuacagauuuggaaaucguauccuuaccuacauaucupcc\n", + "uagagagagaaauuguaaaucccugaaagaaguauccuagaggauuuacu\n", + "uuggagauuuuauuucgcauaccgagaauuccguuguaaaucuggacauu\n", + "uuggagauauuuacuuggauauuggagagagaguuacggauauapcc\n", + "gagagaauccggauauaaucagaauucguuuacccuuccuauacuuugcu\n", + "cccuuguaaaggaagaauuaucuaguagacaagucguaccaagcauugua\n", + "aauucgguuuuauaauuauagaguguaguugcauuaguaagaguauugcu\n", + "uaguucauuccgauucggaaaaagaaaguaguaguagacguagaaguguu\n", + "uuggagagaaucauacuuauacaagagacguuacaacgcugaaccacguu\n", + "aguguugcguagcaaaucuuugcuaguguaguucugaguaaucugacuaa\n", + "gagagaguuauuuagagaguuccuauacacuugcguucguaagaauugcu\n", + "gugaacugagaauacuuggauauucaguuauauuccuuauucgcauugua\n", + "auuggaguuuuuauagaguaaucgauuccguuuuuauucgaauuaucgcu\n", + "ucccgcguauacuaaaucucgcugauaaaaaguucaccgugaauaguauu\n", + "uuggagauuucgagucguugaucguuaaaaguucaauccuaacuaacguu\n", + "aaauaauucguuauauaguagagagaauuauccuugcagugauugguguu\n", + "uuggagauauuuacuuggagauucagagaaucgcacuaagaaucgaaguu\n", + "guagcauaagaaucuauuccguaucuauaccgaaucuugcgucaacuguu\n", + "gaauaauccguuuuaaaguuauccacaccugugaacugcuaagaauugcu\n", + "cccuuuauauaacagauuccgaguaauccaauuucguagauaacuaggaa\n", + "aauucgguuucuuaucucguuucuauuaccuggcauacucaaguagugua\n", + "gagagaguuuugaacuagagagauuccgaaucgauagacuaagaauugcu\n", + "ugagcucugcuuuuguauauuucgauaccagaauccgaagaaapcc\n", + "auugauuagcagauuacuuguagucguaauaaaauaauccguaaaacgca\n", + "auagaguuuauagacugagagaauacacguauacuucuguaaaggcuguu\n", + "uuupuuuauuaguaauucgauuacuuuucuauacgcuaacacauauu\n", + "auauaguucguuuuaucuuggcgaguguuagaacguauauucapcc\n", + "aaauaguuuggagagauuuggacguaucuagaaucauacguagagagaga\n", + "gagagaacuuagauacagagaauuaguccuuuacuuguagguaaaauaaa\n", + "uuggauuccguuuucggaaaucgauuguuaguagagaguguagaaguguu\n", + "uaaauccuauuccuauuuugguucgaaaguuuaauauuauaaapcc\n", + "gcagauaccuagagauuauucaguugucuucugcaaucauaacgaauauu\n", + "gcggauauacuuauccaauucccguuuccuauuaucuagcpuapcc\n", + "uucccgguuuuacagaaaguaucguguguaacauauuacuauuaaguguu\n", + "uuggagauccggauuacagaacaagaguuucgcauaccgugacgapcc\n", + "uuggauuaggagauuauuauuagagcagauucguuguagacuaagaaguu\n", + "gagagaguauuuagugaguagauaacuagauaucuaacuagaacuuugcu\n", + "cugugauaggagagagaauccgaaaaggagagaguguagaaaguauugcu\n", + "uugcagucucauuuucacuuuucgcuuucacaguccugaaaaucapcc\n", + "acagaauccguuuucacacuuauucacuuuccuaucuacuucaapcc\n", + "gagagagagaauaccuaguuuauacgagagagagagacguagaggauauu\n", + "auuggagagagagaauaaauucaaagagagcguguagaauucppcc\n", + "cccguuuuuuuuauccggaucacauauaccacgcauccauaacgapcc\n", + "guaaaccuuuuuauaaucguuguauacguagagcgaaucugacgapcc\n", + "uugccguagauagaggagagagaaucggagagauuaguaagaguauugcu\n", + "gagagaguuuucaauupagaauuguuaucuacuaucucuuucauugcu\n", + "ggagaaaguuucuaguaguagaguagagaaucuagauagagaccuaagau\n", + "cggaguuauacgaauucauagaguagagagauuaacgcgagauuapcc\n", + "ugucaagaggauuacuaaagaguguuacaggaguugauagappcc\n", + "ucpauauaucaaauaacguaauacgagaaucagaacuaguacuaaaua\n", + "ucccucucpagaaaguggacpacuugucaupauggugucuacau\n", + "uuupuuaucaaaucgaagccaaagcguaaauuccgauuaaapcc\n", + "aggagaaccuagagaguuaucguuguccuuucuauuuccuuuacuuugcu\n", + "uuggagaacuuuuaccuacauucguauucuacuugcggagagaaguuguu\n", + "uauagaguauauauauuggacuaguaguagaguaguaguugaccuagaua\n", + "guuuagcagauacaagucguuggaaaaagauuucgagcauaauuauugcu\n", + "gcauaaaaaaccuauucgauuucaagucguuuucaauuauccgauuugcu\n", + "cggaguucauagagucgaauucguauuccggauauaucupuapcc\n", + "acuuggaggauauuuauauucguuucucuucaguucuuauaaapcc\n", + "cccgguuauacaaguucguuuuccuugguuauauuacuuggagauucguu\n", + "cccguauuauuauuauauauuccguuuucauuuuauuaucgguugacguu\n", + "ggaggaaauuucaauuaguagagacguagagauacuaaguaacuauugua\n", + "uuggaaucgcguuuuacuuugucauaucggaguguagagaauuagacauu\n", + "uuupagauaucguaccuuuuauuacaguugcagauacgaapcc\n", + "gguuuggcucccgauaagaguguaugcuaupugcacuuaugcggaaag\n", + "uauuggagagaauuguaauucgaauccuuagcuacaagagaauccgcauu\n", + "gagaguuccguuuucuuuauccguauccuguauaauccgaagaguaaaua\n", + "gagaggauuuuacaguugcaaagagagacguuuacuauauuaucpcc\n", + "cccggauauacauuucuauucuaucucguuauacaauuauaauugguguu\n", + "auucggaaccuuuggagaauucgaagagcauuccuagacuaagaauugcu\n", + "uaaauccuuuacuaaggaguauuagagagaguaauacaauuppcc\n", + "acuugagaagcauuuucuauauuguggacguuaucauaauaagaauugcu\n", + "uagaaucuucgcauauucgaauacugcguagaaucaauuuccupcc\n", + "agagagacauaagacugauuuaauaguucauaccacaaccgugaucuauu\n", + "uuggagaucguuauauuccgugaaccagugacauuauaguguagacuauu\n", + "aauucgguuucauuauagaaaguauuggagaguguagcauaaapcc\n", + "uuggaguuucgguuucuuuuaucuuacccauuaguaaaauaaapcc\n", + "ccggaauucggaaucugauagacguguuuucgagaguaguappcc\n", + "agcgugaauuaaaacaaagagaguuuuccaaguaucguguagaauucgcu\n", + "cccguuuccggagagaggagagaauacuacuaccaauccugappcc\n", + "uauugagagaggaucugaauauauuuccugcuaguagaauccugaauacu\n", + "aaucccuagcagauacuuacuagauagagagcuaauaauuuaauapcc\n", + "uuggauacuuggauuggagaauacucaguaauaaaauaauaappcc\n", + "acggaguuuacaaaguaccucgauucagaguacuuuauauaaucpcc\n", + "cggagagauuagagagcauuuccuagauuuccuaguaauuaaapcc\n", + "ggaggagagauacuuugguauauuggagagaaguucuuauappcc\n", + "auuupuuauucagagaauuccguauuaccaaaguauaucuupcc\n", + "cccguuuuuuucaagagaagaggagcgaauuggauuacugcguuaacgau\n", + "uauugagaaaguaucucguaucgaguauaccuacuucguguagagaaguu\n", + "uuupagagaauaaaggauauauauuccguaucaacgcugagaauugcu\n", + "aapauauauacuuaucuuggucuauacaagauuccgaacgugaucguu\n", + "ggaauuacccgauuuauauccguuuacugucguguagaaauuucauugua\n", + "cccugaucguaaaaauauccugagauugagagaguagcuaauccauugua\n", + "aauucguuuauauaccgaauuccuagacagauuagcguagaguagaaguu\n", + "uagagaguguagucgaauucaaaguaucuucgcuaccacuagucguuguu\n", + "gugaugcaggcgcggagaagccggagaugcugcaugaggagaagcugcca\n", + "guggaguuuaccaaauccagagagaguguaguaaucccugaaccugagaa\n", + "guggauuagauaucacuguauacaaaucuuauuuucucuuuacaauugcu\n", + "agaggaauauaaauccgaauucguagagagauuaguugauaacguaagau\n", + "uauugagagauuuuacuuguauucpagaauaauaaccugagcuuugcu\n", + "guuguccuuuccuuuauuuggaguuacuuaagauaaacguaucpcc\n", + "aauucgguauuuaccuagaacuuauuccaguggacagaccuaguaguauu\n", + "gauaauccguuuucgagaguuguaagagaguuauuauuauaagagacguu\n", + "cccuaauccguuuuuauccgaauucguuuacuacgagaauccugaauacu\n", + "gagagaguuuuccuuggagagagauuacguagacagcgauuuaguagaga\n", + "auugagagaguauuauaaacugauuuaguaauuaagagcguucguaaauu\n", + "auuggagagaauuaauaagaauuccgauuuuaccucguacaaguauugcu\n", + "ccggauauacpauuauucgcuugucgaagaauccaauuaacgauugcu\n", + "auugagagaauauauauuccgauuuuaucuucuauucccuagaauuugcu\n", + "aucccguuuuuauauauucaaagaauccuuauccuuauacgappcc\n", + "uauaaaucccguuuucauauaucgaguuaucuaucguaaagauuapcc\n", + "uaauugcuguuauaucgaggagaauucggagaauuaguaggagagaaguu\n", + "uuggagaauccuauucggaguucuaaguuauuaguaagugacguuaaaua\n", + "uaaucccguauauaauuggagaguuuaccguuacagaucugauuguggau\n", + "uuggaguuccuuuuuguuuucuuaccuuuucggagacgauaauuauugcu\n", + "uuugguupagaaauuucguuccguguuagauuacuaucucgcuuugcu\n", + "gagagaauucgagagugauuuaguagagaauccuuaguaucguguagaga\n", + "gagaguuggacgaauucggauuuaauagcauaucgagcauaaucpcc\n", + "auuupuuauacaagagaguauuucguaucaagaauucugagcuacgau\n", + "aucccguagcuauauaaagcguaguagauuaauaauucgaguaguaggcu\n", + "uaauucguuggagagaagauuauuaacuuggagaguagauaacuauugcu\n", + "ggagagaguuuaguagagaauccguauaccgaaauccuucgagauuugcu\n", + "auuuagcucggauuauagagaguauugagagaacuaucauaaaapcc\n", + "ggagagaaucguucguaacugauaaucuucuuccugaacuaagaauugcu\n", + "uaguucacuucuuguauuaccuuacacguauacuuuucuuauucuuugcu\n", + "gcauaacccaauucgagaauucggagagaagagagucgauaauuaaggcc\n", + "uuggagagauuaucagaggagagaaucucguauacagagaaucuaauaaa\n", + "ucpauacauuacuugguuauauuacaaauuucccgauuaaapcc\n", + "cggagagauuacuuuauucggagagaguuuccgcuauuguagcaccuguu\n", + "auucgguuauuacaauacuucguuuuacacaagucucacuaaaapcc\n", + "guggauucagaaaacuaaaaggagaguguaguagagacgugaauucgaga\n", + "uuggagaauaucaaucucguauccuuguuuugcagugucauagaauugua\n", + "cccggauuuacuuggagaagagaguguuuagcgauaucuuagucuacgau\n", + "uuggagauucguuauuagaauucguuuuuacaguccaauuaaaapcc\n", + "gcggcccpuguaaugauppcgcpcucugccuugaaggugu\n", + "uaauccguuuucuaucgagagaagaauccguauucagagaacugauugcu\n", + "uuguuauuguguuccacaguuucaagaguaucuuacacguauacuuugcu\n", + "auuggaggagagaauuaauaagagaguaguagacuagcauaaauccugau\n", + "uuggauuauccuuuuauuggaguauuaguagagagcguuuaauaauugcu\n", + "uaauccguuuauugucgaucacuaauccgauccguaaacagaacuuugcu\n", + "auucgguuucaaauucagagaaucuaaguaagagaaaacuaggagagaga\n", + "uuggauuccggagaauagagaguuucacuuucuauuacgaauuggauauu\n", + "ccgcagauauaucuugguccaaaucaauuagcaaauccuuaaapcc\n", + "ugucgagaguguguagaaagagaaaaaucgccacaaccauugcguucguu\n", + "uupagauauuuguuuucaauuccguuacaagaacuggaaauccggaga\n", + "gagaacguuuucaagaguuauucgcguauucacacaccgugauuagcgua\n", + "uuggagguuaucaagaguuggagaagagaaucguuauuauaaapcc\n", + "ggagagagagagcaauuauugauaagaguuuccguaaauuaaapcc\n", + "uagaaucccugauuauuaucugcagagauuaguagauagagaapcc\n", + "ggagagagauuaucaaauucagugucuucuguuaccugucuacauacgga\n", + "cccuuauagagagagaaucguaauccguggauuuuacgaucccuaauaua\n", + "aucccguaaaagagaguuauucaauupagaauacccauaaaaauuauu\n", + "gagagaguuuuauuauuauuucauuuggcauauucgcaucuucauuuacu\n", + "gagagaauccuuaucuugcggaucaaaguauuauauucccuaguaacguu\n", + "uuggagaacuuuuccaauucagagagagcauucuuuccuguucuagugua\n", + "gagagaguuauuaucuagagaaucccguauuuaauagaguccugauugcu\n", + "uuggaguucaagcguauacuugaauacguagcuagccauauaguapcc\n", + "aacugaacguuauccuuggagagagagucguuaguaauucauuagacguu\n", + "uuggagauuucgagaaagcuuuggagagaguauuuaauaguauapcc\n", + "uagagagaauuauacucguguacacgaauuguaguagauuappcc\n", + "auugucguuccuuucaaucgugaauuagaaggacgugaauuaucauugcu\n", + "aaaguauuuuagagucuacggauuuacgagaaaucuucugucgapcc\n", + "uuggauuuauagaagacagaucgaauagagaggaguaacgaucguaaauu\n", + "cccguauucggauuucaaaucguuuucguagagcuuacauaaapcc\n", + "ccgcguuauacaaaggagagaauuccuauauucagagcgugaagapcc\n", + "gagagaguuauauuccguaucguuucgcuaaaaccuuaucuucpcc\n", + "gagaauccguuucuauuaucaagcguuaucguaauaaacuaagagcuauu\n", + "apagaaaacguuuauauuccuucuccugcgaguagaauacuapcc\n", + "auuupaauuuaauaguuucgcauuccuagacuaguaccuagauugcu\n", + "aguugagagauucagagaaguauaccgagauuagaaguccgaauagugua\n", + "uuggagagaguuuaucagagagugucuaauaaauuagaucguaaaacgcu\n", + "aaacguugagagagaguacuuauucagagaauauauucuuuauuauugcu\n", + "uuggaucucggaucuacacauuuggaguuacgguuccauuaaapcc\n", + "gcggaugaggauggaauuccgcgccagcgugccupcuggaupucug\n", + "uuggagaaacguuaucagaacuaguaguuaaaaagcugaaaauccgcauu\n", + "uupauacaagaauuaucagagaauccguuuucauuacgappcc\n", + "acugauccucggauuuaauaaguuucgauaguaauuaagagugaaaaguu\n", + "cggagagaauauauauupagagagcaaaucgcauuaagappcc\n", + "aguuuaggagagauauaauaacguagaguagaccgauaacuuagcauaca\n", + "gcauaauccuuauacuaaaaguuuggagaguuaguaauagaauugugaua\n", + "ccuuaguagagaguuauuaaauucgguuuccagaaccuuuaacuaacguu\n", + "cuggaguagaggauaucaggauuuagaggauuuaagcgaacuacuaggaa\n", + "cccguauaaaaaacuucgcauccuauucgaguccuaaaacguacauugua\n", + "gagagagaguuuuacagagaauccuuaucauuacaaagaagappcc\n", + "ggaggagagaauuauauauauuggagugauuuaauagcgugaccuaaaaa\n", + "uuggagagaguuacuugagaguuucguauacgagaagagcauauaacguu\n", + "uuggagauccagaauuaacucauauuaccugguugauugacguapcc\n", + "uagagagcguuauaauagaguaguuucgcucucucuaaaagaccuaagau\n", + "aggaauccuuagagaaauuupaauuacuuaaccgauuuuacuuugcu\n", + "gagagagaggagagaguacauagaguacuuagaacaaaaggaccuaaguu\n", + "gapaapaaugcggaapacagcugagccaaugugacacucuau\n", + "cccguuuuuauauuccaaaucguuguauaccagaauaccuagaaguggca\n", + "aagcguuuucguuauuagagauacuupauuauaucuucuauuauugcu\n", + "uuggagaacuuuaucaaauccgauuauccgcuacaaccauaaucuacguu\n", + "cccguauucguuauuauuuuguuucccguacauuaccaauaacuaacguu\n", + "auuupauucaaaauccuuuggagaaagaaauucaacgauuuaauaaa\n", + "gugaacugagaauuacuugucguauucggagagaacucguaagaauugcu\n", + "ggaguuauccugauaaaagacuguuuuccuuucugcaguacuuuaaggcc\n", + "auaauaggccagacgaagcuccpauggcupcccuguucucguaac\n", + "auuggagagauauaucagauucgaguucguuggagaagacuaacuuugcu\n", + "uuuaucccguauuaucucuaaacuuugcguuuucaaucgugaguaauauu\n", + "uuggagaacuuauacuagcgauaucuuucucuucacacacaaapcc\n", + "cuuuuccuguggagcaguaugcagcuagugagcacaaauggauguaguug\n", + "uagaupaggaggaguuuuuggaupcauaugugcuggagcuugagg\n", + "uuggagaaaguuauauaguaapagaapauuuaguaaaaapcc\n", + "uuggauuuucguuuucaaagagaauccuuaguaagagacugaucpcc\n", + "aucccuuagcuuauauuccgauuucaagaauuaucaaucuucccgcaucc\n", + "gagagagaagaguauaccaauccguuuucuuauucuuuucuuacuuugcu\n", + "gaauaauccguuuauuaggagauuupagaauacuuggagcguaauacu\n", + "uaauccguuuuauaauagaguuccguguuagagaaaucuuaaaapcc\n", + "ggagagagagagauuuaguuggagagagaguuaguagaauaaapcc\n", + "uucuaguucguuuucacuacaaagcguuauauaaagcguguaguagugua\n", + "ccuuuccugguuaucupauuuaauaguuauucaccuguaaapcc\n", + "gagagaguuuacaagaguauaccuugcguaguaauuuaauappcc\n", + "gagauauupaauugauagauuaguaguaaaagcugacaaaguguaga\n", + "aaagcguuuacaaauccgcagaaauucgguuucaauuuaauaguauugcu\n", + "auuuagcgcguacaaauccagagaguauuuucuuaucuucuaucauugcu\n", + "uuggauacuuccaauucuacggagaguguagaaguuauacgaapcc\n", + "uccgauuagcuuuucuauucggaaccuuuucuuucuaucccaaauuugcu\n", + "ggagccuguaaugugaccaugcagaagaccacgaugaacuacucacacga\n", + "uuggagagaaguuuggagagaagagagucguuaauaaaauucgauuugcu\n", + "guggagagagaguuauucgcagauaauccguguagagcagagucuaagau\n", + "uuggagauaucagaaucguuauuguuauuauuacgaagucucugapcc\n", + "ucgugauccuuggagagagagugauaagaguuaucuuaucuacuauugcu\n", + "aguuuagcggagauauaauagagagacguaauagaauaguaaaauucguu\n", + "cccugauccugagagaggauauuacuucgagaauacuuggacuaaguauu\n", + "auuggagaacuuuggagagaguuuucaacgcuuacgaguauuuaguaguu\n", + "uupauuuauauuauaaucgagagaagaguuucgcgaaacguagagaga\n", + "gauggagaugauugugauuaggagaaugagacuucauuggugaaaugaua\n", + "gaauucggaggagaaauucgagaguuuccgaguuccuagaaccuaauaua\n", + "uuggaauuccguaucagauuccgauucguagacuauauuacgupcc\n", + "gcuaauccguuuauauaacgaagagagcgaagagagaguugauaauugcu\n", + "auagagagaaacuuguauuagaagagcuuucuauacccagaauaauugcu\n", + "gagagaauccauuuucuacaaaaacuuccguuuucaauucccuauucgcu\n", + "gagagaaguuuaucaaagagagagagugacguagugaucugacauagaga\n", + "aauucguuuuacuaaucgaacguauauaccgagcuaaaauaaapcc\n", + "ugagcuacacgaggaaaauuguuccuuggacguguagaagaaucpcc\n", + "uauaucccuuagcgaauccguaguagagaggaguguagaggagauagaga\n", + "uuggagagagaguuuauauucauugagagaguaccuagaggaacugagaa\n", + "guaguccuagagagauagaaucgugagagaguaguaauuaacuagcuguu\n", + "uuggaguuccguuuacuuggagaguuucuaauagaguagappcc\n", + "uaggagaauuucgagaggaagagaaucguaucgaacugagagaacugaua\n", + "acuguguagcagagagaauccguguacuuucacgcaaccugaauaacguu\n", + "gagagagaguuuaccuugcagagaguaucuuuucauaccuagcauacgga\n", + "aucgguugaagaguuauuaacucguauccuaaccugauaccuuagacguu\n", + "ucuaucccguaaacuuuccgugaauucagagaauauccggagauuaaaua\n", + "auuggagagaguuuauucacuuauuucggauauuuagaguauauuccguu\n", + "cccugaucagaauucguauuugaguggauuagauucagaguucguaagau\n", + "ggacgaggaggaggaggaaggagaapcacagaugapaggaaa\n", + "apaauccugagaaagauucggauacagagauuuaauapppcc\n", + "uguggcgaaacgugaucauagaguuucaaagagaagucauaaagguggcu\n", + "gagagaggauuuacagagaguuggaguguagaagaaucuuaaapcc\n", + "gagagaauccgaagaacguugcgaagaauuuggagaacgugaacugugaa\n", + "uagaauccuuaucagagcacuagaaguaaaaagaauccuugagcuuugcu\n", + "uuggauuccguuuuacuauugauaaaacagauuuuaaacuagaaccuauu\n", + "auuggaggagagagaguauauucauacguagagaaucuacuucaaagaga\n", + "gagagaguuuuuuacccaggaucuaguucguuuccuaacuaguuuucgcu\n", + "guggcucupaugaappacguguccuuccaacauccaaupa\n", + "uuggagauauucgauuaguauuguaaagagagagagaguaacgcugaaaa\n", + "gaaaauucguuuuuaguccauaaccgauuaaaguuguucacugcuaagau\n", + "uuggaagcuuuuauacuugcagcguauucauacguaaaggauucggagaa\n", + "cccguuuuacguuaucupaagagaggagaguucauaagaauucguguc\n", + "uuggauacacaguuauccgaauaguagaguaguagauagauuaguucgau\n", + "aguaaucuguuauaguagaauccuuaauagagugcugaauagaucucuaa\n", + "gguagauuagcuucaaagagaauuaguaguaaauucauugacguaauaua\n", + "gagaguuagcagauauuauuggagaguguaauaaaacgauaaapcc\n", + "uuggagaaccuuuucuaguagagagccuuuuucauucaagaaucpcc\n", + "uuggagauccggauauaaucggaagaguaucuaucgucguuauupcc\n", + "ucgcguuuuuauauuccgcaucuuuucuauucgcuaacguaaapcc\n", + "gauauuagauggaugguuaugaugagguuucaguuauuuuuauaaap\n", + "auuggagagauuccgauucguauacuuucguuaucucauuaaapcc\n", + "uucaaacuuccguauacuuauccgaaucuuucuuuccucuaaucpcc\n", + "uuggagagagaaauuucguuacaaagcauuaccagaaaccaaguauugcu\n", + "acugaucccgaguuucgaagagaauaccuagauccgaauuaaapcc\n", + "cccggaauuccgagauaauuauuaucggaguucaaggacuagagauugcu\n", + "uuggaaacagagagauaucggagagaagaguauacuuaguappcc\n", + "aggaauccgagauauuaacugucguuaccguuauuuggcgcgugaauaau\n", + "cccguuuuauuuucucuauucaguuucauaccaguaguagacugauugcu\n", + "auugaguuacaaguauagccugaacuagagauuuuaacuagauauuugcu\n", + "ccgguuuauauacucagagaaucguauacuacacagcuauuppcc\n", + "cagugucgcgcugagcpaagacaaugcgccapucccgcgugcgg\n", + "gcauaaucguuucaguuucgcuuacccagagagaucucgugauuapcc\n", + "aucccguuuacaagaaucuagagagucguaaaaaaaucguaagaauugcu\n", + "gaauagauaucguuuauuuagcggauauuacgagaaucgugaacuuugcu\n", + "ucgugauccuuuuacaagaguauacguagagagauuaaauaaaapcc\n", + "uuggagauuucgagauagaaaagagagucguuacaaucauaaapcc\n", + "uaauccaguuuauaacguuuauuauuagaaguaucgugaagaucapcc\n", + "uagagaguuuaucuauagagaguuacacgaaaacccaauaccuapcc\n", + "caauuggccacagcuaagaaaagaggugcaggaugacagcaacuuguccc\n", + "gagagagaaacguuuauauuguguagugaguuaauagaacgugacaaguu\n", + "uugaccguuuuauacacuuauccgagaaccuuucacuccuagaauuugcu\n", + "gagagaguuuuuacgaguuauucgagagaguuaguagaguaaapcc\n", + "ccggauuaaaccgaauuccuuuuaccggauauuauacaauaagaauugcu\n", + "uuggauuccgguuuauuauucguuuucccuuuaauaaucuucaauucgcu\n", + "aauucgguuuuuauuuaguagaaucguguagagcaucccugagaacuguu\n", + "uagagaguguagaagagagagagaagcguagacguuauauccuuauugcu\n", + "gagagagagaggagaagagaguuaauagaacggagagaguagaauuugcu\n", + "uaaauucguuuacaaauuaucagagaauccuuauucucucuuuggauacu\n", + "gccagccaugacugugaagcuupaugauccaacuugcagccacaaagg\n", + "guuggagaacguuuauaacggagagaaucguauccacaaccauaauugcu\n", + "gcaaugcuaaugucgguauagucagaauccagcuuuugaggaggacacaa\n", + "gaauugugaaggauauuuacuaggagauuauuggauuaguagcgugagau\n", + "auauaagcaguuucaagagagaguguagagagagaauacuaaapcc\n", + "ucccuuccuuaaccgaauugaauuguuaaagaguuccuaagugauccuaa\n", + "uauauucccuagcgaaauuauaguuuucuagugaguagaaucacuaggaa\n", + "gagagaguuucuuggcagaguauagcguuaauaaccuuacuuppcc\n", + "auugagagagagaacugauagaguaaauuuaguaaccaaagaguauugcu\n", + "uagagagccuuuuuuacuucguuuucaguuacuuauuauccuacauugua\n", + "uagaguuuggagaagaggagaauccgaauuccgauagcauaacgapcc\n", + "aucccguauuauacuuccguaucuaucccuuguuugaccuagacagaguu\n", + "ccggauuuauauuacaaccuuuuaccuauccuuaucccgugauupcc\n", + "ugguaccguuucaacguguaauuagaguugauauaauccuaauapcc\n", + "agccugugacuccguaagaauuaaugguuucuuucaugaaaacagauaca\n", + "cccguuuuuauacaauuguccuauauacgaaccucucacuaagcauugua\n", + "auuggagauucagaguacuuggauuccgaguuuauucgucgauaauugcu\n", + "uaguucguuuuuacuuggagaacaaauuccugguugaauuagacaauacu\n", + "uauuguuugcaauuggaguuuccuauacugcugcauuacuappcc\n", + "auugaguagaaucggauuauuugguucgauaaagagaucccuaaaaaaua\n", + "gagagagaaucguuauagagaguuauucauaucagucucuaaguauugcu\n", + "uuggagaaauuuguauaaauacuacacugcgaauccugacacacugugaa\n", + "uuupauuaucuauuuggaucuuaucccuuucaaucgaguupcc\n", + "auucuuugaugaaagupaugaaggcaaugaaaccaggucaaauaacgu\n", + "uagccugauuuagaacugugauagaguaguagauaauccuuagcugugaa\n", + "uuucgaacccgaguuucggauucguauauagugaucgauuagcaauugcu\n", + "auuggagauuccaagagagagagaauccguuuuuuacuuuuccuuuggcu\n", + "uaauacacuupauuauucguuuuccugcgaaguaauauagupcc\n", + "cccuuuugagagagaaaucaaucaaaccuaguaaaagaauuguaaguguu\n", + "uuggagauuucauucaucccagauucgagagagcagaacugagagacguu\n", + "uagguauaucaauagugauaauuagagaguguagagagaagappcc\n", + "guuuggagaaccuuuccagaguaucguguaguagaguaacgappcc\n", + "gagagaggagaauuucgagucgauucguuuuacauagaguagaauuugcu\n", + "uuggauucguuuuauccggaguuaauagaguaucacuaguappcc\n", + "aaacacuuggagagagagaguuccuuauaccgaguaacguaaccacuguu\n", + "gaauaacacagagaauuuacaaauucgguaucauucguguagacauugcu\n", + "uagaauccuugguuauaauaagagaauccaaggaacuacuappcc\n", + "auuggagauuuuuacgcggaauuuaguagagauuucgaaauaguaauaua\n", + "auucggagaaaguuguaauagauaucguuggauauauccuaauuauugcu\n", + "uagagaaccuuuacuucguugcaaguauacguaguaaacuaggagucguu\n", + "gagagagaguuuucguuauuucgagagcuauuacagaccuaaaagucguu\n", + "uupuuaucaagugucuaaaagagucuucgucaaaaccuaagaaucguu\n", + "cggagaauccggauauagaguguagaaguuucuauaaacuaauupa\n", + "uuupagagauuacguagaguaccuagacuagauuaguaguuaauaaa\n", + "aaguguuauccgauuccgauuuggagaauauacuuggcauaaapcc\n", + "cggagagaaaacauauuccguaaaccguugauuacugupaauuaaaua\n", + "ccguuaucgcguauacgcaaauaauaagcguuaauagcguagapcc\n", + "gaauccguuguuacaaggaaccuuuaauaguuaauagaaucguagucguu\n", + "aaggaucccuagauacugucuagauuaccuaguaagaguuuucuapcc\n", + "auucgcuguuaagagaauccguggaguagaaauccgaauacauaguugcu\n", + "uucuaauucggagaaguuauuaauccguucuugacuagauagacuagaaa\n", + "uuggaguagaaguuauagagaacuaguaguagagaguaguagaguguaga\n", + "ggaggauucggauccaauuggauucuaaaaguaucuccguaauuauugcu\n", + "cccguuuccguuauacaaagaaauucgcagcaagaauccugagcuuugcu\n", + "cuauuuccauguggacucccagcaugaguuuugauaggauggaaaugcug\n", + "uuggagagaggagaauaguagacuuggauuauaccucgcugacaaagaga\n", + "aaauaaaucauauucagaaucgaaggaagaguaaaaaacguaauagugcc\n", + "aguugagagaaguuucgcgcuacuaauucaaauaauccgauaaaapcc\n", + "gagagagaaauccgaauuauucguguaucccgaguagaaauauauucgcu\n", + "uuggaggagagagagaauaauucggaguuucaagaauccugagcuuugcu\n", + "auuggagagauucaauucgaguuauauacaaccguaaacuaaaapcc\n", + "aauucgguuuuuauauaguaggaguuauacuuaucuugaacuacauugua\n", + "gagagaggauauccagagaaucaauupaucuauaaacuaaaapcc\n", + "uccggauccuaaacuuguuaucuuauacggauacacacguaagcauugua\n", + "auugcguagagagauucgaauucgaauccgaguuuagaacaagaauugcu\n", + "auucaaccuauuuagcaaaucuuuaucgaguuuuacuuaucuupcc\n", + "agcugaggaccuacaagcacugaacggacuuagcgcauucuugaauuaac\n", + "uaaucccguauuacuacaaauucgauuaguaguaguugaagugauagaua\n", + "gagaguucguagagagauucagaguaccuagaucaauccugauuaaagga\n", + "uuggaguucauuucaauuucgagaggagaacgcaucaacuaguapcc\n", + "auccgguuucaaaucguguccuuagagagguuauccgauuagcaaggaga\n", + "uuggaguuaccgagaauuucgagaacguaucuuuaccucaccugaaagga\n", + "gagagaggauauuagaagagagagaaaaguuuacccuauuccuagacguu\n", + "uuggagaacuaacagauuccgaguagauuaguagauagauagacuaggaa\n", + "gaggauuagaaguuucuucguucaaucuauuucgagcccuaauuauugcu\n", + "gauuugguuacaaaucguucauuuuauauucaucccugcaacugaauacu\n", + "auuggagauauauagcugcaaagagagcuucaccuaccuauuuccgugua\n", + "uuggaggagaguuuuacaaacguuuuaagagaauauauucgagapcc\n", + "ggagagaguauaucgaguauccagaaaccuacccuaaccuauacuuugcu\n", + "uggagacaauccguaacauaaguguauacgugaacagaauacgaguugcu\n", + "uucgcgguuuauuaguagagaauccuuauccaccuucaaccuucauugcu\n", + "uuggauuauacguugugauagagagaccuaguaaacccgugauccauauc\n", + "cccugucaacgcguauuaucauacuguguagcgaauacuuappcc\n", + "gagaggauuuuuaucuuguauuggagagcguuucuagcauaaapcc\n", + "ugaggagagccuuuagaguaaaucguucgacgcguaaucuaappcc\n", + "cccguuuucauuucgauuagcacguuaccuaaacugagagaauaauugcu\n", + "agagagauuauauucagagaaguaucuuacaaagagcacugaguauugcu\n", + "ggaggagagaauccgaauacuuuguucuuucucuuaucgaaagcauugua\n", + "gagagaaucgagaauccgaagagacguaguaguuucacuagaauccugau\n", + "aguagaguguagcagagaaucuugcguaucaauccgaagugacauauacu\n", + "uuggaguauauaucgaggagauuucgagcguuauuccgcaucguaacguu\n", + "auaaccuagucgaagaaaacaaauagaguaauuaaaaggaucucugagaa\n", + "uauugagagaguuuacuauaauuccgaguauauacccaauuaucauugcu\n", + "uaaucccguuucaaagauacuguaguagagagauuccgauucaapcc\n", + "ggaggauucgcgauauaauaggauauucguuuacuuauucucupcc\n", + "uagagagcauuauuauuauuauacucuguagagagcuacugagcuuugcu\n", + "uuggauuccguuuucuaguagauuggaguaguaaaaguauuppcc\n", + "uagaguuuaccgauauaacuuuguucgcuagaauccuucacaagapcc\n", + "gagagaauagagagaguuauuucaagcuaccuaucggacuaauccggaga\n", + "cccgauaccuagagagaggaaucguuaucauacuucuauuaccuagugua\n", + "cccuuucccugaaguccuaaauaguauaguaauccauaucguagauugcu\n", + "aggauuaccuagaaucucggaaagagaacacuaguagaguaaaccauacu\n", + "uagagaguccaguguuauucggauuaccuagagucucacuaauagcauca\n", + "gagagaguuauaaaucugauuuaauaagugacuagagcaucccugauaua\n", + "gagaauuugcagauauaauccaauucggaguucaaacgcugauacauaca\n", + "uuggauacuuagaaauagagagcggauauauucgauuagagappcc\n", + "auugagagagaggaauagacaaguagacgaauuaguaauccguauucgcu\n", + "gagagagagguuauucaguuauugagagaggauuuagauuaguapcc\n", + "aucccuuaauccgaauagauuuggaucacuaguagaagaacuaguaaaaa\n", + "uuggagauuuacaaauucguuuugcacagagaauuaucuaccucuuugcu\n", + "uagaggauucagagaauuauacuuggaguagaauccgaguaguapcc\n", + "uauugagagaguuuuccaaguaacuuauaccguaaccguuauccauugcu\n", + "uagauacuupagaauacauacacuuccuuaucuccuuuauauauugca\n", + "uagcuauupaucuuuacuucgagaauuagcagauuacuuuacuuugcu\n", + "gagauuucggauuuuguuuaccaaaacacaaacgcuaaccguaaucuauu\n", + "ccggaauucguuauacagcuguaauagagauccgcauaccuaccuauacu\n", + "gagagaggauuauauagagucgauuaccgauuuuccgauuagcuaacgua\n", + "cccguauucguaucaaguguuuugcagaaaucuuauuucauuuaapcc\n", + "cccgguuuauacaagcguauucuaucauaccuaguaagagagaguuggau\n", + "uagaaucccguauucauucgaauacuucaccuuaccucguaaguaaccaa\n", + "auuggagagcgaaauucgaauuuuauaucgcaucucuuacaauuauugcu\n", + "uuggagauauucauucgcaguucaauuccgaagcaacgauaaucauugcu\n", + "gagagaguuaucaagagagagaguuggaguguagucaauuagcauacguu\n", + "ccggauuuauacuauucpaauugauagauuaguagauagagauuugcu\n", + "aacguuugagaagaaaauccaauaccuagugaacuagaaggaacuagaua\n", + "uagagagcguuaucaauaccucuucuucuauacacguauuccaapcc\n", + "gauuuggagauuuaauaguuauuaucagauccgaaucguugagagaaguu\n", + "uagagagacguuuaucaaacgcaaagagaaucuuacccauaaccaauacu\n", + "ggaguugaccuagaagaguuguacuaacgugauaguuuaguugacauaaa\n", + "uupauacauagaguagagagaaucguaucuauuaucuaccuauucgcu\n", + "uuuggagauucagagauauagagaguccuauauuccgauuauacacuguu\n", + "uuggagaucauucuguuauuucauuucuaucccugcagagaaucpcc\n", + "uuggagauccggaaaaaauacguaucuauccaagucacauuucpcc\n", + "cuugauuccgagauaccgaauuuaguaguagagacguaaappcc\n", + "uaggaaccuauucagauauuggagagcuuaaaucuucuauaaapcc\n", + "auuagucuuuagaagaagaauccgcaauaccaagcauuauuauuauugcu\n", + "auuupuuuuaucuggacuuguagaaucccgcguaacauaaapcc\n", + "uuggaguuccggauucaagagaguuucuuucgccuagacuaaagguggcc\n", + "aacacacaggaguauaaagaugguguuucuuagaaggaaaaguaauguuc\n", + "guggagagaggauuauauuggacuagaaauccguuguagauuaguaaaua\n", + "uuggagaauccauagugaaguagaaguaaaaagaccacuaguacuaaaua\n", + "uaauuccguuuccucucuaaagauaguuuagucuuaucgugugaucuauu\n", + "acggagagauuuauucgaauucaggagacgcuagaccacuaaaapcc\n", + "agucccgugcacuacucaaugcucauuuucugccucccucuuaugaaaaa\n", + "cccuuuauuauucgaacggagagaaccuuuaucgaagagcguguagugua\n", + "uguccgcgauuaacguagagcguaacguuuucagauccagaguccugagc\n", + "auaacaccuuucaaagapaguaugcacacagaugagccaaapcucu\n", + "acugaucuugguguacuuguaguagacggauauucggagaacuauucguu\n", + "cccugauccgauauccgaauuccguuuuuucucuuuucucuucuuauaca\n", + "uuggauucguauacaagagaacuuuauccguuuuacacguaaguauugua\n", + "ggaggagagauuaucacuagaacacuuaguaauaacuaagagaaaggaga\n", + "uuggauaccuauugagagagauuaguagaaaaaucccguauuuagacguu\n", + "uagauacccggauauauuccguuucauucguuacaaggagcuacauugua\n", + "auuupuuuuauacagagaauucgaguuccuaguaaagagcuagacguu\n", + "gagagaaucguauacuuguaucgagagcuaguaaaccacugaucpcc\n", + "uuggagagaauauauuauauuguggagaguauaccgacguaauuauugcu\n", + "gagagaacauaaauauauuauccgaauccguuacaaguaucuacguggau\n", + "ggaagauauuagaagaguugcguguaguggagaaaaauccugaacugaua\n", + "uagauacuucguuuucuuauccgauaccuaaaccguauccuauuauugcu\n", + "cagauuacguagagaauccgugaagagaguuuuaagccauaaacuuugcu\n", + "auuggagagaacuuuucagcuuauucggaucccuacuuguaaguaauauu\n", + "cugaucuagaggagaacuuugcaccuauuaauaaguuagaauugucacuc\n", + "uaggcaaucaauacuucguauuuucguauaccacaauccugaucpcc\n", + "uggaccuggauaccaaaauugcucuggagcuaaauacggagaacuugagc\n", + "uuggagagcuaaauacgaaguagagaggauauaagauaacguagauugcu\n", + "gagagagaagagagauagagauuuaguagagauucuaauucaapcc\n", + "cccugaucguaaccaauucggagucgauuagcagauccuugagucauaaa\n", + "gaaucggaguuauucgcguguauuaguagagaacuaauccgugaucuguu\n", + "uuggagagaguuucucuuacagauuugcagaucacuacauauucauugcu\n", + "aaccucaguggagaaugagaugacauuucccaggcagguuguucccugca\n", + "gugaccguuuuuauaagauaaagagcguuauccaagaguaucuapcc\n", + "uaguuuggagagaacugauagacugagagaguaguugacuaagauuugcu\n", + "aaacguuauccguuuucaauucgagaacuucaagaauuccgcacauugua\n", + "gacauggugccaaagauauuucapupagcgguaagagcauaaugaa\n", + "guccaagcccugaugugaacuccacuaugcgaacugaaguaaaugaguca\n", + "auuupuuuccaaaucaauuccguauaauccacuaaguuauccuugaua\n", + "uagagagagagagagaauuagagaauccuuuuucuucuucuacuauugcu\n", + "ggagagaauauuacgaauuguaguuucgauuuuaccugacguaaucugcu\n", + "gaauaauccguuuuaccguuauugagagaguuucacuucaccgauuuacu\n", + "ugaaaagcguguuuuguuacaguauuaucuaccuuaccauaaucpcc\n", + "uaauucguuuucaauugagagagauaccuagauaucuaguaauuagugua\n", + "uuccgguuuuauacuucgguuuucuggaccaaaacuuggagaucgguauu\n", + "uuggagagagagagauuuaucccguuuuacgaauuauaucgagauuugcu\n", + "uuugaucuguuaucaaaggaagaggaaucacuauucuuacuucaagacua\n", + "gauacgcuuggauuauauacaaaguuccuauccaaagcguuacuaguguc\n", + "uauuaauccguuuuuacuacaggaguuucgaagcaaacuacauuauugcu\n", + "uuggaguugcuuauccgaauucaauuggagaaagaaucuuaaapcc\n", + "guguaguuuuccuugcagauuguguucguaacuacuuauaccuagguaac\n", + "uuuaucccuucguuuuacuuauuaucuccuauacuucuccuucuaauaua\n", + "guuggagaaguauucaguuuauuauuggaguuccauuaccuagagacguu\n", + "aaguguugagaggauuuauaguguagaagagaauccguaaaagaauugcu\n", + "cuuggugauuuagaaauccgaauaccuaguaaguaauuaacuacuuugcu\n", + "cccugauccuuuucgagcguuguaauaguuaccucaaaaccuacuauaua\n", + "aucccguuuuacuauauucagagaguaccuuauuuaauaaccuapcc\n", + "uuggagaacuuuucgagaaucgagaguguaguagacuacuaagaaucguu\n", + "acggagagaagagaauaauucgagaguuuaccuucaucauuguggauauu\n", + "aaaaaaagaguacagccccagcaagaagguucaggagaaugguguucugu\n", + "gagagaggauauugagagaaucugauaagagaguucuucuauacuuugcu\n", + "aaauaaaucccguauacuuauuuggagauccggaucacauauccauugua\n", + "uuggagauaucagagucauagagacguaguaagagauuuaguaguagaga\n", + "uauugaagaguauuuauucguugucgaagacguguagauuagcuauugcu\n", + "auuggagagagaggauuuagaggagaguuauuagauuauuauuauuugcu\n", + "acuuaggaggagagaaucguugauuuaguaguugagagauuaauaauacu\n", + "aggagaaucugaguaucguuuccgaguaguagaucgagauuuaguagaga\n", + "uuggaguuccuuuuauauauucggagagcguuuauagacuaagaauugcu\n", + "cccguuuucguuacucaguuuauuccuuaucccucaaaagcguagagaga\n", + "ugcaaagagcguuuauaauagaaggagucgauaguaaaacgappcc\n", + "ugaggaaccagagaaucguaaaacuggcuucaagaaucuuagacguggcc\n", + "acuaauucguuauauacuuuguucucuguaaaccuuucccuagaaucguu\n", + "uuggauacuuagcagagaagaagaaucuuucugacccaauccuaaacgcc\n", + "uauugcguuacauuucgaagaaagaguuuaacuaccgcauaaapcc\n", + "gagagaguuuuuauauuauuuuacuuaucuuacccaauuaccugapcc\n", + "uauugagagaaucuguaauagaguuggaaggaauuagaguagacauugua\n", + "cccugaucaaauacuacuuggagagaaggauuuauagccuaaucuacgau\n", + "uuggagagauuuauauaaccugauuuguuauuagcguguagacguaaaua\n", + "uuggagagagaauaagaauccuauuccgcuuuacuuucuauccpcc\n", + "uggagagacagguaauuguaagugucaaagccacgaauuuaaguguugcu\n", + "auupauuuaauagucuguuucaucguuaaccuucucagaccuagaua\n", + "ucccguauuupuauaauagagagacguaacacaauccugcguagugua\n", + "cggagaauccagauucagagaauuucaagcguuauaacagappcc\n", + "uauuaacccguuucaaaguauauccuucgaucaauacgauaaapcc\n", + "uagagaacuugaguauuupagagaaguauucgaauccugaccuauacu\n", + "uagauaccugguauauaguagaguaguagauuaguaacgcggauauugcu\n", + "uuggaguuacuauuuggagagaauucgcuaguaauauaauugauagugua\n", + "gugacguaaauacgaaucggauauuupauuuuauuuccuuacguguc\n", + "guguuccugcugaagccgcaugagauggauaaagupuuuuugcuaaa\n", + "gagagaguuauacacuaauccaauuacuuagagaggaucugappcc\n", + "uuggagaaccuuuuauaaucggauuccuuagacuacguaucuacuuugcu\n", + "gagagagauauagagagagagaguuuccuaucccgaacgugaaauuugcu\n", + "cccguauagagagaaucgaauugauaaguaaaagaguaguagugapcc\n", + "uaauccguuuuauaguagagaaguucggauucuuacuuguaauuaagaga\n", + "agagagagagaguaguaaauuaacucaaucgucuuuaacuaagagaaguu\n", + "gagagaguuucaaauccgagauauacgaguugcaaauccucaguaguaua\n", + "gagaguauauuccuucuucuguuauucguuuuuauucgaguauuauugcu\n", + "gagagaggauuauauuagauccuaucccuaguaauagaauaagaaucguu\n", + "uagagaauuugaguauucguuuaucguuugcgagagaaaagaagapcc\n", + "aaacgcaaaacagagaauuguauaaaggaaucuauucuuucguaguuauc\n", + "uugguauugcgagaaaacauauaucgaaaguuuucucuguaacpcc\n", + "uuggaguuccaauacuuggagauuuaucguuuucuucuauaauccacguu\n", + "ugucacgagguauaaaacuuagcaagauuucggacgaagaagaaggugcu\n", + "uuuaucccuuauacaaucguuuauuupagaauacuuaucuucpcc\n", + "ggagagagagaauucagagauuuaauaguuuacuuuauauaacuauugcu\n", + "ccggaauucgaggaauucagagaaucggauaucucgcaucccugaucgcu\n", + "uuggagauauuggacuagugauuguguaguuuaauugacauagugaguaa\n", + "cccguauuaucauacuuggagagaguaucuaucucguauuappcc\n", + "auccguuuucagagauaaccugauuuaguagcuaaaaguuuaguaguauu\n", + "acuugacccuauucgaapaagagaguuauuggagaacuuuccuuugga\n", + "uucugaguuauuuguacagaagaaucuucuuacuuuaccgagaaucuauu\n", + "apauuccagagaauaacgcauugagaguuuaucuagcaucccuagaaa\n", + "cccuuuauauaacuauuauuccgauuuccguuacuauuaaucuggauacu\n", + "uuggagaacuuuuucagagagcuauucgaaucaaguuucuaguaaggaua\n", + "uuggauuuucaauuauuauucguuucuuauccgcugucacgauaapcc\n", + "ggaauuupauauacacuuguaaaucguuuuccuuucuucucuuugcu\n", + "auucgguuaucaaaucggauucgaauucuuccuuauccguuccaauugua\n", + "cccuaauucguuauacggagauuuucaguucuuauaccauaaucguuguu\n", + "gaauagagaaccuuuauauucguuggagcauauuaccuuuuugcapcc\n", + "uuggauuccgagauauauuaaguuugcguagagaauccguaaacauuauu\n", + "cccagaagagagaguugaaaggaauuaccuacuuccuugacguaguuguu\n", + "uagagagaaucgagagaggaauccaaagcguuuacuauacuacaauugcu\n", + "gagagagaguuucuacaaguacuugucgauucaaaaucguaacgapcc\n", + "gcgaauuggaguuuuaucggaaaacaaacguuuaccuauuaccupc\n", + "gcaaauugccgauauuauuauaaggaggaacaaauaauccguagucgaau\n", + "uuggauacuuagucuuuucuggaguguaaucuaguaguaauuaagugaua\n", + "cggagaacaauacugugauagauuaagauauuuaguaguagaguauugcu\n", + "uuggagaucguucaacggauaucgagagcguauaccuuuuauacuuugcu\n", + "uagagaacguagagauaauuacaagagacguuuuucuauuuccpcc\n", + "ggagagaguauaaccuagauuauuccgguuuucauauaguaagaauugcu\n", + "ccggauauacggagagaacuuuuuauucacuucgauaccuagucuauacu\n", + "ggaggagagaauuauuaguucguuucgcggauaaaagaauccugauugcu\n", + "ucccguuuucaagaguuauuauauucgcauucuaucccgugaucuuugcu\n", + "gagaguuuguuguaauaauagagagaacguuuaccuuucugappcg\n", + "ggagagaacugagagauuuagagaggaacugauagauuaguaggugagau\n", + "uagaaucccgauaccuagagaauucgaguagaaucccauaccuaauugcu\n", + "uucugagagagaguuucuuauucguggagaagagaacgcugacacauaua\n", + "uuggaauuccgguuuauauugguaucagaaguaguagauuaaapcc\n", + "gagagagaguauuaguagaaguuuauuccguuuccugcauaaapcc\n", + "ggaaggaguuauuaauagagagaguuuaguaguagagagcgugaacuguu\n", + "cggagauauuagagcuuccagagugaucguuaucaaaagaauauuaaaua\n", + "ggaguguagaggauauucggauuauucgcuauaccacgauaauuauugcu\n", + "uuguguuccggagagaagagaguaucguuagauucagagaaaapcc\n", + "uagauauuccguuuucucagagaguuucugaguaaauucgcugacauauu\n", + "gagagaguuuuacaguuauagagagaauuaucuccucuucucuauucguu\n", + "aacugguuuuuauaauuggaguuacguguaguaaaagauaccugapcc\n", + "uuggagaacuuuaucuagauucggaguucgaagaaacgaaggaucugaua\n", + "acuagaggagagaacuagucugaguagauaguaauuaacagaccuacuaa\n", + "gagagaauccaguuuuagaagcuauugagagagaaauuagaauuauugcu\n", + "cccggauuuucgagagagauuugguuaccguuauuauuacgaapcc\n", + "gagagaguuuuacaaguuauauauucgcaucaaccgauauccapcc\n", + "uccgaacccuaaguagaguagauuaguagagagagcguaaccuaauugua\n", + "gagagaauucguuauauauauugcguguauauaaagcuuccuacauugua\n", + "uuggagucguuauuauaauccguuuuauaucucuuaccucuauagguguu\n", + "uuggagagaaucaauucguuaucacucuuagagacguaaappcc\n", + "uuggagaaccuuuuuuuauucgguuuccggagacuaguagucugauugcu\n", + "ggaguguaguguuuagcuaccuaguaauuaagagaucccugaacuuggcu\n", + "uuggagauucggagauaauucagauccguaaaccagaacuagacaacguu\n", + "uuggagagaauuaucuuucaauccuuggagagacgauacugaapcc\n", + "uuggagagagagagaaucguaucuauacggauauauuaucuucauauaca\n", + "gagagaguuuucaaagaggagaaguuuacacaaccagaauccguaauacu\n", + "acuugaacguuuguauccaauucguauccacacccaucgugaacuuugcu\n", + "cccguagagagaacuuuccuuuaccucaaucguauaccguagcacauaca\n", + "uuggagaacuuuggaagagaggaucaacuaguagcaaauccacgauugcu\n", + "auagagucuuaaacgaauucggauuccugcacuucaacguugauagugua\n", + "ucccguauucaauuauccuuuucgcagcuuauacaaguauaucacacauu\n", + "auuggaguauuauuauuauauuccacagauuuaauagcguagaauuugcu\n", + "uuupaguauuacaaaucguuguccaguaucucgcgaagaaapcc\n", + "uaggagauuuuagauuaguaggaagagaaucaagaauuacaauuauugcu\n", + "guggaggagauaucaggacgaauuaccucauugcagacuugagaacuguu\n", + "auuuggaggauauccugauugagagaacguuuaauagagaguucauuguu\n", + "uaauuccuuggagagaacugauagaguagagauuuuaauaaaapcc\n", + "uaauccguuuucauauagcuuaucgaaggagaauuaguagaggauuugcu\n", + "acuugacuggcuauauauccugauccagcuucuagauuaagaaucgugaa\n", + "auugcggauuauauucggaguuuaucaaacagagcuauauaacaaacguu\n", + "auuuagcugguauucagagaauacugcguaaccuaaaaaappcc\n", + "uugcgguuauccgaauagauauauucuuccucuguaagagaaucauuguu\n", + "uggagagaacacuggcauacucaagagagguuauaagcgaacuauucguu\n", + "cccguuuuauauuucagagcuuauaccguaaaacgcuauuaaaapcc\n", + "guauagagaaauuugcauucagauucgcauuccucuucuuauacuuugcu\n", + "uuggagauucggauauucaauuaguagcuaacuaaccgucgugauuuaga\n", + "aauuccuuguaaccaagaauauuauugucguuaccguuacgagaaucguu\n", + "ggagagcguauauauauuaccggauuauuaucuuacuauuuaguagagua\n", + "uagagaguauuauaucuugagaagacuaguaacuaauuagacuagaaguu\n", + "gcauaaucguuuauucccucgcuuauuuucuuucuucugcuccauucgcu\n", + "gcauaaacacuuggauaauaguuugucgugauauaucgagaguuauugua\n", + "agagaaguuaugaaugaaacacagaagauguccuggaaaccuucugcaaa\n", + "cccguuuuuauagaguagagaguguagcgauaccaauccugaguagugua\n", + "gagagaacuaucacugcuauuaaucgaaagcaaagcaucgcuagauugau\n", + "ugcuguggccuccgaguggaauggccucgccucgcuucccccugacgucc\n", + "uuggaguuuauacacuuggauuupuauauuuaccuggauacucauaaa\n", + "aaugauggagaugcugagguguaugagaaagucaccccugcagagagcga\n", + "cccugauaccuagcgugaacugauagauuagcuagaauccuaacuuugcu\n", + "uuggagaaccuuuuaccuuauccagagccuauauacucuguagacauaaa\n", + "aguuaucucggaucaauuccgagaguaucuuuaccgucauaaapcc\n", + "uagagaguguagagcacuaagaaucguucguguagaagauuaguaguaua\n", + "aaaggaguuuuacagaguauauuauuggaguuacuuauuauauucgcauu\n", + "uupuucuuggagaaauuugcaauupaguaucuuuucucppcc\n", + "gagagauugcagauucgagaauuauacccguuuuacaagaaaapcc\n", + "ccuaaaucccguuuauucgcuuguaguaguaguagacuacauccapcc\n", + "uuggagcacagagaauaguagaggaguguaguagaaaagcuuuaauugcu\n", + "gccaauccccagacagcgcagaupugacgucaapaugucggauucg\n", + "gagagagaguucuuggagugaauagagagauuagccaauucppcc\n", + "gagagaauccgauauuuggagagaaguuucugcgcaaccuaaauaauauu\n", + "cccguuuaaagagagaucuguaguagauuagcugauaaucuucupcc\n", + "agucguaucuaucgagagauuguguagagauuaucgccauaauucauacu\n", + "cccguauucgauacaauccguguauagagaguaaucccuugaguaacguu\n", + "ugagaaacaacggaauugcuguucagagagucguuaauuaccupcc\n", + "guauaauccggagaauucugagagaaucugauagagaacugaaacgugaa\n", + "uuuaauucggaguuauccguuguucagaguuuacuauuacgaapcc\n", + "uagcuuuggagauauccgcaucacauauccagauuagaaagapuggcc\n", + "guuuuuuccagaauucugcucagaugcupuauuuuagaauucagaug\n", + "uuggaauagagagaaauuaccuaguaaucgcaccuaccgugaucuuuacu\n", + "gaaagcuuuccaagaugcucauaupaccaaacuugguuccgccauugu\n", + "uuggagauaucuggagagcuuauagagagaguaauaacauaaagauugcu\n", + "auugaauagagagaauaaacugagagaguaauuaguugacgugacauauc\n", + "aucccguauacuucugcuacauucggaguuccuuauacgugaguagcgua\n", + "auuupuuuucaaggagcgaauagaguauuuagagagaagappcc\n", + "auagaaccuuuucgauaauccguugucaaccaauccgaguagaauuugcu\n", + "cccguauugcggaucugauagagagagaacuuaguaaaauuauapcc\n", + "auugcgguuuuuuauccguuauuauuaucuccucugugaagaapcc\n", + "uupauuccggauaccaaauccggagaagaaaguucccugauuauugcu\n", + "cccugccuuuuauaauagagaauccgauuucuauauuaucuappcc\n", + "aucccguuuuuauuauuuccuaucccuucguuucacaacuaagagucauu\n", + "cccugauuccgaagaaucauucgaapagagauucugaagaguauugcu\n", + "uagagagcguuauaaauacauucguacuuaguagaauuaucappcc\n", + "cccguuuuuauucaaaggauauugagagaguauuuaauaaucuggacauu\n", + "aguugagaguuuuuuacaaaucguguaccuuuucaucccuaguuauuguu\n", + "aauuccggaaaaaaauuccugucaaguguagaaaguuauaucapcc\n", + "uuggauaccuagaaaacuugcaucccuaaaccuugcauaucugaauugcu\n", + "gagagaguuuauacacguauauauucguuaucacugcuuuaaucpcc\n", + "ccggagaaaaguuauucaaagcguaucguagagaagaacugaapcc\n", + "auuggagaguuauucgcguauuuaggagcauuaguaaaauaaucpcc\n", + "auuggagagcauuuauagcagauauugcguuauccggagauuuggauacu\n", + "uuggagauuuauuaguucgaguuguuuuuuauauccuggaguuuagcgua\n", + "uaaauucguuuucaauaggagauugagagaauuaacgcgugauuaguauu\n", + "gagagaguuauucgaauccgaaucuucucuucuauaaccuaagapuc\n", + "gacaacupaugauugguuucuggucuuggagaggaagaugcucaggag\n", + "ccggaauugcggauauucgaguuauuuaccgcgcaucuuuappcc\n", + "auucgguuuuuauauucgauuuggagagaguuaguaauaagaguauugcu\n", + "ucagagcccuaauugauagaguagaguagauuaguaguugacuguaggau\n", + "uaaggauuucagagaaucguugaucuuagcuacguguauuuagcugcuaa\n", + "gagagagaaagagaauuccgaaccuaccuagagagcguguagapcc\n", + "uuugguuggagagauuaguagauuaguagagaauucgaauccgauuugcu\n", + "gagacguuauauugaguguuauugagagagcuaucuuagcaagcuuugcu\n", + "uaaucccguauuuuauuaccucuucuucuuccucaguccuaagaguuguu\n", + "uupauugcagauuucaguuuccgcuucguuacaaguauugupcc\n", + "auugaucccggaaucuagagaauccguuuucuuuuaccgaucccauugua\n", + "uauuaaaaguuuuuacgagagcuuuggauauaucagaagaaaguauugcu\n", + "ggaggaucaaggauccuuuggagaaucguaaacguuucuuucuauacguu\n", + "aucccguuuuacaaauucaaagcguuuucgaguacagaguacuagaaguu\n", + "ccggagagaaagagauuacuugugauagaguaauccaaaaaaapcc\n", + "auuggagauauauaaguuuggagagagagauuaauccgugaucugacuaa\n", + "ccggagaaacuuuggagauuucgagaguuaauagaggagagappcc\n", + "gagagaguuuauauacuucguauacacacggagagaguuuappcc\n", + "uguccucaauccguagaggagaguguagaggaucguuuauaaagapcc\n", + "uagcuauugcgagaauaauagagagaacucgaauccgauauauuaguauu\n", + "uuggauuagaaguuucgagaaucuuauccaccacuaacgugauuauugcu\n", + "gagaggauuuuauauucgguuuuacaagaguugcaaauacgauugguguu\n", + "uagaaccuuuacuagagagagauuuaguggagcguaaauuappcc\n", + "uuggaggauuaaaaauccuuucccgcacaacuaguaaaauaaapcc\n", + "cccugauccgaaucaauaccaauccuuauacguaucguguagaggauauu\n", + "ggaggagagauuucgaucaguuccgagaaucuagaguagaauacuuugcu\n", + "uuggagaguuuacuuuggauuguacuucgagcguaucacaaaucauugcu\n", + "uaaucccguguauaaauauuguguuggagagauuuaaauuaaaapcc\n", + "uagaauccuucguuauucauccauugucauacacuaaccugauuauugcu\n", + "gagagagagagaagaauccuuccugucguagagagauuauaagcauugua\n", + "uaggaauccggauauucgcauauacuucauucgcgaucauaauuauugcu\n", + "auuggaguuuuuacaaguuaucccuuuucagagcaucccugaaucpcc\n", + "ggaggagagaaguuucgcuuauuggagagcgagcaucccugaucauugcu\n", + "cccguuuaauccagauuucgaguauugcggagauuaaguaucuapcc\n", + "auuuagucccuuuuucaagucucuguauuaucagaacuucgaguauugcu\n", + "aucccguauuuauuauaguagauuuacauauccgucguuuacuggauacu\n", + "aggagaaccuagaaucgcacucuuaguccguauuuaguaaaagaacgaua\n", + "auuggagauauauaguagaaguuugcauuaacgaauuggagaucauugcu\n", + "uuggagagauuauacgaggagagaaaaguaucuauauccuaaucauugcu\n", + "uaauacacuuggauauuguggcauucagagaauucucauauucpcc\n", + "uccgguuuauagaagagaaguauuaguuugucuaauucucggacuaaaua\n", + "uuggaucacugcaaauagaauccggagaacguuauaaacuaagcauugua\n", + "gagaauacguagagaaucguguuuucucuucccuccuuuuucapcc\n", + "uuggagagaguuauucgagugguuauacagcuuauuuaguappcc\n", + "gaaauugucagaguuucauuggagagaagagaaaaacgcugaucuuugcu\n", + "aauugaauucguuauuagaaucguuuacccuuacaauuauccacuuggau\n", + "uauuggagagaauuacgaguaucuuuucguuaucuaccauaauuauugcu\n", + "cccggaauucggauucggagagaauuacuauuguguacauaauucccauu\n", + "cggagaguuuauucgagccauugugaaguauuuaauagaguaucuuugcu\n", + "uagauuucgucguuauuaucagagaaauacaccacuacauaagcauuauu\n", + "auugauuagcagauauucggugauagaucguuaucuagcugaguapcc\n", + "aauucgguuuuacaaucccguauuuaauaguaucuagcgugauucauacu\n", + "uuggauuuccggauauucgcggauauauaccaagaauccugaaggagaga\n", + "auucggaucaaagagaaucggagaggaguagaaauccggauauaauugcu\n", + "uuggauuaccuuauccggauaucguguagaguaucucugaucugaauaua\n", + "auuggagaaucgagagucuaaguaauapagagaagaguagcaauugcu\n", + "uauugagagagagagagauuccggauuucuuauccuauuuaggagaaguu\n", + "auuggagauuuucgagaguuuuggagagaccuaguaaucuaguapcc\n", + "auuggaucacuuuucuucuuauuuggaguaaauuaccuguaaguccugau\n", + "acuaauuccgguuuauaauagaguuggagagaagaguccugagaaucguu\n", + "uuupauuacuaguaauuggagaaucguauccugaacuagaagucguu\n", + "uuggauuaaauaucaagaguuaaauucguuuccuuaacuaguacuaaaua\n", + "uuggagauauuuuauauaucgugucguguagagaguacuugagcuuugcu\n", + "uucupauucaaagaaguuuauuccuuauuuaauagagcguacapcc\n", + "gagagauuguccuuuccaguuauaaccuuuauccguacauaaapcc\n", + "acuuggcuuauauugucgcaguuucgaagguuauuacaaucauuauugcu\n", + "ccggaauucggaucaaacagagaaucuaguaaccguaaacuacaaguauu\n", + "gagauaccuuagcacuagaaucgugaagagagaucguguagagcauugua\n", + "auuggagaggauuucuagaaucguauccuaaaccagaccugaucauugcu\n", + "uaguucguuuuuacagaauccgauucagaguacuacaaauccugapcc\n", + "auucgcuguuaagagaauucgagaagauuccgaguucgagacuagaaguu\n", + "cccauaucuuagcagagauagaguaaacuaguuacuguaggugagagaga\n", + "acugaucccuagauauaaucccuuggauauacuauaguguaacguguaga\n", + "uauugaguuauuucuauuaucguguuggaaagagaaccgugaauapca\n", + "ucccguuuuauauauauucucguaccuuuucuaucguaucguguagcgua\n", + "uuuggaggauaucagauuupaaucuuagaucguacauaaapcc\n", + "gagaguugagagagauuugguuaucccguaguagaaucgugaguaacguu\n", + "cccugauccaguuuuacaaacuucgaguuauacaagaguaucaauuuagu\n", + "acuugaacugcgaauuguaaagcguguagagagaguguagagaaucuauu\n", + "cggagauuguguaauagagapagaaguaguagaaucgugaauaguauu\n", + "starting nats\n", + "cucccuuccaggucaauccaaacuggagcucaacuuucagaagagaaagacgccccagcaagccucuuucpaguccucuagcuccucaccucc\n", + "cagaggcccggcgaccuccapcupaagucaaccgagguucpcagcggcgapcuccpcga\n", + "gucaauccaaacuggagcucaacuuucagaagagaaagacgccccagcaagccucuuucpaguccucuagcuccucaccucc\n", + "ggccggcggucugcgcccugcgcgccucggcuucuuuccgcccggcuccuucagaggcccggcgaccuccapcupaagucaaccgag\n", + "agacaagguuucccucuguaacccaggcuggagugcaguggaacuucugagcucaaguagucuucacaucucagccuuccaaguagcugugacuagag\n", + "cuugugacaguccagccccuucagccuggaguuccaccuaccaguccccacaugugcugucucucaccaagguugccagugaccucugaccaaaacaaucuu\n", + "cccgcugcccaggauugguaggcuccaccgcucggcagccggcuucccugcucggacgccgagcaccgccaaagcgc\n", + "acuucgauuuucagaauuccuccupaaugcugacuccuugcuuggugcccugaugcuucucugagauaaacugaugaauuggaacc\n", + "cuggcgcccgcucggagcggcgccgcgcupagcgacugacgccccgcugccpacgucpcupccuggccagucccccagagcuupag\n", + "auugcaucupuagaauuguggaacaagcaccaggaagugaaaaagcaaaaagcuuuggaaaaacaga\n", + "ggccugaaguaaucaaaccugucuuugaccuuggugagacagaggagaaaaagucccagaucagcgcagacaguggugugagccugacgucuaguucccag\n", + "uauagagauaaaacugaauccuauuaccugcagguccucuacupagcaapaaaggagaaagcaguauuuugaggauuugagag\n", + "aggauugguaggcuccaccgcucggcagccggcuucccugcucggacgccgagcaccgccaaagcgc\n", + "cgcucggagcggcgccgcgcupagcgacugacgccccgcugccpacgucpcupccuggccagucccccagagcuupag\n", + "cccccgcugcccaggauugguaggcuccaccgcucggcagccggcuucccugcucggacgccgagcaccgccaaagcgc\n", + "aauagaggaggaagccugcgaucuuuaggauccgccuccaggcccagaggapagagucacaaaugacagccuuggccgugagapccucuucuuacuaacccccacugcgccauaugg\n", + "aguugcuuugcuguuagccuguuggaccuucgagccuagcugcucgcacaggacucggccaccugcccuuccugcaccgacuggccag\n", + "auucauuupaucuggaacuugucacugucccacugcugccucgupcucuuaggucuuuuguppaupapuguucugaagaucauguuuuugaagaaaaguacuuuaauuuuugcc\n", + "guaguccauuccgccggcgccggcgcuggcgcugcugcpcucggcgccggccuuugucugcpcacgcgccgcugcg\n", + "gugcucaggaacagcccauggaagaaucauaugaagagguggugacugaggucguaagcaggaguggac\n", + "gcggccgccaaggaaaugagcaggccuggccggcccpccccgapaggccagccgcgagcggagaggucggcgguccgcagagcapucccguggaccggagagcpaugccgag\n", + "gugagcgugugugcgugcgucuacuuuguacupaagaacacagcccaugugcucugcauggacguuacugauacucuguuuagcuugauuuucgaaaagcaggcaag\n", + "paagaacacagcccaugugcucugcauggacguuacugauacucuguuuagcuugauuuucgaaaagcaggcaag\n", + "guguugacagcggcggcgguggaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "cggcgguggaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "ggcgcguguugacagcggcggcgguggaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "agcggcggcgguggaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "pcggcgcguguugacagcggcggcgguggaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "gaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "guugacagcggcggcgguggaaccpcpcggcpagucggcgccucpuuccuaccucgcgucccuaggcggcggcggccpcgucccp\n", + "guaaguucaccgccggucpuccggccgccgcgcuguccagcuccugagaccuugcuguccgccggucugccgucugcgcgccucacg\n", + "agauuuccapcucugagaaaaggaggaggacgcagacucugcucuucagauccacaugcugauccccacuacaaucagugaccugaacucagaguccaaguagg\n", + "cugagaaaguggaacuccagagacacuccugaaauuguccuaagucaaaggagccaaacgguguacgagcucccucucugccguccccucugagagcagcc\n", + "guggauugucaauacaggaguccauacugacugaaucccuaauuuuggccuguauucuucucccucugugaaccaucuucuuagaagucacug\n", + "aaccaagagugccagaaaaccaucccaagacucacacagaguuguucuuccauaguggauguuuuggccacuggacaucagaaccacauuuupuuugaagaaucuucuacaug\n", + "pagugagcgacacagagcpccgccaccgccgagcagcccuccggcagucuccgcguccguuaagcccgcpuccuccgcgaaucggcggupuccggcagccga\n", + "uccugagauggccccagaucugcaagagacauuugagagaagcuauuuauuagcagacgugaagaaauggauucugcacuugauuauuuagccaugacuuauca\n", + "agagccuucccugaucugccuccagcacugcccauccuugccccuuuccacuguccuuggagcuuccupcccuucccupccucaggaucccacccuccaucccgucugcccugcagg\n", + "paupcuccugcugagugguggugacaaguggagccgccaccgucggauguugacgccugccuuccauuucaacaucuugaagccuuauaugaagauuuucaacaagagugugaacaucaugcac\n", + "augacagaaagcucuuccccugcucugcccccaagacccauccucucccugcgacaucuguggagauuucucaaggacacggcuccap\n", + "cugagauagcgcuuccccauugcucacaugacagaaagcucuuccccugcucugcccccaagacccauccucucccugcgacaucuguggagauuucucaaggacacggcuccap\n", + "gcagugacaccucaacccccagcccuccucacacccccacupcuccugcauuaagcccpuucgcagccgcagccpaucpcacccapcpcpcacgguapcc\n", + "ggcuccugcauuaagcccpuucgcagccgcagccpaucpcacccapcpcpcacgguapcc\n", + "cacacccccacupcuccugcauuaagcccpuucgcagccgcagccpaucpcacccapcpcpcacgguapcc\n", + "auuaagcccpuucgcagccgcagccpaucpcacccapcpcpcacgguapcc\n", + "gcaugcgcauagcuaaccgcacccgguucagcucgccuuucuuggccagaggcgccgguuggacucacpcpcaug\n", + "ccpcuugucggugaagcggcaguggcggcggcggcggcggcucggcaggcpuucaggcuucpccag\n", + "gagcggaaguggccggcuagagccpcupcpaccpcuugucggugaagcggcaguggcggcggcggcggcggcucggcaggcpuucaggcuucpccag\n", + "ccccacucapcagcapccgcucccuccguccuugccucccuuacccacccucaccggcccuuguuucuccuuccccupcagccgccgcc\n", + "gucggugaagcggcaguggcggcggcggcggcggcucggcaggcpuucaggcuucpccag\n", + "auuggaacaggcugagaucugcuggagacaacuuaggaaauuaucauagugaaaauacuaacauggauuguugaucaucugaugcuaugauucuuucccaggcaccacaccuguugguguucag\n", + "caggcgccaaggcucuggcaguuggccagcacaccacuacgcaugugugucaacucuapuupugcupuugcggcuuucgguuaacaccgcag\n", + "gucuuaccpccggacugcgcagccuuuuuccpcacacupaguugugguuuaucgccucuggacuaauggcu\n", + "aguuggccagcacaccacuacgcaugugugucaacucuapuupugcupuugcggcuuucgguuaacaccgcag\n", + "ggcgcaggcgccaaggcucuggcaguuggccagcacaccacuacgcaugugugucaacucuapuupugcupuugcggcuuucgguuaacaccgcag\n", + "agccuuagcaacagguggacuagagaggcpacuccagccagcacaupaaagaccugccggcuuggcgcagg\n", + "guaagcccugaggaggcagcguuuucupcuucugucugguucucucucuccagaagguucugccgguucccccagcucupuacccggcucugcaucgcgucgcc\n", + "gcuucugucugguucucucucuccagaagguucugccgguucccccagcucupuacccggcucugcaucgcgucgcc\n", + "gucugguucucucucuccagaagguucugccgguucccccagcucupuacccggcucugcaucgcgucgccaugaupccaucguccagugcucgugcuca\n", + "uuaggucuagcuuuauauucuuggcccaucccuuaguagcgguaauuuaaauguuucaaucuguauuacggaguuaacaguauuuccuaguagaauugugagaauuaaaugag\n", + "agcpuugagguguaagcccugaggaggcagcguuuucupcuucugucugguucucucucuccagaagguucugccgguucccccagcucupuacccggcucugcaucgcgucgcc\n", + "guggaagaagacagcaggcggupcauucacugugcuggupaagucugguuacauuaagaaaggaauucuagcaaaguuauucuguaaauacaacagaaucaguugcuuuuguuaaauauauug\n", + "auccccugugupaccugcccagguaggcgccaaccauugguuauaagaaccugaccuuggcgccuccapaaacgcggaguguccuggagcuugacgcgcuggagcuugagag\n", + "aaaacagaaagccccugcccagcgagcagcgguuuccgcpcggaacaaacaggcagagccaagugcguccuggaggcuucccccguugcgaag\n", + "guaacuugacaaagauguuucaguggucucggaaugcaagacagaauccugacgguagaaauuucuaggcaapucuaaauuaggcaaacug\n", + "cucucuuccucucucccucuuucuccucucucacccacacucacgcacaccuccaaaccgcacacccagacgcacacgcauaccccagcgcccggcaguu\n", + "auucaagucaaucugaaagucccagccagccaagugacgcugacauuaaggaccagccagaaaaug\n", + "gacauuupcuuccaggacaguuuugucacaucagguguuuuuagugucacugagcuaguaagagugucacaga\n", + "caccaauagcugcaggaacuggcccaaauuuuucucucucagauuuggaaaguucuucauacuacagc\n", + "uuuuuuuuuuacccaugauuccauaugguauggaccggacuacauguugccccacaugccacugcaaauguuuucucaauuaggugucuuaucucccgugaguuagcaucag\n", + "cacccacacucacgcacaccuccaaaccgcacacccagacgcacacgcauaccccagcgcccggcaguu\n", + "agaccaacucugagcauuuucuugccacucacuccuuugcuguugguuugcuuauuuuucuguggcuuggaauuuuaaacuuucuuuggacauaccuaauauucaucuuuuauuguuguuc\n", + "gaugaauuucauccuuucaucgaagcacuucugccccacguccgagccuuugccuacacaugguucaaccugcaggcccgaaaacgaaaauacuucaaaaaacaugaaaagcgu\n", + "cucucucuuccucucucccucuuucuccucucucacccacacucacgcacaccuccaaaccgcacacccagacgcacacgcauaccccagcgcccggcaguu\n", + "acaaugcuuugagccuuaccgcauuucagupaaaaaaaguuaccuaggaggucugauuuuucaaagaaauuugcauac\n", + "pucugagagugucagcuuccupagaagcacggaccgcgcaccucugagcugccapupacgcugcccuagcg\n", + "guguccaguugguugccgcggcagucucuccgagcagcgcauuugucuucuaggcugcuugguucgugccuccgagaaag\n", + "pucuccugcugccagcuaagugupagaacuugugcacguaucuccccuccgaaucccaacg\n", + "uaucauuuguggaaaagauuaucuguccugcauuaaacugcuuuuggacuuucgucuaaaaucaguuggaccgguuuuuguuggcaaaguuuugccugaagcuuauuccaacag\n", + "aggcagugaggaaagaagacaugacacagccaacaapuggcagccuggcucugaaguggaauuaugugcuucaaacagguugaaag\n", + "guaaauacuacccacgaccggcggcgccggauuccuugcuuggcggcapcggaacaaggagccuuggagcpcaaag\n", + "gaggaagccagugaagguggaggaaaugaucgugugcggaaccugcaaagugagguggapaguuaagaauauu\n", + "ccaagacaaguucaggaauuugcuugucucugcucaaaugcccugguugauaucugagaaagaagaggcaggcggaucaugaggucaggagacugagaccauccuggcuaacaug\n", + "guuaccacuuggaaaacaauucaucugaaagaagcacagauuuucucaucuauccugucaacaaagaaggaaucaagagagcaaggacagugauuuccccugcauugcauuugu\n", + "uucapaagcgcggccacgccupccggccaccauuucccpcgccgcggcggcgccgacucgcpcagcggccccucagugcgcccagccpcccccgaacgccpagc\n", + "guuggcauupacugacuccagccucugcuccpaggcccucccpcugccugaccucccpacc\n", + "ccpcgguuggcguccucugcggcuccugccapcpcuuuucaaaucuucccuuugaaggaguggcgacggcccggacaguucgcguuggag\n", + "cagcpugacggagcggcgagacgagcgcacagcagucgcggcccpagccggagcugccgccgcaccccpaaggcugccuugccgccggcccgccgaccgcggccggacgaag\n", + "ucauugacacagugapaggcaaaacaguguggaugcagcagaauaaccacaaccaggauuuugaacugaauaaguaag\n", + "aaagauuaucacuuugaauauacggaaugugauagcaguggcuccagguggagaguugccauuccaaauucugcaguggacugcucuggccugccugacccagugagaggcaaaga\n", + "acacagugapaggcaaaacaguguggaugcagcagaauaaccacaaccaggauuuugaacugaauaaguaag\n", + "aaagauuaucacuuugaauauacggaaugugauagcaguggcuccagguggagaguugccauuccaaauucugcaguggacugcucuggccugccugacccagugagaggcaaagaaugca\n", + "auuguauugcacaccucuaaaaaaaacacugccucugauuuaucaauauaaaaaagauccucugagaggaggapcacuuuugugugauggcaacuucacuucuap\n", + "cguggugcuugcucccgaaucagacgccggcagccaaacuuguccccuccuguagaguaggaagcggccpcgccpcuguupugccag\n", + "auuguauugcacaccucuaaaaaaaacacugccucugauuuaucaauauaaaaaagauccucugagaggaggapcacuuuugugug\n", + "ggaaauuuggauaugugcagugcaucuccucgaagaugcugaugguggaaauuucuugaaaccgcucucguaauuugccacg\n", + "ugcuguugcaaauauucuggugaaugaacacagaaucagcauggcuuuccuuugcugagaaaucacugaupaagugagacuuguuaaacuugaaag\n", + "gucacpccgcacggccgcggccgccaucuugcccgcguccpcuccugcggcpcpcggugucccggccggaagcggcugugcggcggccgcgcugccaccucag\n", + "ggcagcggcagcggcggcpacgcggaggcucccccpauucggccucagcagcgaggcggcggcggcggcugcggaggcgcaggcagcaacugaggcagcggcaggcucaggugcagccgcug\n", + "gcugaacauaacuucuuuuuuucaaaguucccuguguugugaacugagcuupugaagugaaaucuuugag\n", + "gaagcuaaagcuguguguauuuguggaucagacaagugcagcaaguuaauaucauuggcuucugaapagagugaggug\n", + "aguuucacuauugucacccaagcugcagugcaauggcgugaucucagcacacugcaaccucugccucccagguucaagcaauucuccugccucagccucccgaguagcupauuacag\n", + "uauguuucagcagaaaucaagguagacgaaguaaccucuuguccugaauuuucauaguugcucauucuuaauaauggcagcagaagcaacaaugagaguaacuaccuccucag\n", + "aaaacaaaucuaagacugaauggcupucuacaccuucagccaaccaggucgacccggcucggcaggccuccucccagcucccaguucacccaaaaacaccugcacuauaccaagacucag\n", + "uggucaucaggacupagaaugacuuaaccuccgcuuccuuaucugcaaagugcgaacgccaguaccaccuaccuuauapuuuuggcaaagacgacucgagag\n", + "gguaucuccucugapugaugcugacccagauggcpcucgaccuggaggaauuuucccgcuaucugcaggagcpaacagcgucugcugcuc\n", + "ggaggcugcggagccggcggccgcpagcugacccugcpucccppapagccgcgaagcccccacugaggccgccgcugccpccuccccucccccccpcpcgcc\n", + "gcggccgcpagcugacccugcpucccppapagccgcgaagcccccacugaggccgccgcugccpccuccccucccccccpcpcgcc\n", + "auacguagguaaccuuuccagagaugugacagaaguccuuauacuucaguuguucagucagauuggacccuguaaaagcuguaaa\n", + "uagcaacgaggcacaacaapacupuucgucugcupuuugcggagcagcuagcuacucggcpaucucccggcag\n", + "gugaggaaaauaaaacaacccuccuugaacuuggagcuguggaaccuuuaacuaagcuacucacccaugaagacaaaauuguaagaagaaaugcuacuaugauauuuggaauccuggcuucuaaua\n", + "augauguuaaaaaauuguuaapaguuagaugucaugaauucugucauugcccagcucgcuccagaag\n", + "caacaapacupuucgucugcupuuugcggagcagcuagcuacucggcpaucucccggcag\n", + "gugaggaaaauaaaacaacccuccuugaacuuggagcuguggaaccuuuaacuaagcuacucacccaugaagacaaaauuguaagaagaaaugcuacu\n", + "guucuuuuucuaauuccaaauaaacuugcaagaggacuaugaaagauuaugaugaacuucucaaauauuaugaauuacaugaaacuauupacag\n", + "agugauuugccccggaucaaaacggagauugaggccuugaagaaccugagacaucagcauauaugucaacucuaccaugugcuagagacagccaacaaaauauuc\n", + "aacccggcgaucgaaaagauucuuaggaacgccguaccagccgcgucucucaggacagcaggccccuguccuucugucpcgccgcucagccgugcccuccgccccucag\n", + "gaucgaaaagauucuuaggaacgccguaccagccgcgucucucaggacagcaggccccuguccuucugucpcgccgcucagccgugcccuccgccccucag\n", + "acaacccggcgaucgaaaagauucuuaggaacgccguaccagccgcgucucucaggacagcaggccccuguccuucugucpcgccgcucagccgugcccuccgccccucag\n", + "guaccagccgcgucucucaggacagcaggccccuguccuucugucpcgccgcucagccgugcccuccgccccucag\n", + "gaagcggugguuuuuagcggcucucupuagcapuggugugauagcggcagcgapcucggagaggugcucggauucucguagcugugccgg\n", + "cccacaaugauucugagcuaaaacacaaaauaaaaaccagauucauugccaccagcgcucaccucgccugacuuaaaaaaaag\n", + "aagcagaggccggaagcggugguuuuuagcggcucucupuagcapuggugugauagcggcagcgapcucggagaggugcucggauucucguagcugugccgg\n", + "ccgcccuucgccgugcccuggaaugugcggccaggcaaagccacaggacggacgcaaccaucugcggaaaggauappaggaagacuuaacacugcaacaacag\n", + "ggcuccacgcuggccaggaggaugaaaggccccagcupcuccuugccaccagugcugugucuuaagagcugccaucccggcugg\n", + "agugcgucggcgaaacgcacucucuugcpugucupcuacggcugcpcgcccpccccgccgccuccggcuggugcagaucpcccggcggccccgacucg\n", + "ucccucucucccucccucccagcuccugcaccaggaaacggcccggaucccggcagcggccugacccgugagaucccuaaccuggcaggcpcpuuggagacuggcugaggup\n", + "uccugcaccaggaaacggcccggaucccggcagcggccugacccgugagaucccuaaccuggcaggcpcpuuggagacuggcugag\n", + "guacauaaauaaaggauaaaauauuuuaugaaacaaaucuucaaucaaguauaacauuuugaugcuuggcaucuagacucccuugugcccucacu\n", + "pacgaugaaccugagapugcgcgauggcgccagcuggagugcggcuggcggaggaaggagccuggcggcpuupcugg\n", + "aaggauuugaaauuucccugcccaagaaucaacaggaacucuguuuauagaccagaaaugugacaucuaucuuug\n", + "acupcccpacgcgccggcggcggcggagacuccpcugcggcgccgcccgccccgcccgcagaguccggcugccgcgcaucguccgcagacgccgccaccgccaupcuccugag\n", + "acuccacupcccpacgcgccggcggcggcggagacuccpcugcggcgccgcccgccccgcccgcagaguccggcugccgcgcaucguccgcagacgccgccaccgccaupcuccugag\n", + "cccucgcucccggcuuagaggacagcpaaggcpcggupcapccugaagcggcgguaccggugcuggcggcggcagcugaggccuuggccgaagccgcgcg\n", + "paaggcpcggupcapccugaagcggcgguaccggugcuggcggcggcagcugaggccuuggccgaagccgcgcg\n", + "ggaaggcpcggupcapccugaagcggcgguaccggugcuggcggcggcagcugaggccuuggccgaagccgcgcg\n", + "pcapccugaagcggcgguaccggugcuggcggcggcagcugaggccuuggccgaagccgcgcg\n", + "gcucccggcuuagaggacagcpaaggcpcggupcapccugaagcggcgguaccggugcuggcggcggcagcugaggccuuggccgaagccgcgcg\n", + "guucaaucaauucuccugcuucaaccucccgaguagcuggaacuacaggcacaugccaccacgcccag\n", + "uccgcgccgcaucgcucpugcagcgcagcucagcgcagcgcugcggccuuucggcagccgaacggccgcggcag\n", + "cauuuccuuuacaggcugcacuuccuucccugcugccagccaggaguuucggaagguuuccuggaggaagugugauacagcag\n", + "agccccggagcggcucgcggccggcuccgcgccgcaucgcucpugcagcgcagcucagcgcagcgcugcggccuuucggcagccgaacggccgcggcag\n", + "gcgcgcuccccgcccccagccccggagcggcucgcggccggcuccgcgccgcaucgcucpugcagcgcagcucagcgcagcgcugcggccuuucggcagccgaacggccgcggcag\n", + "cccgcccccagccccggagcggcucgcggccggcuccgcgccgcaucgcucpugcagcgcagcucagcgcagcgcugcggccuuucggcagccgaacggccgcggcag\n", + "ggaaaucccucccuguguaauguugcaacacacaggucuaccacguggaaacuugcaaagauguaupuagaacuaaccccuucugaccucucaauuaaggccuuuaaaugucuucuguccauu\n", + "ccccgcccccagccccggagcggcucgcggccggcuccgcgccgcaucgcucpugcagcgcagcucagcgcagcgcugcggccuuucggcagccgaacggccgcggcag\n", + "guucgcaucugccucggauggupagauuuuucuuuccaagaccuuuucaucgccuugcapucgauuucccccccucguccccccaacuacaaaagagcacgacucgcuuu\n", + "ggccuugcuuccauuuuccauuauuauguggacuaccggagcgacagcgcaguccaagaccuugcag\n", + "ggaagcggcugcgguucucgccgguucucagccpuuugauaguugucaggaggauucgacguucagugcccapauguggag\n", + "agucucacucugucacccaggcuggagugcaguuugugugaucucaacucacugcaaccucugccuccupuucaagcgauucuccugccucagccucccgaguagcuggaauuacag\n", + "cuccgagcccuggaggagcagcacggagcpagagcguggcgagagaaugaagaaaccaaucgcccpagaagc\n", + "pcggcgagcaggcccpagccpaggcugcpcggcggcgcuggacccgacgcggcgagagaggccccgag\n", + "gcacccccuuapacgguggcgacpucugaacucugcucccccacccgcaggcgcggaucaagaagauc\n", + "cuccaaaugaccacuugcuuuauagcaaucggucucagauuuauuucaccuuggagucucaugagaaugcacugcaugaugcagaaauagcauguaagcuccgcccg\n", + "ggagcugcgaggcgcggcgcagagcupcugcgcpccpcgagcpaccaggcpagccauggaccgcuapcccggccuagccccgcg\n", + "cgccgcagcpagcpagccggagcugcgaggcgcggcgcagagcupcugcgcpccpcgagcpaccaggcpagccauggaccgcuapcccggccuagccccgcg\n", + "aggcgucuguucucggcagcggcacagcgaggucggcagcggcacagcgaggucggcagcggcacagcgaggucggcagcggcacagcgag\n", + "auugcgccgcggcacggccuagcgagugguucuucugcgcuacugcugcgcgaaucggcgaccccagugccucgaccacu\n", + "guggaguuuugcucuugucgcccaggcuggagugcaguggcgugaucucggcucacugcaaccuccaccucccagguucaagcgauuuucccacuucagccucccgauaagcugagauuacag\n", + "aguuuauuaaccacuuaaccucucagaacugaacaaagacaacauuguuccuggaacgcccucuuuuuaaaaaag\n", + "uuaaccacuuaaccucucagaacugaacaaagacaacauuguuccuggaacgcccucuuuuuaaaaaag\n", + "guagaacuuuagacuucauagcacugaauuaaccugcacugaaagcuguuuaccugcauuuguucacuuuuguugaaagugacc\n", + "cccpaagcugcgcgapucgacagccuccgccacauccuccaccucucuugguccagcgagcguugccpccapucaagcggapcuccgacggcgcggacggagcgaagcgccgagcc\n", + "cucuucuucagccccaaacucacaucuccggaugcacagcuucccacaggcggcuugauccucauugaauucagauuucucugcauugauaauccugaggccpaaaug\n", + "ccacggaagagcugaaggaauucuuugccaaggcacpcuggcucugugcggcucaucaagguugugauugaggacg\n", + "agacucgaacagacaugcgagaccucuaccaacugaagguuucgugagcgcacuccuuugccaagaucuuggugaauagucuuucacugugcaauuuuaucuuagaaauuguuuuacguuugauc\n", + "gccgaapagaaacaagagugcagccaccaccccugagccaccuguggcucugcuacccacaauuucacugugaagagucagcugccupccgugaggucacugccacc\n", + "ugcuguccuauauaauccauggaacaacccugagaaauuguccccauuuuacagaaaaggcagcugcuauggcuucggagcaa\n", + "cucagagagaaugaacccagauacaaggcagcucuuguuuuuaaauggagugaagcuuaaguggcugcagagaagccacaaagugugcugcagagaagccaccagccuggaga\n", + "aaccugcaucccuccccaaaaccaacggcaagcagcuguguccucuccacuugcagcuggaauaggcaguuugaugccuuugcugcgcuggcaacapcucucucucuuggaugucucagcc\n", + "aauupaaauagcccccuggccuccupacgugagaaugcuguucugugugaagcucaggaagaguggcupaaacagcaguugaaucgugaacaugauuuuaaaagccucuccaagcag\n", + "gcugugucuuucuaucacggauuuccacccggacacguggaacccggccuggucugucuccaccauccugacupcuccugagcuuc\n", + "uaauugaaggccugaaacgcccaugugccacugacuaggaggcuucccugcugcggcacuucaugacccagcggcgcgcggcccagugaagccaccgugguguccagc\n", + "ggcccgupaguaucuguccugccgccuucgcccacgcccugcacuccpaccgucccugcgcgcucupcgcacc\n", + "acccggcccgupaguaucuguccugccgccuucgcccacgcccugcacuccpaccgucccugcgcgcucupcgcacc\n", + "aucuguccugccgccuucgcccacgcccugcacuccpaccgucccugcgcgcucupcgcacc\n", + "cuuuccccgcgacugcgccacgucugaggcggcuguggccgcgucgguguccgcgucgaggagccpcapcacg\n", + "aagagcgccuggauccauccgacagccgcpugcguggucgugcggcaagugagcgauuuggugaacagacacucccuucuguag\n", + "ccgacagccgcpugcguggucgugcggcaagugagcgauuuggugaacagacacucccuucuguag\n", + "ugacaaaugagauccucuauupcuuuaugucuaaagcuugcauuucaagcaauuuccucacucgaggucaggaguucaagaccagccuggccaacaug\n", + "gaggagcagcccccacaacaucgauccaagappcucagupcggcgugugcuaccugucg\n", + "agagcucggagcggcggaggcagagaccgaggcugcaccggcagaggcugcpcggacgcgcpccggcgcagcc\n", + "agcucggagcggcggaggcagagaccgaggcugcaccggcagaggcugcpcggacgcgcpccggcgcagcc\n", + "gccugcagagcucggagcggcggaggcagagaccgaggcugcaccggcagaggcugcpcggacgcgcpccggcgcagcc\n", + "gaaauupcugcgapacagaggaugugcugcuggccugcaccggaauugacagaccagaaagugaugaaauggaaaucagccagaaccgacggcgcugcggccucuggacgucp\n", + "agucacagcagcaagcaagucuagugaacagauaagaugacaugcucagcaaaauaacaacgaaaccagag\n", + "gccucccuccuuupuucgguaucccuacuuccauuacccucggcuccucccacuccucgcpcuccgugcuuuccgcpucuguccpcuccggacccucggcgcag\n", + "cugaguugauggcuuccggagaacuggcauagcugcagaauaugaguagugucccaagaagagugcuuugccuuuggcacaaggaucagaauaaag\n", + "auagacugucuucaagcucacugauauuuuccucugcuugauccauugugcuguugagagccucuaguaaauuuuucag\n", + "acugacagacuucaaggaugcagcugcuacuaccggagguguguggcaccuuaccucagcaaggccaugagaccguguggccaugaugupccccuc\n", + "gaggcugccpuagcccagcaggccgapaggaaguagcguggagccggugccgagccpcgaagcuggauccccuag\n", + "augcugccaugaaagcaggcccaccuuuccuuacuggagaauauuuugugaauuugauuuagaaa\n", + "uucagacugacagacuucaaggaugcagcugcuacuaccggagguguguggcaccuuaccucagcaaggccaugagaccguguggccaugaugupccccuc\n", + "gugcgcuugucacgcguggcggugcgugguugcuapcgccugaggcugccpuagcccagcaggccgapaggaaguagcguggagccggugccgagccpcgaagcuggauccccuag\n", + "gccggcgcccugccuggcccggcggccuccucucpcacgaaggcuugcugcugcuucuccagaacuucccuuccucguagacacag\n", + "agcccagguucaucuacauccuguugagaaguuuggcagcuggagguggacaugcacacacuacacugaaccuccugcaacaagcacugcggaag\n", + "gcacupuguccgccpcaucgcucuguccaguuauuccaguuucucupagcagccgaguugaccccacggucugag\n", + "gaaauggcaacugcugacaggaaguuuggcauccaccucccccagccuccugaguggacapcccupcaccacuucagag\n", + "cccugccucuuucuugucgcagucaguuucaucaucagauagaaacaguguuacaguacuugaaaag\n", + "gcaauuagguuacugugucuugcupcuuggucuuguuugcugaapcagcapcucuacc\n", + "acagcucuguggcuuggagaauuuagacucugucuucagccaggcacucccucccucccucccagcacu\n", + "guuuauuccgcgguuuccccgcggcugcccccpagaccgaagagguggcupcaggccgaaagcagaggaaagguupcagugucacccuugcacacccacagg\n", + "guguuuauuccgcgguuuccccgcggcugcccccpagaccgaagagguggcupcaggccgaaagcagaggaaag\n", + "aaaugccucucugccaaugugacaacuaauuuaaugacaaagaaggaacuagugauguagaagucugaggucaaaauacugcaggcagaagaacagaaagugcaaaggcccugag\n", + "gaacaucgugaguacuucauuaccuucagaucaaccagaauuaucauucaauauaaaguuaauggaugaaagacaaggaugccaaugcuguuuuugccugagauaaagagaucuuaac\n", + "paguacgugagucguccagugcaaucucuauugucugaaacuuacuuuuuaucagaauuugaagaugaaaacg\n", + "agauccgcauccggcuccucccccggcugccacccuucccaccggcagaauccagagcgaaguuucugcuuccugcugcpaaucggacgccccag\n", + "gcpcggcccgagcuucggcggcggcggcggcagcggcggcagcggcggcggcgacgcugacaccucccaccauggacagcuucgacuuagcccugcuccagga\n", + "ggcggcggcggcagcggcggcagcggcggcggcgacgcugacaccucccaccauggacagcuucgacuuagcccugcuccagga\n", + "cuuuccucuuggaaguggcgacugcugcpcugagcggugcucgcacgcgucucpagccagguuggcggcgcg\n", + "guagugugacauuccugccugccugaggaagaaauggugagcapcugcaauugcagacaagugucacccagaagccacaaguuucugugagcaccaggucuacaaacuacccaaggcauagca\n", + "ugagaggcucuuccuggaucccuuauuuucuacaggagaggaggaaaacaccupaugcuccagugcucuuacgcagauaaugaucauuaacaucagccucucugaucaaag\n", + "guacaaaacucaaaacaugaacaacaauauauauuaccaaucuucaaaccugguuugccuagaacuggaauacaguugccugcgacauauuuuagaagaacuagaaaagucaaagua\n", + "agugccuuccgugaaguugcucgccpucguupcccugucgaccuguaggcpcgagcgagccagcggacaagacugcgg\n", + "acccaggagauccuacugaagugaguggcuggccgaguccagugaccacaucagcacauucaguaaugacucuugaagcuuuugucugcccuaaaugauuug\n", + "agagaagcaucuccapacaccggcggccgagccccgcgcacgcccuugagcaccugagcuccapcguccccucggacucaaggagaaaaaacacaccccgaggcacacguggacaccuag\n", + "cccuucucccugugaucaguuaccaacuaccuguugaugugugugguuacagacuucuuucuaugcuuuguacaacucuacagaccguauguag\n", + "aguagaguuuugcuguuaagacugcgcgaggagcuagagagagcggagagcgcugagccpccgcacccgccgagccgu\n", + "gaaaaaaguacaucuccuggaapaugcuuuuuagcugagcucugguggaugagaggagcuagccuugaaaaa\n", + "cccuucucccugugaucaguuaccaacuaccuguugaugugugugguuacagacuucuuucuaugcuuuguacaacucuacagaccguau\n", + "aguuucguccgagcucaguagaguuuugcuguuaagacugcgcgaggagcuagagagagcggagagcgcugagccpccgcacccgccgagccgu\n", + "gcgcgcgcapccaagcccgaggcagcucgcccgcagcucgcacucgcaggcgaccugcuccagucuccaaagccg\n", + "pacauggaauuccgugguccupcgcugcuaagauccpugucuggacccupupacggagugaccgugaagauagaaaaaaaaaaupaaag\n", + "ggapcpuaggcgguuuguauccpcugugaggugcucggagccucggcggaccuugcugccucugucucuuuaacgcgagaggaagcgaugcagapuggaaa\n", + "apcpuaggcgguuuguauccpcugugaggugcucggagccucggcggaccuugcugccucugucucuuuaacgcgagaggaagcgaugcagapuggaaa\n", + "acaauaccaggcpapcpuaggcgguuuguauccpcugugaggugcucggagccucggcggaccuugcugccucugucucuuuaacgcgagaggaagcgaugcagapuggaaa\n", + "gcucggagccucggcggaccuugcugccucugucucuuuaacgcgagaggaagcgaugcagapuggaaa\n", + "gguuuguauccpcugugaggugcucggagccucggcggaccuugcugccucugucucuuuaacgcgagaggaagcgaugcagapuggaaa\n", + "agaucacacupaaccagacugacuucuccaauucugaacucgccccggccucpcggcucaaapccuccucugccgcauccccgccaaaaccaaaccgccuggcacaagccg\n", + "gcaguaggcgapcgcggcugcpuuccuggugcugaggacggacgccauuggaguucccgagaag\n", + "guccpcugcugugcuggcagcaguaggcgapcgcggcugcpuuccuggugcugaggacggacgccauuggaguucccgagaag\n", + "ggcgucccagccgccuaccucgcupacccuggucuugcugucccccgcuggccuccugcccaagcgacugcggccagg\n", + "gccagcapcgagccccuaccccagagugaagguggacuuugcccucucgugccacgaggacuugcuggcacccaucucugagcccaucgaguggaaauaccacagcccugaggaggagauaag\n", + "gcapuuuuugcugcccuugaguggcpuggacagcgcagccaccgccugccucaucuacucc\n", + "gaaguccugacggccacgcuggaucuggaggacguccggagcuacapcggagauuucaucucgaaaccuggcg\n", + "aacccggaagguccggcgucccagccgccuaccucgcupacccuggucuugcugucccccgcuggccuccugcccaagcgacugcggccagg\n", + "agguccggcgucccagccgccuaccucgcupacccuggucuugcugucccccgcuggccuccugcccaagcgacugcggccagg\n", + "guuguaguuaagcucguguaacggcggcggugucggcagcugcuguagcgaagagaguuuggcgcg\n", + "aauucuuucuaagccgcccaaagcpuugcgccpccuccpccgaggupccugcucauuggaagaucgcaucgcagcc\n", + "guccccgccucgcgcggcggcggcggcpugaggagccugaggcggcggcpuggcuccgcgcgcgguggucucp\n", + "cugcgcggcgcggcgcugcggagaccguugguucauuugcauguccccgccucgcgcggcggcggcggcpugaggagccugaggcggcggcpuggcuccgcgcgcgguggucucp\n", + "gucaapaggccccaaaacagucuacacagcaggapauggcupcucuugagcuauaaguggcaccucapcccugacpcgucucgcc\n", + "cgcaccugcgugcaggcaaaugaggcaaggcugagcccagapcgagcgaguuacugcgcgcgcaccucacccgcccccugcauuccccuccuucgccggcagguggag\n", + "ccccaggccgccgcggccccgcagcgcuggucuccgaagucuucgagcagcaccupaggucacaucuugcag\n", + "ucccuggauggcuuuguguucgccuugaaccaggaaggaaaauuccucuacaucucagagacagucuccaucuaucupucucucacag\n", + "gucuuugaguguuuuguguguacauauuuugcucuuaaaguuuauaaauauacguauauugagaguguccacgucuccucgcugaaccuuaggaaucccuuggcacc\n", + "gagcccucccugcucuaccuccggcacugcccgucccugccucuccacugucccuggaggucccupccguucucupccucaggaucucaccguccaucccgucugcccugcagg\n", + "ggaggaaaaagagguaacuaguccaccuccagaagaagacagguuccaggagcuuaaaguagcaacagcagaagcaau\n", + "ugcacgagcauagcugugucucggaaaugguuggcuuupcaguucaggaggaggacuccaucucauucagaaagaaggcuggaagcacaggcuuuuucuuucacacagg\n", + "gaaggugcaauuucucaagucgccuguuguuuacaugaugaugauuauguugcuguagcuaccag\n", + "gacgucagcaaggaapaggaacgcgapagacugaaguucacguuccgcucuuagugcgcggugaguuccccggcgcuaagccpagacaagauccgaucuacugagagcugcgag\n", + "aucccaguugagaaccacugcucuagcagguggugcccaggauuguguucapuagagaaguggauucuggcuguaauccucaa\n", + "gucauugaaucuuupaauuauuauuuauaaagcacuggacuaugguuugaaggagaaugaagaaapaauuaagcccuccccuagagcagcuuaucgaucac\n", + "acucagaugcucauugaagaggaggaggagguugagaaaagguuucucccaucaguuuuuaucuaauucauucuuuugagag\n", + "guuuacucagaugcucauugaagaggaggaggagguugagaaaagguuucucccaucaguuuuuaucuaauucauucuuuugagag\n", + "agaugcucauugaagaggaggaggagguugagaaaagguuucucccaucaguuuuuaucuaauucauucuuuugagag\n", + "aaaugaccauuaagaaguagaugcccagaugcaaaagugaugaaacaguccauuugucauaaaguaagaugcagcuguggcaugucaaccagcuug\n", + "guuaaaucagcaaacaaagaaaacaugguauuuugaaauaugauuaaacuccugaugcugcagcagaggcuaagaauauuaauggccagaucuag\n", + "ggccuuguaggcacagcggcugagacucgaucugcuccaaguapcuccagcgcpucggagucupuucgcgcccgccgacccgcgcccugcucccucucagcaccupcggacg\n", + "gagauuuucuucuuucuaccaucaucaagaucaagcaggcaaguuuacuugcugucaucuucugcaag\n", + "auugaagguuuguggcaacccuguauucagaauucuguaucagugccauuuuuccagccagcgugugcuuacuucaugucucupucacauuuug\n", + "ucuuccuauagauacguaccaagauuaacaaugacuccaggauagaguuaugaccaacacuacuaaag\n", + "acagcggcugagacucgaucugcuccaaguapcuccagcgcpucggagucupuucgcgcccgccgacccgcgcccugcucccucucagcaccupcggacg\n", + "guacccaggcugaagugcagugucacaaucauagcucaccacggucuugaacuccupcucaagcgaucauucugacucagccucccaaguagguaggaccacagguguacag\n", + "gaggccuuguaggcacagcggcugagacucgaucugcuccaaguapcuccagcgcpucggagucupuucgcgcccgccgacccgcgcccugcucccucucagcaccupcggacg\n", + "agaaauucucaauguuuuucuucuguuuuuagguuaaaucagcaaacaaagaaaacaugguauuuugaaauaugauuaaacuccugaugcugcagcagaggcuaagaauauuaauggccagaucuag\n", + "ucgaucugcuccaaguapcuccagcgcpucggagucupuucgcgcccgccgacccgcgcccugcucccucucagcaccupcggacg\n", + "gaugccuuccgcgccuuccacccugaccuggaauucgupcaaguucuugaaaccccugcugauuggugaacuggccccggaggagcccagccaggaccacggcaagaac\n", + "ugcacacaccggcupaggcagccgucugugcagcgagcagccggcgcpaggccgcagugcacpcgucacagucggcaggcagc\n", + "aaagcgaagapcccpcugcacacaccggcupaggcagccgucugugcagcgagcagccggcgcpaggccgcagugcacpcgucacagucggcaggcagc\n", + "guggcuggucauugaccgcaagguuuacaacaucaccaaaugguccauccagcacccppccagcpucaucpcacuacgcuggagaagaugcaacg\n", + "cccagcguccucucucgccucgcauugguacacuccaacuccuuucuacucuucucuggaggcggcacuuuugaauuucagacccagcgcuccagucuuuaga\n", + "cgcgcpcuaccucaguucucpcguacggcgcggccuguccuacugccgccggcgccgcggccguc\n", + "accccgcagcccggccucggccuccgccgcuugucgucgcgccccgcccgcgagcccgccccgcacgucccccgccggcggccacc\n", + "ccccgcagcccggccucggccuccgccgcuugucgucgcgccccgcccgcgagcccgccccgcacgucccccgccggcggccacc\n", + "ccgccgcccgcgcgccucucaccgugucucuccgucucucccccgcccgccggcccggacccgcucggaaccggacccggacucgaccccgaccccgaccccgcagaggacaagcag\n", + "gacauugacaagcaguacgupcuucgccacacugcccaaccaggugcaccgcaagucggugaagaaaggcuuugacuucacacuc\n", + "ugucugcggaauccgcaccaaccagcaccaugcccaugauacupuacupacauccgcp\n", + "acaaagucapacccuccaucucugacgcgaccugcpccaucucucccagcuggcccacgccauccgccugcuccuggaauacacagacucaagcuaugaggaaaagaaguacacg\n", + "gacagugucgcaaagauucgccgaagacacuccuuuccuuacgugaccuaguuuucgcucgcccagugaaccuguucucgccugg\n", + "guupcguggugccucaugccuguaaucccagcacuuupaggccaaggupcagaucaccugaggucpaguucgagaccagccugaccaacauggagaaacccc\n", + "guuccccucuuccaagacpugccaagugaugaguaucaggugucuauggugagauuupaggaucccagaccuuaacagcccuuugguugaaaccucucacaauguggcag\n", + "agaupuuuugauguguugcccaggcuggucuugaacuccugagcuuaagugauguguccgccupccucccaaagugcuggaauuacagacaugag\n", + "ugccugcugccuupccgccuugaaccuccapuuuccagcuccuccuccuucaccccagugccacugcc\n", + "cgccguuuucccpagaugcgccgcccggucucccugccagcggagugcupccgaggacapcggcapugacagupuccaggagagucucaaaauccuaag\n", + "cuuucaguauuuguuauugugaaagaaguuaauucaccugaaacagaggapcaaccugaguuaucagaaagugacuuccuggccuucccuucuuuacugaucag\n", + "cccuaacuccccuaaggaggagaccccpaucaguuccccagagacagaggccaggauaagccugccaaaggccaguuuaaagaagaaagaggaaaaagcaaccaugaaga\n", + "gagaugcgccgcccggucucccugccagcggagugcupccgaggacapcggcapugacagupuccaggagagucucaaaauccuaag\n", + "ugcacccugagccggagcugcccagucgccgcpaccpccgcupucuggacpucgcc\n", + "pcccuacaacugcacccugagccggagcugcccagucgccgcpaccpccgcupucuggacpucgcc\n", + "gccaugguaacpagcgcuacgccpacuggcggappcccacgcguaaauagccgaggcuggaucpcgcugacaagucccuucucugccgcgg\n", + "uggccacaggugcggcuggccuggcgapcgcucpccccguccccagucccugaucgccggauaacaapcagcuggcgccguccauug\n", + "aauauuugugcaggcgccgcaggaacpcuccgcggacgacpcuccapacgcacaggcagcpccucccaccgcpugccpcppcugccccc\n", + "aagacaauagaugugcaucuucaaaugcagcauccugugccaggugccuugcgcupuccagaauguggaugguguguucaagag\n", + "aucgagccpaagauggcaccgcccacggagcugcuggccaggccggagcgaggcagcgcgcccggcucccgcgcc\n", + "aupcggcugguggcugupcuugcupaucgcgcuggcgcuccupcgagaggcuucuggcacucag\n", + "ggaagccugaagccagaaugccagacagcgcagacacuauuccaucucgcauuuuaguuuuaaugaaaaucucug\n", + "aaaucgacuuaaagccuccagagaaguagaaucuguagaccuuccacacugccaccugauuaaaggaauug\n", + "auaapacagaugaggagguucugaccaccuaccucccuggcuupcagacauaggaguucuuggcaucuucauagguccaguuuuucuggaggaagaaguaaccaacucugacaccugacu\n", + "agcugcuggccaggccggagcgaggcagcgcgcccggcucccgcgccaupcggcugguggcugupcuugcupaucgcgcuggcgcuccupcgagaggcuucuggcacucag\n", + "aagcuggcucugaagauauugacauacuucccaauggucuggcuuuuuuuaguguggugagugucuucuuccuuccccaaauucagcagaggagauacaapuauuugaugapcugcagaaca\n", + "ggacucggccuaggcggaggacpcggagcgcggccggcaccaucgagccpaagauggcaccgcccacggagcugcuggccaggccggagcgaggcagcgcgcccggcucccgcgcc\n", + "ugaugguuucccaaguuugacucuccauugccgauucccugccacauuccuucaggaaacuguuuugucuucgguuuccuguuaaucccuauuauauag\n", + "gaaccuucccuguauacugucaaagccauccugauucuggacaaugauggagaucgacuuuuugccaag\n", + "uacuaugacgacaccuaccccagugucaaggagcaaaaggccuuugagaagaacauuuucaacaagacccaucggacugaca\n", + "gugaaauugcccucuuggaaggccugacagugguauacaaaagcaguauagaucucuauuucuaugugauuggcagcuccuaugaaaaugag\n", + "gcpccuaaupaacguauggccaaucagcggcggcguuucuuuugcggcuccacgucggcaccagcugcpcaag\n", + "aacccccapuugapapaagacgaagcuugaaagacuugguaauggcgacpuuug\n", + "guuuguguacugcccaaauugcauggcuugacaucauuucuuaaugucguuuuuauuuuaagucagagcaccauaac\n", + "aacugcaacacuuccucugcaucuggauaugaapagccccagaaaagcggaagaauuuagacgcacacugg\n", + "gacgcacacupuagguuugaauuuguuuuguuuucaaaaauuaaacaaaugauccuucagcaucaucgccuccgcugcuuuaucag\n", + "gcugugaaauuugaaccauaccaugauagcgcccuugccagauuucugcugaagcgugguuuaaga\n", + "aacaaaagaauuggucacuuuuuguuuugguucuugagaagugagauagcccaguccagacacuaucagcagagguucgcugugauucuggaagccuaucugapcuguggcacagcc\n", + "aaggcgcgcgcggucagcuguuggcggugcapaggaggacgccpcucgccuucccuccucugccgccgcugccgcc\n", + "ggcgguagcuugguuccugagcggaugcupcuguaaggcgcgcgcggucagcuguuggcggugcapaggaggacgccpcucgccuucccuccucugccgccgcugccgcc\n", + "uggcgacccggaaguuguacuugcaacugcggcuuuccuucucccacaauccuucgcgcucuuccuuuccaacuuggacgcugcaga\n", + "agacuauucgguaggcgucuugagagcpugugccpugacgagaaaaugcugcaaagauuaacgcucucauuccugaaucccagcagaaccucauuagauccauaaaupaac\n", + "gcuguaucauccguugcagucgucuugaagaaccaaggaggaaaauugcaccagcaaaaaaaaauugagucaugaaagaugugaaaag\n", + "acuapaugagcccgaacuapaugugacagagcgcgagacccagccuaaagagagcccggagccagcgupaggccgcugccgucgcgcgccuug\n", + "guuuuucuguuccuuuuuuuuuuuuuuuuuuaacuuccugccuauacacacgcagccaucagcccacaaagac\n", + "cgcugcacgccagacaccggccuuucaauauccgucucuucccugcagguugacggcguugcacgcucucgcpaggcucuggcuuuccaaacgcuggcaccgagg\n", + "gagaugcucgccuccgcgcguuuccgcuuccgccaucgcggacgcagccucgugccpagucgccgcauugugguccgcuucucugcacu\n", + "agcacuuccpugapaggccpccgcgagacpaaggcccupcaagaacgcugagaaacg\n", + "apagapaagacaguuucugcgcucugcgagcucauaauccccuguagugaggauucagaaaapaaaaauccccuugugacupaaaggaapcgcauauagcagagg\n", + "gcapagcuuaacagccaggccuggacacccucaagagacugugugcugauucucagucgucacuccuuggaucaggaaccauaguccug\n", + "augcagccgcucucugcucccugccccaaugaacaucugcacuaggcccaagccuuggaguaauuuaccugaagagugacaccauugauuuugaaacuacu\n", + "acuuguugcuuacgguacaguccagcaugagcuggaaauguaggaaccucagccucccgagcagaaaga\n", + "cuucugccgaagaaguapcppaaguuuaggaguugaggaaagaagauuaaagagcgcgaggag\n", + "acugccugaaguuacauuuagagacugaaaucacugcaccuuaaaaacaaaagauugagcugcacuguauuccu\n", + "aagguuuuucaaagaggcaguggaggagguucuaauaaauuuggaaggaaacaguucccugucuupaaaaggagaacuccugacugauuagcauucacaccag\n", + "ccuaugucuaagcacagcucaucuucacaaacugaaguggaucuugauuucuggaaauguccaaauaaug\n", + "acaacaaccccauggagguggauacaucagagucagcuggagguggucagaauuauuugcaauguuug\n", + "agacgucugcgcgcgaaugccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "gcccccgcccgcagacgucugcgcgcgaaugccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "gccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "ccccgcccccgcccgcagacgucugcgcgcgaaugccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "cugccccgcccccgcccgcagacgucugcgcgcgaaugccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "acgucugcgcgcgaaugccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "gacgucugcgcgcgaaugccguggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "uggcgcgaacuupacugcagaggcgcgccuggcggaucugaguguguugcccpcagcggcgcgcpaccaacgcaag\n", + "uguuuucuguuguuguuccuguucugaucgucucuaauggccuuaaaaagaaaagucuagaucacagupcucuaggag\n", + "agacapuuucgccauguugaccaggccggucucgagcuccuggucucaagugaucaccugccupccucccaaagugcupauuacag\n", + "gagucpaaauggccgcugugugguugcaacggagauaaauucccggaaccgcgauucggcgugucag\n", + "gaauucgaauuuagaguuuaauuucucagagcauucucuccaggaagaauuuuuacaguaucucaaagacuucacuugacuucuugauccugcauaaaaccaag\n", + "uuccucgcguucuugagucpaaauggccgcugugugguugcaacggagauaaauucccggaaccgcgauucggcgugucag\n", + "cuugagucpaaauggccgcugugugguugcaacggagauaaauucccggaaccgcgauucggcgugucag\n", + "gacgugcuagcgcgucgaagguagcucuaugguuuuccucgcguucuugagucpaaauggccgcugugugguugcaacggagauaaauucccggaaccgcgauucggcgugucag\n", + "ggcugcupcuggcpcgcaggccgcpacccgagcccpaagcgagagagcggaggcgccgaggauccgauucacucccupagaccuaupccgaagccguguaaaugcguuuuaag\n", + "aggccucggcuccgcaacugccacuccuccucpuguugcacaaguuucgaggucaccggcgacccccccuagcagcgcgccuggcucuggcccccgcgaaggaggacggaguuug\n", + "uguguugcauacuuucuaaggcggcggcugcagcagcggcuccauccagcccgucagcuccuccugcaaggc\n", + "cagaggccucggcuccgcaacugccacuccuccucpuguugcacaaguuucgaggucaccggcgacccccccuagcagcgcgccuggcucuggcccccgcgaaggaggacggaguuug\n", + "gauuuuguagaagauuccgccaaagacucaacaacauaaagaaauauauauaccuuucgguuuggauaucucucaacaaaaccuucuacugcuucucagccagcc\n", + "agugaggacpacucuacugccgagaccaggcucacgcugagaggupccaugaccuccgagaccucuuccggaagccacugugccag\n", + "aaagauagauccugcuccaggagccpaagccuugcccuggccagcugugcupcaccuccccugccugcuuccuggcccacuugcaggcaaggugapc\n", + "acucacuauucagccccauacagcccaguuguuuaauuuucucuagaaauguucagcugccupuccagauacuga\n", + "guagcupacuuuuccgcccgaccuccuccggcugcuccuccccgaggaccaccccacccccuccccgcccaccucaccccuagcuccag\n", + "agapaggagaagapaaucuguuagcuucucacuguccucuccgacacuucuggauuuugucaccugaccccuuuggacaguccguggagaagccagauccuacaucccuug\n", + "aucuccaguugguugaaugugugcauguagaacccacagacacagaggaupcuacauuauguagc\n", + "aucugugucgapcaauauugcaagupaagacgacaugccuggaauucuucuccaacgcgacagacgucgag\n", + "cguccgcucuggcuugugcugucuuucaguuaucgcguagcacauuagcggaccuagagcupcacauauuagcggaccuagag\n", + "gcucucgcgcaugcgccccaacpaucccgcggccguccgcucuggcuugugcugucuuucaguuaucgcguagcacauuagcggaccuagagcupcacauauuagcggaccuagag\n", + "acaapcgguccccgguguccugcgcpcgcggapcpcgucaguuccgcppcugucpaacc\n", + "gcccpcggcggcggcucucpuucuccguapccccgccucggagcpcggcggcggaggaggagacugaggagcagg\n", + "gaaugucggauugcacauccuauuguaaaauguacuuacugcagaucagaauuucaacaagagag\n", + "cccaagccuugucaguacuguaacauaauugcagcauuuauugguaccaagugucagcguugcacaaauucagaaaaaaagu\n", + "agaaaugccccaggcucuccpcacacaaagcgcaggcgcagcpuupuggcagcagcaucgaguagcggccgcuuaggcagcaacauccgcaacaaguguagacaag\n", + "aaagcgcaggcgcagcpuupuggcagcagcaucgaguagcggccgcuuaggcagcaacauccgcaacaaguguagacaag\n", + "acauucugauuuaauuguuacggaguguggccugguaucggaaguucucaaagcuccugccggcauaacgguuugaagccaggacugcupu\n", + "uuucaaggacaggugcguguccauccuguguugcaaauucuguaaacaagugcucagcucuapa\n", + "cuaggcupacccpcuguccgccapcupagacacuggaggaggccggccgaugauuacgcgcg\n", + "cugcgcggaacacccauccuccupuccuaggcupacccpcuguccgccapcupagacacuggaggaggccggccgaugauuacgcgcg\n", + "acugcagcaggaguuucaagaacagcagcacaaaaauaaugacuuaacuggauagaaaaaaaggcacauauuuucaggaaggccucuuuauucuuagaaguuacccuucaag\n", + "caagaacagcagcacaaaaauaaugacuuaacuggauagaaaaaaaggcacauauuuucaggaaggccucuuuauucuuagaaguuacccuucaag\n", + "agguucacaauaaaggugcuaagaaagagaauguaagacaggaaaauaauuaaauauucuuaccgag\n", + "guucacaauaaaggugcuaagaaagagaauguaagacaggaaaauaauuaaauauucuuaccgag\n", + "gcacugupaaagagcuugucgcugcgguguugcuguuggagacucgauuguuggugacagcgaaagaacgauaacaaa\n", + "gagcuugucgcugcgguguugcuguuggagacucgauuguuggugacagcgaaagaacgauaacaaa\n", + "cuuucuupuuucuuccgacggcgupccucgcuaaggaauucccggccccucapccacggcuuuagcggugucuuuugcg\n", + "gucauaccugucugucugcucccagcuuucuupuuucuuccgacggcgupccucgcuaaggaauucccggccccucapccacggcuuuagcggugucuuuugcg\n", + "aguucuucguaaguacaucuuaaagcugucaagaugguucuagcagaccuuggaagaaaaauaacaucagcauuacgcucguugagcaaugccaccauuaucaaugaagag\n", + "cuapccccuccgccapacccccgapcgagcgccuppcgcggccuugcucgcpagcgcugcugapagagug\n", + "uauaaacuaguggcaauuucugaacccagccggcuccaucucagcuucugguuucuaaguccaugugccaaaggcugccaggaaggag\n", + "acgccuuccugaguccuggaucuuucuuccuucuggaaaucuuugacugupuaguuauuuauuucugaauaagagcguccacgcauc\n", + "cagcucuuauaaacuaguggcaauuucugaacccagccggcuccaucucagcuucugguuucuaaguccaugugccaaaggcugccaggaaggag\n", + "gcuuuuucuuuccaguguuggcugacuuacagcucuuauaaacuaguggcaauuucugaacccagccggcuccaucucagcuucugguuucuaaguccaugugccaaaggcugccaggaaggag\n", + "aaagugguaaaauagcuguggagugcagacccagugaagagauuguagaugucagaupaagaacuacacaguuuaauucaa\n", + "gucaguugcucuccccugaaggaagaguauucucggauuucaccucagaggaggaagaauucaggcugccagaacuggacuagcacuucugaagaucccaaggccag\n", + "aaauucccucugucuccuccagaauccagaaaagaauaauuacgauauuuucaaaauggaaaguucccaugccaaagacuuugccuucuucaccaaacuaugauuucgugauguucuuaaag\n", + "ccuggccugcagacuagcaacccaagacuuauacugcccaauuugacagcucauuuuuauuuuaguuucaccauauacaugaauuggacuuacaauuccagaaaaauuaaag\n", + "aauccagaaaagaauaauuacgauauuuucaaaauggaaaguucccaugccaaagacuuugccuucuucaccaaacuaugauuucgugauguucuuaaag\n", + "gugcgcggcccggcagagccgugcpcgcccgcguacucacuagcugagguggcagugguuccaccaac\n", + "aacggccaggcccagccgcuugaggcuccccaacggccaggccgcgcccccgcgugcgugcgcggcccggcagagccgugcpcgcccgcguacucacuagcugagguggcagugguuccaccaac\n", + "aucaauaugacaacaugauuuugucuuuauaucaguaagcagcuucuacuauguuuuccuauuuucugcuagcuacaguuuacaaaggaugucacagcacug\n", + "gcauauucucaagaugccuaccugaaaggcaacgaagcuuauagcggcaaugcccgcaauauaccugaaccuccaccaaucugcuaucccuggcugccaucugccccaucagcc\n", + "pcccggcgcccggccagcgucuccgcuucagcucgccgccgcgcuucggccgccpcccgagcpcpaagg\n", + "gcpaucguccggcugcpuccggcucacgccpcpcpcpcgcgcugucccggagccggccagccccgugcggauccacucgucccgcuuccucug\n", + "cccggccpcccggcgcccggccagcgucuccgcuucagcucgccgccgcgcuucggccgccpcccgagcpcpaagg\n", + "ggaaucucuggagauugguucaccuuuugugguccugaccccuucuguccucacuguaccuugaaguccuagaguccaauaaaaucgcugccucccagcuguuuggaucacagagag\n", + "gugcgcacupucagagagaapagaggccuccuucugapcggcuugauaccgguggag\n", + "gagcuccaggaagcaggcaggccuuggucugagacaguguccucaggucgcagagcagaggagacccaggcagugucagcagugaag\n", + "guucucpacaggcuaaccaggaggacaggagccccaagaggccccagagcagcacugacgaagaccu\n", + "gccugupucuccaucgcccagcuccugcccacgcuccugacugcugcccugaccagagucauc\n", + "uuuucuacpaacuggccugaacucggccguacpcuccccaguaaccgaccuuuggccaaaguguggaugga\n", + "accugacgcagupcgucuugcacgugcagccguuuaagucgcgupcgccugcgapcuupagagcaagccgcggagag\n", + "uucucaauucuaaauuuuaaagugaguguaccaccupaauagaacagcgaaagaugugaaguuaagaaagauuuuaua\n", + "acugccauugguccacpacggcccuuccaggagccaguggcupagcagugcuggaggaucaaggaagcagag\n", + "auaapccucgcucuguuacccaggcuggagugcugugguguguuugugacucaccguagccuugaacuccupcucaagcaauccucccaccuaagccucuggaguagcupacuacag\n", + "auugcuggacucgcugaagagagacuacgcaggaaagccccagccacccaucaaaucagagagaaggaauccaccuucuuacgcu\n", + "agcgagugcgcgguccagugcggccggaaccuggcgcaacuccuagagcgguccuupagacgcpucccaguccugcggcuccuacupagugcgcuggucggaag\n", + "cuuuagguucauucuuguaaguguugcuggugucagaauaggaaccucccugcgcuuugaapaugaaugugaccucucccacauucuccggugcugugauguaccuuaaacacagcaag\n", + "cagugcggccggaaccuggcgcaacuccuagagcgguccuupagacgcpucccaguccugcggcuccuacupagugcgcuggucggaag\n", + "uucugcugacaccucacuggccaucucaacugcaaggcagccuaggaaauguagugcuuaccuguacacguggauuccuggaaucaauucagg\n", + "accuggcgcaacuccuagagcgguccuupagacgcpucccaguccugcggcuccuacupagugcgcuggucggaag\n", + "pacacgucacuggaagacagccaucaagcaucaugagguacugaggauaccucaauauccuggagaagguaguup\n", + "upaacuucaugaggcccucgaacaucugaagaaagagcaagaagaggccuggaagcuugaaguuggugaaaggaaacgaacugccaccuggaag\n", + "gcugagcugccpaacggcagcuucugacgcupccauuggacgcugcggaaccaggcuucuucacuuugaguuuccgccgcgaagcgccaguccpccgaggapag\n", + "gcagugaapcguugcauuucccpuaccccgagcugcccucuugugacuccuuggcpcggcuggucagacaaagugugccuccpccggapcgacccagaggapaag\n", + "uuaauguuauuuuuuaggaaccuaauucaucucuccagcaaaggacacaucucuccagcaaaggacaccucucuccagcaaaggacaccugcagag\n", + "gaaccuaauucaucucuccagcaaaggacacaucucuccagcaaaggacaccucucuccagcaaaggacaccugcagag\n", + "gcugcuacupcugcugaggcugcgaggaggaggaggaggaggagguagagapaggaggaggaggag\n", + "cagaugcggagagguggcuccauggacacagaccugcugugugugcuucugcgccccagguguugugugupugcag\n", + "pcaaaacacaccuuuugaggucuguggagcucaaaaaugaagucaaaggugacupugacacaaacagcucag\n", + "gauuuuapaagcagguucugcugcuguugcugcugcuacupcugcugaggcugcgaggaggaggaggaggaggag\n", + "gcuucgagucucaccuccpacaccacgucuugcuugaaagcuugcuuuaacacugacgugcccaccuucgucuuugcagg\n", + "gguccugcucuguugcucaugcupuguaguggcaugaucauagcucacugcagccucuaccuccupcucaaaugaaccuccugcuucggccucccaaagugcupauuacag\n", + "gaaaaaaaaaaaaagaagcaaaugauaccaagacaagcucauaacagagauccaaucagcagauguguacggaugaaaauacag\n", + "cuugaaggcagguccacgccuccuccuggaagccuucccuugacugacuccucgcugaguucacag\n", + "gugguuugguapugagcugguguguggugugguuggaccuggcauggaacuuaacuggaguuuauguggaaugaaccuugap\n", + "pcugucgcggcuugaggapcpcccaapcpaccucpuggcccgagguggcccggcugcupuuggaagcggcgcaguccgacucaucccggccccp\n", + "aacccuugcuggccucagaacaccagcgcccucccuccggugcagcccugccuggccpccccuccuccacagcc\n", + "uccuccuguagccccaccauccaccgupaacgguggagagacuacaacucccaguaugcaccgcg\n", + "auaaacaaacauugauugcuuuccuaucuuacauuuuuuuaggagugcgaaauaagugagucauc\n", + "gaagacaauauacapaauguggacagauacaggaaggacagagugaaaggcauuguuugaguacugcuuaaguacuag\n", + "agacauggucucacuucauugcccaggcuagucucgaacuucupcuccagagauccacccaccuuggccucccaaagugucaggauuacaggugugagccacggcacccgacccag\n", + "gugguuuccuagaaacaugauuguuuauuggcauugaucucacagucuggugaggacuucuuuacugaua\n", + "aguuucacucuuguugcccaggcuggagugcaauggcacgaucucggcucaccgcaaccucugccucuupuucaagcgauucuccugccucagccucucgaguagcupauuacag\n", + "gagcccccgcagcccuagagccgcccaapauggcgauggcguacuuggcuuggagacuggcgcggcguucguguccgag\n", + "ggauaccgcuguccaggcgaaggucgccgccguuggaagacccuccuucccuauugucuagguggcaacaggauuuugcuuugcugguuuuccggugag\n", + "acccccgagcccccgcagcccuagagccgcccaapauggcgauggcguacuuggcuuggagacuggcgcggcguucguguccgag\n", + "agaacuapagcugguggagaagguggcggccgcuggaaggaggcccpagguggcugapuccaggcggcpacgacucuggccuuuugaagaccp\n", + "agaacuapagcugguggagaagguggcggccgcuggaaggaggcccpagguggcugapuccaggcggcpacgacucuggccuuuugaagaccpupugcucucu\n", + "uucgccuguauuuugcuccugcgcugguagcuupuuupcacagugccaucupuucuaaacuuccuggacaaaggccagcugcugcug\n", + "ccccauuccuuggucucgucugagcaguuagguuccgccugugguugcacauuugguucaucugagg\n", + "agcccccuccccucgccuccucgccgcuggcggccaccgcgucgcuccggcccpccccaccccaggcgacucugugaggagcggccggaggccggaggcggag\n", + "agucuuccgagcaagauggcgccgcpcauuucuuccacugcccgucugapaacgcuaaguaguguguccggcgccguguuccag\n", + "guuguuccucaaagucauucaagcuguacucgccgaaggagcccccgaacggcaacgccuuuccccccuuccaucccggcacc\n", + "gucguccugguccgcggcgcccgappaggcggaggcgccpagccgcgcgaggagccgccgccgccgcgccauggagcccgagugagcgcggcgcpcccguccggccgccggacaac\n", + "cuugaaauccauggcccaaaaugacucuaccaguggagacucucuucugugaagaagacgaccagauaagagguup\n", + "agaupucuugcuguguugcccagacuggucucaaacuccuggccucaagugauccuucugccucagcuucccaaaguacupauuacag\n", + "ccpucuccuuuggccupuaacccgaggugcagagcugagaaugaggcgauuucggaggauggagaaauagccccgagucccguggaaa\n", + "auuagcuccauucaagccuacaaauugcaucacccuccuccucugcccagaccupcuccaacaccuuucgcuaggucuggcucuggccucugagcgaaccuuccguacagu\n", + "uuugaaacccaggcggccgacuuagccgguggcacgacaguugcugcapaaucuuuuaaacgagagcgagaaggacugcpcaggaccggcpcuccugg\n", + "acuggugcugaaccccgccgcgcgcgcuuugaauuucccagccgcuaagcgccucuccuggucggugucccaggcagaaaggugcagagacccaucugacgcaggacuccag\n", + "auupcggcgugaucucgccgcgguuccgcggcccugccgccgccgccgccagcagagcgcaccpccgaucpcgaguggcc\n", + "gcupcggucauupcggcgugaucucgccgcgguuccgcggcccugccgccgccgccgccagcagagcgcaccpccgaucpcgaguggcc\n", + "caaguaacaggcaggaggaguguuaagccugaggcuccaucuucapaagaaaacaucccaacuagagaagaapacaccuuccccuccuaacaa\n", + "gcgacupaaacggcugcauuccacugcgucuccuuggccuggcupcggucggaggcugaucugccaa\n", + "gauuacuguuuggagaccgcugcagcccacguccaccugauagacuauuuacuacacauaguagguucagagccgcuaa\n", + "aacuuggcuuugagucacaaagcugcugcggcaccapcuccaagacuggccguucagacugcuagguuuagcuucapcag\n", + "cccapcaguguugcugcauauugcauggaugaaaggcugaaggcugccuccucuugcaggcuggcuucugagauugcaccuucuucuccugcuacuccuccaaaucu\n", + "acaaagcugcugcggcaccapcuccaagacuggccguucagacugcuagguuuagcuucapcag\n", + "ccagcccapcaguguugcugcauauugcauggaugaaaggcugaaggcugccuccucuugcaggcuggcuucugagauugcaccuucuucuccugcuacuccuccaaaucu\n", + "cccapcaguguugcugcauauugcauggaugaaaggcugaaggcugccuccucuugcaggcuggcuucugagauugcaccuucuucuccugcuacuccuccaaaucuaugacccuucaag\n", + "gcagagcugaccuguccgguaaucaaggcaaugcagccggccgccuagcuacaguucacgagccaguugucacccagupcggugcauccuccagcccccgcucaccccagucuccuggacaaa\n", + "apauuggccagaacuuggcuuugagucacaaagcugcugcggcaccapcuccaagacuggccguucagacugcuagguuuagcuucapcag\n", + "agcugaccuguccgguaaucaaggcaaugcagccggccgccuagcuacaguucacgagccaguugucacccagupcggugcauccuccagcccccgcucaccccagucuccuggacaaa\n", + "gcgccuccgaacgcgcpcgcacgcugagagccpaggaccaggugapccuccgucuuccgaagacag\n", + "gaacgcgcpcgcacgcugagagccpaggaccaggugapccuccgucuuccgaagacag\n", + "pcccggagcuuccuccgcpcccccaggcccgapccpcugcugauccgccaggcacg\n", + "guuggcgcuguacguuuaugaguaccugcugcacaucggugcccagaagucagcccagaccuuccugucugag\n", + "cgucuucupaccuguacugcgcggcgccugacagaagagaggccugcgagcacuccggcgaggccaaggccuuccaggacuau\n", + "agcaugcgcagugcgcapccggcucgaagcgcaagcaggaagcguuugcggugaucccggcgacugcgcuggcua\n", + "agugauacauggugcaaaacagccupauaauauugccagcugccagaccagacuapuggcucaagg\n", + "gguugccauaguuucuaaaucuuuugaaggaaaaacugaucgcacagaagagugguauggaacccaguacaaacaagaagcuauaccggaugaagucaucaag\n", + "aaauggcaaaaugcugaccugaaupaaauuuaaacuuccuacaaagaaugaauuuauuccuacgaauuuugagauuuuaccguuagaaaaagaggcgacaccauacccugcucuuauuaag\n", + "gauacagcuaugagcaaacuuugguucaaacaagaugauaaguuuuuuuugccgaaggcuugucucaacuuugaauuuuucag\n", + "cuuugauaaaauuguuggcuuuuggcupugcgauagcucacaccuguaauccuaacauuuupaagccgaggcaggaagaucgcuugagccuaggaguucgagaccagccuggacaacaca\n", + "augcgcagugcgcapccggcucgaagcgcaagcaggaagcguuugcggugaucccggcgacugcgcuggcua\n", + "aguuguaacuguaguaggucagugauacauggugcaaaacagccupauaauauugccagcugccagaccagacuapuggcucaagg\n", + "gcugcagcggcagcagcugucgcgccagucgcaacagaagcagguccgaggcacagcccgaucccgcc\n", + "ucgcgcggccgagaggcugcagcggcagcagcugucgcgccagucgcaacagaagcagguccgaggcacagcccgaucccgcc\n", + "cucgcgcggccgagaggcugcagcggcagcagcugucgcgccagucgcaacagaagcagguccgaggcacagcccgaucccgcc\n", + "gaggcugcagcggcagcagcugucgcgccagucgcaacagaagcagguccgaggcacagcccgaucccgcc\n", + "gagaggcugcagcggcagcagcugucgcgccagucgcaacagaagcagguccgaggcacagcccgaucccgccauggagcagccgaggaaggcggugguagugacgg\n", + "gagcuagaaaagcuaggccuuggcgacagcguggaccugcauguguacgagauuccgguugaguaccaaacaguccagagacucauccccgcccugupagaagcacaguccacag\n", + "pcugccagcaugcugucaccucucaauaggagaucaguuaaugcauacugaaggaaggcuuguuggagaagaauccucuccugaacccuguggagacucuagaauccugcg\n", + "gaugucucucucccuaaguaagagauguuacuuccuggapaaugcaguguupaaucugaagacccagcuuugagcugaauuugcuuugugauaccug\n", + "uguggaacuccaacagaaaccggugaauaaagaucagugucccagagagagaccagaggagcuggagucaggaggc\n", + "ugaguucaacaacaacgacaacaacagccgcagcucauccuggccgucauggaguuucuugaaagaacguaucuugugaaugauaaagcugccaagauguaugcuuucacacuagaaag\n", + "uuuuguuuuuuggcaacuggaagcagupaugaaauauuuuccuaaggcgucucaggacugaacuggcagcaaaaua\n", + "ucgccccpcccgcccucggcccggacccaugcagcuupcccgcaucaucgcuuguucgguaacaaaugauucugauccauucugagaucuacaaaggcuguuacccugcag\n", + "gcpuaaaaauggcugucupaggaggcgguggcpcccggcgcccgcggugccagccccpagcagcaaccuuccgccgaacucpugcpcucaagaaa\n", + "aacaaaugauucugauccauucugagaucuacaaaggcuguuacccugcagguccaucucacgucccccaggaggccpaaacccupcugcggapapaggag\n", + "cuucuggcaaguaugaggcaaggauuucacagaagaacuuggagcaaaaauucccacugucauagcuauaggcuguccagucuugapagcugcaggaacaggaaaaag\n", + "aauccagauucggcuaggaaaagacaagcuuuccagagaauguuucagagaaaguuacguggagcgupcguuucgcagacuccuaag\n", + "acugccauucauaccacagaacgagaaggcaguggcgauccucaacggcuacaugucacugccug\n", + "accaccugaucaaggaaaaggaaggcacagcggagcgcagagugagaaccaccaaccgaggcgccpcagcgaccccugcagcggagacagagacugagcggcccggccccgcc\n", + "acagcggagcgcagagugagaaccaccaaccgaggcgccpcagcgaccccugcagcggagacagagacugagcggcccggccccgcc\n", + "acaccagccuugagcccagccugcggccapaccacgcacgucccacccacccagcgacuccccagccgcugcccacucuuccucacuc\n", + "guuggugacuuuggagaugcaaucaauuggcccacaccuggagagauagcccacaagaguguucag\n", + "acguggugccuccccgcgcpagcggcaugugacugccgaccggcgcuccgcgaguccucccucucccuccuccgcguuuugguccuuuuggaccgugccccuuuccppag\n", + "acggccaccgccupccgcagcgguuagupcaacggugugguucpccuaccucgucggcagapupcgcugguuucagugaaacgauccccaccgcaugcuggu\n", + "gccagagccaggaggcagcugugcgaucuggauguaccuaaacccuccapccacauagugaccccaggcccuggucacucc\n", + "ggagagcgcgcgugcgccgucacgagcucggcgcugccpccgcgguguggaagcgaguauucgaccgccgugcpccgcp\n", + "ggcccuuacugcuuuauaagcaccagcucaagaaggaaccuacagccucuuggaaaggaaucucacuapcuugacugcgupucuguagcgcuuucacuguaagaaagcaag\n", + "gcacucaagcagagaagaaauccacaaagacucacagucugcuggupcagagaagacagaaacgacaugagcacagcaggaaaa\n", + "guaaucaaaugcaaagcagcugugcuaupagguaaagaaacccuuuuccauugaggauguggagguugcaccuccuaaggcuuaugaaguucgcauuaag\n", + "aacauaccugcuuuaugcacucaagcagagaagaaauccacaaguacucaccagccuccuggucugcagagaagacagaaucaau\n", + "augcacucaagcagagaagaaauccacaaagacucacagucugcuggupcagagaagacagaaacgacaugagcacagcaggaaaa\n", + "gaaaguugucugacagaaguuugaugagaggaauuugacucagaagacugaaauauccuuuaaccuuacuauaaaauaucuuacaaaauacucauugauuucacagcauuagaaucaucaag\n", + "augcacucaagcagagaagaaauccacaaagacucacagucugcuggupcagagaagacagaaacgac\n", + "gugugguggaccucaguuuugaggccgagaguccucuggcgccccccacagagcuccuggagagacugcccagcuaugacuggcuucuucaapca\n", + "gaggacagauauucuucccaccuuuggaggccccapaggccccaggagcaaagguccuggcccucguuccuggaacacag\n", + "aaaaupccuuguaauaguaccucuuapcugcugugaaggaaggauaacauggaagcaacaugccuaucauagugcuuuguguaug\n", + "ccccugucaaccaucacucuacuuugugugugugaguuugaccaccugaaucuuuuuggcaccaucucaaguauaauucaaaucacgaggcauuugugcauaucgacaauacacccaucgug\n", + "augcpacacgcuguagaacagcucacacuggcuggcacugcuaagcaggugcggapagucagagacccccggauggap\n", + "uguagaacagcucacacuggcuggcacugcuaagcaggugcggapagucagagacccccggauggap\n", + "auauuggagcagcaagaggcupaagccaucacuuaccuugcacugagaaagaagacaaaggccagu\n", + "acgugcggccggaapaaguaacgucagccugagaacugaguagcuguacuguguggcgccuuauucuaggcacuuguupcaga\n", + "gcgccuagccupagagagcupcpcggcpagcugcucucgcpccgcggcccucgcccuggcugcaacg\n", + "pcpcpcpcgaggccgcggcgagcaaaguccaggccccucugcugcagcgcccgcgcguccagaggcccugccagacacgcgcgagguucgag\n", + "cauucaaacuauaaggccuguguucuuccaaacguaguuccaccacucccccgcugugugaccuupcagguggccucaccucccucaggcucaguguccuc\n", + "cagapcgccacggccagcgagcaccgcgcgcugaugucggagcucaagauccucauucacaucggcaaccaccucaacguggucaaccuccucpcgugcaccaagccgcagg\n", + "aggccagccggcgcccgcgcggacacuuucagccccgagccgcggccgcucpucggacccacgcgcagcggccggag\n", + "ggucucacucugucgcccaggcuggcacgaucccaguucacugcaaccuccaccucccugguucaagugauucucccaccccagccucucgaguagcupauuacaaacgugccccaccacacccag\n", + "aauuuguuauccgacucuuaucugugugcuguuuuaugaugucuaugaccguguguuccaugaag\n", + "ggcggcggcggcggcggaguguaggaagaggcacugcugapcgcgapaacggaggccagagcugcg\n", + "gugcgcaccguucccggcgacgaacggaagauggcggcggcggcggcggcggaguguaggaagaggcacugcugapcgcgapaacggaggccagagcugcg\n", + "guguucpugacaauccagcccagcccauccgcugguucccugagcuugauccauccucuucuuuccupacaagcugacagcagcc\n", + "gacgaacggaagauggcggcggcggcggcggcggaguguaggaagaggcacugcugapcgcgapaacggaggccagagcugcg\n", + "aauauggcggcgcccaguggcggugugaacugugaggaguucgccgaguuccaggugaupuuuuccuc\n", + "auuguugcaccauuagaagcuagguugauccacagacagauggcugaaaguggaaaagaaaaaauaaaauggacaaccaccauuauuauuagcucaucucuuaag\n", + "aguuaugaaguugcaacugcccuagaaaaucgaagccacaaaguucgauauucagauucaguggaaaauggaucaauuauauuuucucuuucug\n", + "agucugcauugagcuuggcucaggaaagaapaaauccaggcpccuguupcccaggucuugagcucuuuuggcuccagaguucccagcacaguc\n", + "gcaguuacacacaggcagugguaucugugagcagcucuguggacucaaagguuuucucccugagaggcaugacccaggccagcugauucaucagaaucag\n", + "agucucaucugccuccacucggccucaguuccucaucacuguuccugugcucacagucaucaauuauagaccccacaac\n", + "ugcuagaggcccacaguuucagucucaucugccuccacucggccucaguuccucaucacuguuccugugcucacagucaucaauuauagaccccacaac\n", + "gucgaagcgcgcgaacuccucccgguuguagauguaucucuccaggaagcgcugugucccauuaaacgcguagcauuccugccgucccuggaaaag\n", + "gcgcgaacuccucccgguuguagauguaucucuccaggaagcgcugugucccauuaaacgcguagcauuccugccgucccuggaaaag\n", + "gcapacuggcugccaaccccuccggcuacpccccuuaccgagcucccagacuggucauaugcgg\n", + "puaugauccugcuuaauuggauaauuggugacugaggaagauggugaagauuuuuucuacuuguuauuuacu\n", + "cagugaaucuugaagugccagagagauguuacaagugauaaacuauguauuauguguuauguuaaaugacugaaacaucccugucuucucagugcuucccu\n", + "cagugaaucuugaagugccagagagauguuacaagugauaaacuauguauuauguguuauguuaa\n", + "cucuucauccuagcccgcccccuccccggcucuggacccgguucugupapuccguuccpcucggugcgacugcgcagcuccucggcgcuuccucgguggcuuccccpucgagcaaacag\n", + "guaaguucpagacuucaggccapcagucuccugucuucucuuggaaaccacagcagcccaugcacacaga\n", + "augguguggucgcucgauucucccagugccuggcugaguuucggacgugguuaagaaccaacugguugagguucaaugcagacaagacggaugugaugcug\n", + "cuggaagaaggaggcpcggcccpccucaggccccucccaggcucugagucucccggcugcaggcgg\n", + "aguuuugcucuuguugcccaggcuggagugcaauggcacgaucucagcucacugcaaccuccgccucccugguucaagcgauucuccugcgucagccucccgagcaucuggaauuacag\n", + "aaaacgcugcuugcuugcaaaugaggaggccgcuaggcauuugccuagaaccacaaccuuucuccgguuucgccuuuuuuuaacccugauuuuuuuuuuccauucuggap\n", + "aggauugugucccugagaucgugagcuguggcuuaaaauccccuucuucccucugucuuggaugugcucg\n", + "gcugccaccaucuccucuguggacuccuguaaccaaaccagaacuuuuuuuuuuuuuuucuguucagugacaucug\n", + "gcccagugcccgcgcgcgccgccaggcucgcaagcaccgcguaggccagcuggccggaucccgccgucuguc\n", + "gcaugcccagugcccgcgcgcgccgccaggcucgcaagcaccgcguaggccagcuggccggaucccgccgucuguc\n", + "agaagcgaauucugcaccgcgaagccugagaggcagguagcugcggcgcupcuggcggcggcgaguccacgugcuccccgcggccgguugaaaccguuggcpcgcuggcugagag\n", + "cugccuaccpagcugacggacgacgacugccaacaccuuagccccagcuggcccaggaaacugcugcgguggcagguggcggcggcaggapcucggcugccccgagcgcccgccag\n", + "agaccggcccggccagcgcgcauucggccccggacgaagguacucgcagcacuuggagcgcagaaccggccgcgcccg\n", + "gauaaaggcugapccgcgcgcuuggcccagaccggcccggccagcgcgcauucggccccggacgaagguacucgcagcacuuggagcgcagaaccggccgcgcccg\n", + "aggcuacpagaaaaguccuccgcucggccgcacccguuagaggcgcucuccacugcuguccucuucagcucaag\n", + "gaguuggcauccuuuggaagaguucgugaaagcuuucugcccagagcuccuggaccaaugcaucuucccaccaccuuaaaccacug\n", + "agcgcugagucccagaaaaacagagcpccagcugcagcguguagugcgagupcggacgcgcgcagcccgcccgcccggcgaccagcaag\n", + "aggcgcpapcucggaggcuguucccacccccaggcuccgcguucccgccggccccagcuccagccccgcagcccaccg\n", + "cggccccgccgacccacggcccacgacccaccgacccacgaaucggcccggcccccgcguucacc\n", + "uggaggapcaagcaaapaauguagauaacuaaagugaaauagagcugauguauccagagguuauguugcuagag\n", + "ggucccggacggucgccgccagcugcgaguggaagugagcgapcuagucccggaccgccpccapuccggcggcagcagacpuaccguggcggccaaaaaa\n", + "gccacgupcggaacggaaaccucgcapucagaccguagcgacgcpaaguccggacgcaguagcucccugaagcggaggcgaapaguuuaagccccagcggcggca\n", + "gcapucagaccguagcgacgcpaaguccggacgcaguagcucccugaagcggaggcgaapaguuuaagccccagcggcggca\n", + "gaauguuccagauaaucccuuucccaguccugccugacaucupuapuuugucccuggaauucupacacuggcupuuugaggagagaagccaguaccuaccuggcugcagg\n", + "gcccucgcacgucacuccpacccccgcggccuccgcagguucugcgcuccaggccggagucagagacuccaggaucgguucuuucaucuucgccgccccugcgcguccagcucuucuaagacgag\n", + "cpcucggccccgccggcgcgcgaccccauccccaucccggucccugcagagcgauccccpcccagau\n", + "ggcugcggcggcaggaaaucpcucggccccgccggcgcgcgaccccauccccaucccggucccugcagagcgauccccpcccagau\n", + "ggcucggccccgccggcgcgcgaccccauccccaucccggucccugcagagcgauccccpcccagauauggacgcagcagagccgg\n", + "ggugccacgacugcugapagapcaacgcgguaggauccccacapccccucuguagcccupagucggcagugcuggucuaggccccuuaggagapcappcagcaguagaaau\n", + "gacuccccccagguccugapcaggaagagguacagugacaucuuccggagccuggacaaccucgaaaucucacupaacgu\n", + "gcupcapcgacgcggaaccgaggcggcggcggcggcugcggcggcaggaaaucpcucggccccgccggcgcgcgaccccauccccaucccggucccugcagagcgauccccpcccagau\n", + "ugagauuapcgcagccagagcaggccuaggaaaacgccagcagcguguggcgaucacggugaugaagcgca\n", + "agccccaauupcggccgguuuccaauuggaapcuucugagccucagucuucpcggcgcugaccauuggcpcaggauggaggcggagccuupuugucgcccgccgccpuuaag\n", + "gacugcaggcaaacccggcgacagcgcagcucgcgucgacccuggcuccucugccugcccccucag\n", + "cgcgcccpucagugaaaggcgucuucccguucccgcccuccgccuccucucgccggccagcaac\n", + "uuuuagugguggagucaauuuauuucugaaacgaucucauuuaccugaaugaggagcucauauuuauuuucagg\n", + "gaucugaugaauccaaggaguggagcaagaggcagauuuuggacacgguuaugagaaugacagaaacugccuaaagcauuuaugcucuggcauucgucccuguuucuggagguccaguaag\n", + "agaccuggcaaggugcggagcccuccagaagugcggucaagcggcagcggagacggcgagccaggaaccuccccccgcguccccagcuucccagcguggcggcggaacccccggagaaa\n", + "cuggaccccugccapaapuccucagacuugagguugccagcucagaugupcugcugauacuag\n", + "cuucuucccupacacugcacupccapcugccpacccupcucaggcccccuuguc\n", + "ggcaccuggaccccugccapaapuccucagacuugagguugccagcucagaugupcugcugauacuag\n", + "cuuuuuaagcuccccugagccggugcugcgcuccucuaauupacuccgagccpcuauuucuggcgcuggcgcggcuccaagaaggc\n", + "auccgcauuugcuaccagcggcggccgcggcggagccaggccgguccucagcgcccagcaccgccgcucccggcaacccggagcgcgcaccgcaggccggcggccgagcucgcg\n", + "gcpcapcgcgcaggacagaagccucgcuguuccuccpagcccaacaccguucccgcgcggccacg\n", + "aggaupaguccccaggacccggagcugagcagccuggcgcgcggcpcapcgcgcaggacagaagccucgcuguuccuccpagcccaacaccguucccgcgcggccacg\n", + "ggcccucggccucuuugcacccggcagagugacgagcuucgccggugucuucaacgaaguccugucggucccuaccggcacaucacacacuccuggaagc\n", + "gacugugagcugcggcagcugagcagaggcggcggcgcpaccugcagucgccapauucccuccaggugacg\n", + "cuuuucgacugugagcugcggcagcugagcagaggcggcggcgcpaccugcagucgccapauucccuccaggugacg\n", + "guucuguugcaaaaugugaaaaugaaggugaaguccuccagauuccauuuaucacagacaacccuugcaua\n", + "ggcugagagcccuuuucgacugugagcugcggcagcugagcagaggcggcggcgcpaccugcagucgccapauucccuccaggugacg\n", + "gagcugcggcagcugagcagaggcggcggcgcpaccugcagucgccapauucccuccaggugacg\n", + "pccugagaccaccccugcccuaggcccagcuuuccuggacugccugcccccacaaaccaacagcccgcccccagguccccagucg\n", + "aagguauccugcagaccaugaacugagcacuguucccagaccguucaugagcacaguguaaggugugccgagacccaccacccagcgagccccuccccuccguagcacugaggacccccggagaag\n", + "ucuucuagaggcccagccucuauggcccucugaccugcagguauuggcgauccauagcuaagacgccaggucccccggaaaccuagaaaug\n", + "ucuucuucuagaggcccagccucuauggcccucugaccugcagguauuggcgauccauagcuaagacgccaggucccccggaaaccuagaaaug\n", + "guauuguugucucuaagccagaccugaucaccugucuggaacaagaaaaagagccuuggacuagaaagagacauagg\n", + "cacpcaggcaaguggucccuagguucpagcagagcagcagcgccucaguccuggucccccagucccaagccucaccugccugcccagcgccagg\n", + "guuugcacucggcagcacpcaggcaaguggucccuagguucpagcagagcagcagcgccucaguccuggucccccagucccaagccucaccugccugcccagcgccagg\n", + "uucucucagcgucuggacagugaccaugugucacgugcuggugaaccccuggccapcccaauaaauauugaaugaguaa\n", + "gugaaaaugaaauccuugcaacucugcaugccauuucaagcaaaaaccagaucuggagaucguauauuggc\n", + "gaaaagcagaagaaaaaccaggagaaugugguaucguggcacccaagagaagguuuuuucuaggaggaggaagugauccauuguguaag\n", + "aaguuaccgcccgugccgcgguucggcggcggcauccggccucgcacuuccggupagauuccggccuggagcucccapccgag\n", + "apuaauuagacaccupcuugugupucugcuuggcggugapcucuacacaagcuuccuuuccgucaugccggcccccacccuggcucugaccauucuguucucucuggcagguc\n", + "ggcaggaguggcgcugcucaccucuggugccaaapcggcgcagcggcugccgagcucggcccuggaggcggcgagaac\n", + "ggaauucauuguguacugaagaauggauagagaacucaagaaggaaauuggaaacuggaagcaaauguap\n", + "gacggagaaggccagugcccagguuagugagcagugcccggcgcccgcuucccucaccuccuuuuccagccuuugcacag\n", + "agaccucggacgagagcgccccpagcucggagcgcgugcacgcguggcagacggagaaggccagugcccag\n", + "ccagaccucggacgagagcgccccpagcucggagcgcgugcacgcguggcagacggagaaggccagugcccag\n", + "uuccgguucucugucagucgcgagcgaacgaccaagapuguucgacugcuagagccgagcgaagc\n", + "acuuccgguucucugucagucgcgagcgaacgaccaagapuguucgacugcuagagccgagcgaagc\n", + "ugguuucaguaucaguuacuugaauuacaagcugcuucuccccccacccccacauuggaacaggcucauuaag\n", + "gcagagcuuccgcugcuucaaaacggcgugcaggagucagagacauuacaucaggaagauacugcagagauauucuacuccaucucauucauuguacag\n", + "auucuaaacucccugaaggagacaaauuaccaguggacaagaacacagccucuggaguccaauaggccuggugcauucauuagg\n", + "gauccugccacagcugcugcccacaccgcgcucagcgccuucacugccauccccgcuguccuugccgcccccgcc\n", + "gcuggugguccaggccguggugccugccaggugaugupcaaagccccccgcacaggccacugagagcuccggacacgcacccggcugccacc\n", + "acacgcagcaucuggcugaggauuaacauacauacauguguauguaugcgucacguauauauuuacugcaaauggupaucauuuagugcccgag\n", + "agucagcugacauggucaacaaauuuaucaaagaaacccccuggcuuuugaagaauaguacuuuauacaucuggaucugcacaucaggcaaa\n", + "uuagaggaagcpagacggcgcgugcacuguguuccugguccupuuccagaggaugacacugagccugucgcagccacguupuuccgcacugaagccaaaag\n", + "guugaaaagaaaaagaaggagaagguucucgcaacuguuacaaaaccaguugguggugacaagaacggcgguacccpugguuaaacuucgcaaa\n", + "gucagcggaggaccgagcgacggccpaauggcagcgcpcuccgcggaggcgccacgcacaguguccaaagcauccuugcuuccuccuggaaaccgcggccgccag\n", + "acagagucucauucuguaggccaggccggaggacpaaugagaaaggccauguacaagaggaaguagucagccgcuaaauccaag\n", + "ggccugucugcaagacuugaguucaggacucccaauccuucgccauccgaaccuggapcauccagucgacaccuacap\n", + "acapucucucacucuaucacccaggcuggapcagugguucaccuugaccuucupcucaagaaauccucccaucucagccucccaaguagcupaacacag\n", + "ucccgcpcggugcgccupaggaapaggucggaggagcpcaccgcggcgccpuauaaggagcaaag\n", + "ccuucuaccuccuccucggccagcucagguugcagcuucucupaacugcucaccuuuccggagcapaagcugccccgugcccpapagcpcgcaccgcggcccccaggacacgcgcu\n", + "uucucupaacugcucaccuuuccggagcapaagcugccccgugcccpapagcpcgcaccgcggcccccaggacacgcgcu\n", + "agaccgugugapccuguggccccagcgugcuguggccucpagupaaguggaggcaggagccuuccuuacacuucgcc\n", + "cugcagcaccupagaaggcagaccgugugapccuguggccccagcgugcuguggccucpagupaaguggaggcaggagccuuccuuacacuucgcc\n", + "caccupagaaggcagaccgugugapccuguggccccagcgugcuguggccucpagupaaguggaggcaggagccuuccuuacacuucgcc\n", + "agaccgugugapccuguggccccagcgugcuguggccucpagupaaguggaggcaggagccuuccuuacacuucgccaugaguuuccucaucgacuccagcaucaugauuaccucccag\n", + "ucagcgcguccucccgcggcggcccgcpacggcgugacccgccpcucucggugccccpccgcgcgcc\n", + "agaccuugcguccgcaguaccgacccgcacgcucuucagcgcaucccuagugaaggagguucucccccagcccgug\n", + "caugugapagcagagccuggugacggaucagcucagccgccgccucauccggaccuaccaacucuacagccgcaccagcpaagcacgugcagguccuggccaacaagcgcaucaacgcc\n", + "aagcucagcgcacuuggcuuaapcggcgcgcucccugccugcugcupcggapaaggcggcaagagcugcggagccccuggaag\n", + "uuggcuuaapcggcgcgcucccugccugcugcupcggapaaggcggcaagagcugcggagccccuggaag\n", + "agaacugcupcugucauaggucuaagcagaagagcgaggacuaaaucccuaauuuucugacaccgaugccacugauauuuucauuauaucaggcugccucgaccugcug\n", + "accucaaggupcgaguggcapcggacccuggcgaccugacgcugcggaggcucgagcggcguauccauaccacccagcuguucgccgcpaacccgccggcccgcag\n", + "ugguucccgcpccuggccucuuuacpuuauggcccuugcgugccuugaauuacuuccacgccccuggcugca\n", + "gugapccupacagacgcagcagacupauaugcaaagagaggaguagccuaauugucaagucuagaucuaacaaaagcagugucccaagauc\n", + "agacgcagcagacupauaugcaaagagaggaguagccuaauugucaagucuagaucuaacaaaagcagugucccaagauc\n", + "guuuuggccggaaaggcuuaccaugaguugccapcugagagagauggagaaggauucgcggcggugacagauuaaauuccccaguuacauuauagacuuggag\n", + "gaggaccacaagcpccpcuacagaugcugcggcugcccpcagcgcuagcaccgaggaccugacagucgg\n", + "uuuggccggaaaggcuuaccaugaguugccapcugagagagauggagaaggauucgcggcggugacagauuaaauuccccaguuacauuauagacuuggag\n", + "ggcggcagauuguaguuuuuguuuuggccggaaaggcuuaccaugaguugccapcugagagagauggagaaggauucgcggcggugacagauuaaauuccccaguuacauuauagacuuggag\n", + "ggacgcggaagaacuggcccagcggagguucccgcuucugaagcgupaggcggaagagacugcag\n", + "auuggaguggccgcuggacgcgugcgcaggacccgaupugcccggacgcggaagaacuggcccagcggagguucccgcuucugaagcgupaggcggaagagacugcag\n", + "agucuupaguccauagcuaagcaccaggagcugagcacugcccgcugugccugccugcaagucugac\n", + "cupcuuuuucagcaggcccguaacugucgguucuuuccccuucggucuuaggaugaggupcgcaccpcauagugguuggaguuucuguagauggaaaagaagucuggucagaag\n", + "gauucaaaccgccugcupugccgupccauugugcaagucuuccaggccgcggucgaaugauucugacaagcg\n", + "aaucacapcugcggccgagagagaagccuuauuagagcuuucucaaccugcagcccucaucuccgccggcgaguapccagguguupag\n", + "aagugcucagcaacgauuacgccccgapccaaucacapcugcggccgagaaagaagccuuaauagagcuuucucaaccugcagcccucaucuccgccggcgaguapccagguguupag\n", + "aaucacapcugcggccgagagagaagccuuauuagagcuuucucaaccugcagcccucaucuccgccggcgaguapccagguguupagguga\n", + "gagguagacaaggcugaupaagcaacugguagaaauccucaccacccauugugacagcuacupuggag\n", + "agugcucagcaacgauuacgccccgapccaaucacapcugcggccgagagagaagccuuauuagagcuuucucaaccugcagcccucaucuccgccggcgaguapccagguguupag\n", + "gacuuccugccccgccagagccaggaagcpagccpacccapcccpaucgccgagcccgaccucpcgccccgccggucaccuccgcgcggacaccag\n", + "ccapcccpaucgccgagcccgaccucpcgccccgccggucaccuccgcgcggacaccag\n", + "pcgcaaagguggacucapcggcuagagcgacgcggcggcapupagagugcggagcccgagcgcggaggcuucgguuccgguggcggcg\n", + "agagccaggaagcpagccpacccapcccpaucgccgagcccgaccucpcgccccgccggucaccuccgcgcggacaccag\n", + "agagcgacgcggcggcapupagagugcggagcccgagcgcggaggcuucgguuccgguggcggcg\n", + "guuguccaggcugaucuuauacuccuggccucaagugauccuccugccucagucuccaaaagcacupaauacauag\n", + "guuguuagcgacaugaguacapucuggaucuuacccauucaagaguguauucucagcacccaaugccuggcauaua\n", + "acagacuagccaaguggcugagacgagugupugcgugacucugccugcgcgcgcgccagccccgcagcucucgccagagccuup\n", + "aguccccaaaauugagugucaaacagaggcupugaccuccuguccaggauugcucucaucguaugaaucgaaguuuucaucuuaacguauuuuuuucuccugagaauaggccaaccaauca\n", + "uuccaggcacupcuaggcacupaugguguggugagcaaaaacugaccaguccugccguggaguuugcupagacacauguuacucaaagaaucacacuaaggauag\n", + "gagguucuacugcucuccuucuuaagaapupaggcacucggucucuccccacaccucucgccugaggccaggcgccaggugucgccugaagccagacagccgguuupagcgagccugag\n", + "aaauaaaggucguagccgcagagucaacpcggagcuaaaguggucgugauucaugcugucgcpaaccccgaaggupccccacguaacaagaag\n", + "ggagcuaaaguggucgugauucaugcugucgcpaaccccgaaggupccccacguaacaagaag\n", + "aaagcccgccuuucgugacaaauaaaggucguagccgcagagucaacpcggagcuaaaguggucgugauucaugcugucgcpaaccccgaaggupccccacguaacaagaag\n", + "agugagacuguapupcggugcgagcggcgguuagcucccaguucggccucugaggaaaacpcguucgccugcgguugguccgacuguuagcaac\n", + "guuggcgucuucguccuguugcuggucuccguccggucgccggccgucuaggucuccggcccuccccagccgcuccugcgcccuugccggccccgccgcccgcagcc\n", + "cuugauugcacauugauccaacccuccuaacaacuagucuuccaaaauauaaauggacucuccugauaccacauucuccuucaguagugcuucacuugacaagguccugcuaag\n", + "uauuaucagaaaauccacccagcuucaccauuacugugacgucugaggcuggagaaaaugaugaaa\n", + "pcaagagcaapccacgaugacagauuacggcgaggagcagcgcaacgagcuggaggcccuggaguccaucuacccugacuccuucacag\n", + "gcagaugucucucagcuaucccuguauagcuccaguccuguucauguucucucucaccagcaguacaucugugcugugaggauguuaapaugagugaagapuuugagagugucauuaacugg\n", + "cucccggcgcggcagcugucupcugcugcgcgccgccuaggugucupcgaucuaupcaagagcaapccacg\n", + "acuuuucapacauucagaggcaucagccccuuccuccucaccagcucccagaguucccaucuccauccccaauccuaaagaaggaaaucg\n", + "cagccccuuccuccucaccagcucccagaguucccaucuccauccccaauccuaaagaaggaaaucg\n", + "auucuuuccagcugugacaugagacaauccaggcaucucuaagagcuccuccugccucagagccgg\n", + "auccucucaaccuacagacccagugagcccuaggcccucaccccagacccagcugcuggauaggacccagccccgcucccag\n", + "gagaagaagcgcuuccggcggucuuagaucacuaaucaacaaaccagcuuucpucugacgcgauccuugccucaggccucucgagguccagacagccgcccagcccgcucugcgacgcagca\n", + "ggcaaggaucucacauuaucagucuuugaccgacacagaaugccuggcauuugauaaauguuuguugaacuugaagagacauauggaca\n", + "ggcaaggaucucacauuaucagucuuugaccgacacagaaugccuggcauuugauaaauguuuguugaacuugaagagacauauggacaaugaaucugcaaag\n", + "uaggcacugacuccgaacaggauucuuucacccaggcaucuccuccagapauccgccagcccguccagcagcacc\n", + "auupcucagccuugcuccucccuuccuuacucggauaggagccacupaucuggagcuccagcuuccaaauugaagcuggccucaggccaggugaccuuuucuuu\n", + "aggcacugacuccgaacaggauucuuucacccaggcaucuccuccagapauccgccagcccguccagcagcacc\n", + "gcapcucuggcucacgcuuguaaucccaacauuuupaggacgaagccagccucaucgcuuaagcacaggaguucgaggacupagguggagguugug\n", + "gcapcuguggcucacgcuuguaaucccaacauuuupcggaggaagccagccucaucgcuuaagcacaggaguucgcggacupag\n", + "ggaccugaccugaauugcgaccccaaccuggacugcuccccugaccgcaaccccuacccccgcccaccagu\n", + "pcpuccugagucgcgacccugguccggaccugaccugaauugcgaccccaaccuggacugcuccccugaccgcaaccccuacccccgcccaccagu\n", + "gaagauuucgaugucgaucauuuugugucugacuguaggaagcpuccagcuggaagaacugagagaugaccuggagcucuacuauaaacuucuuaaaacagcc\n", + "gugccguggaaacuggcgguggccgcggccgccgagucggucugcgcagccuccugcguuuucucgcuuggaucuuggcacugagaggcgguggccggcp\n", + "auguuggcggaagcggaccccccugugccguggaaacuggcgguggccgcggccgccgagucggucugcgcagccuccugcguuuucucgcuuggaucuuggcacugagaggcgguggccggcp\n", + "aauugaaaccugagcgguggcgcggccagcugupuggagucaccccgcggacuggacpaaccuggcpucaggucccgucaagcagccuggcuc\n", + "ucuugaccggcacacacagcucgcuucuucacuuucuuuuccauccacugccggacccaagccagccuuccapagcagcc\n", + "agcccaguggcccucugagcuguuccuucuugaccggcacacacagcucgcuucuucacuuucuuuuccauccacugccggacccaagccagccuuccapagcagcc\n", + "acucagcccaguggcccucugagcuguuccuucuugaccggcacacacagcucgcuucuucacuuucuuuuccauccacugccggacccaagccagccuuccapagcagcc\n", + "gucccgcgcgcagauupcgucacugcpccccgguccgappugucggcguuggaguugugaauucgcugcguuucc\n", + "ggaccuccgaaacaaucuuauuaguaguauagauccaggugccuucupacugucaucucuaaaaagauu\n", + "ggaucugacaaacaaucgaauaggaugucugaaugcagacauauuucgaggacucaccaaucugguucggcu\n", + "aaaccuuucpaauuuguuuucuucauuaucucaaggaacuuuugauuaucuugcgucauuacggucuuu\n", + "ggaauuccagacugaguaucuuuugugugacuguaacauacuguggaugcaucgcupuaaaggagaagaacaucacgguacpauaccag\n", + "acccuccgcuugaauugccgucuuucuacaugacuccaucucaucgccaaguuguguuugaaggagacagccuuccuuuccagugc\n", + "uucauauuuuccuaaccuguguggucuuugupaggaauaacccagacuaggaaugccagcaucugccaagca\n", + "gguaagcpaagcgapcgapuapcupaapcgagcpaggcgcpcucucucuagcapcugcagcc\n", + "pcggagacugcgacccggagccgcccggacugacggagcccacugcggugcpcguuggcgcpcacggaggacccpcaggcaucgcaagcgaccccgag\n", + "gaauaccagccugucugcgaguuagacgccaguccugguggcccpaagcccagauccgcaucagcg\n", + "agcugcagagagccagcuucuccgcugugccugugcuggccaacccggcagccacauccggcugccgccgcuacguggaccaugaccucaaccgcaccuucaccagcagcuuccucaa\n", + "uuccaggcccaccccggacgacccauaugaggugacaagagcccgagagcugaaccagcugcupcccaaggccucpccaggccuuugacuuuguccuugaccugcacaacaccacggccaac\n", + "gcccaugaauaccagccugucugcgaguuagacgccaguccugguggcccpaagcccagauccgcaucagcg\n", + "acagcuugaucuupauugcugauugagcaagcugaguggcugccccucagaaucuucuguaggccuuucucuugccuucuuuuauuca\n", + "caacugaugacacugcauaucuuccccuguucuuauupagaaggccuugugugucaccaagagguucucagaapaccugucaguuuuugguuaaaagaacccggaaagagaaggacu\n", + "ggccuugugugucaccaagagguucucagaapaccugucaguuuuugguuaaaagaacccggaaagagaaggacu\n", + "cucccccgccuuccuuccucucgccupcugccugccucagaagupacccaaapugcaggacgccuggucugccuugupuccuggacggagccccuaccucugcaaag\n", + "agaagupacccaaapugcaggacgccuggucugccuugupuccuggacggagccccuaccucugcaaag\n", + "uguauuugcaugcccgagucuuugagccgugcuauaccaguuuguccagauuguuuauacuagcaaugcaguuuacggugaagaccugccuucccucupaaucuggagcuucaguaacag\n", + "guaaagguugcaucuccgucccuucgcucccpacccgcpaaaaaaaaaaauccaacacccaggccccgcggcuagccccuucccacaggcucucuccgcucgauuuugucaccguu\n", + "gagauguuucacaaagcagaagaauuauuuucuaaaacaacaaacaaugaaguggaugacauggacacgucagauacccagupcugguuuuacuuggcaga\n", + "gagguaaacaguacugaaguccapcgucggugcucacugcucuggcaaugcccggugagacugaauuauguuuaaauuuauuguag\n", + "gapaacaucuggaacauuagacapuaagccaccuuugcaacuccuuucccccugcugugacguacag\n", + "gaggagacaugcauguggcugcagccaguuagcgagagcuguuagguaaugcgcaaagagaaapaucgcgapcugcagugcgcacpucggauuugaaaucgguggccuugagcag\n", + "guacuuugagaacauccccaapucuagaccaggaaggcuggacucgagguggcauccagccccag\n", + "guuucuccugcuuggccuccuccaggapcuggcuucucugcagagcucugcuuccugcagccucuccccgaccucagagccucugcagaggaaag\n", + "cgccaucucccauagcugucgccugcagcugagaaapuugcugucccagcaggccagguccag\n", + "ggcupuauaaguaagcaagaagapccupagaagagucugacgagcaapaagguagccaaggauggagugaaauacagg\n", + "agaugcggucuugcuguguugccuaggcuggucucaaacuccugcucucaagugauccuccugccucagccuccugaguacauuuauauuuaaaguaauuauugaugg\n", + "agcccgcgcgapcggcacccgcggaggucccppcgcupcagugupcgcpauuggacaagaggccgacugaaggcggagccgag\n", + "cuagcccgcgcgapcggcacccgcggaggucccppcgcupcagugupcgcpauuggacaagaggccgacugaaggcggagccgag\n", + "agucacacagcugccuggaaggugacuggaggccuugaucgguucucauugcgauuuugcugcuguggccccaacccugccucccuccccacccugcg\n", + "uguguuuuauggaccaugugcugcuauguaugccugaagaaguacuugaaaugcaaauuupagacuuugccauauaa\n", + "gauuuccggccucucgccugcucgccccgccgcccgccugucccgcucccucccucccpacccggaggagapacc\n", + "acuggcagccaaugacuagccpugguccagcagcgcgaggauuccpacccgcgagcggagcggcgcgupucgguugcggucggccccggcag\n", + "gaupaaggccauugugacuauguggugauuacaguugucuuacuacugaguuuccuacugaaauc\n", + "guccggugcgcgcgcgcaggcucuucagcuggagcggacacacggugugcgaaccgaacagaauaacccgcccccagcpaugugaaggacuccpugaggccggccacgccccgcacg\n", + "gcaugcucugcagcacaccgapcgccaggcguaucccggcgugcaucpagcgcccaapcgaugguucccggcuccuggagaggcgugcgaaguuaagccg\n", + "aauguaguuuaauggcuuuacaaagaaagccaggcagaggagcacuucucaguggcuguggucggaccaugaccuagcugacc\n", + "gcucacuuuuuccccuugcaagucuuuguuccaagccugacguugcuacgauucuguaauuaacucccuccacuccaaapucuggaggcupaugcucugccagcucagagg\n", + "agcgccacggacgcccccpccgagcggcggugcgcucccgugcagacccguggacagacgccccuggccgguggacucucgagucucgcuucugcacccugcgucccuagac\n", + "ggaggagcagccacuuccupccgccggccpccgcuggcugcacucagcgccggagccpagcuagcggccgccgcc\n", + "ggcugcacucagcgccggagccpagcuagcggccgccgccaugucccaccagaccggcauccaag\n", + "caagugaagauguuaaagagaucuuugccagagccagaaauggaaaguacagacuucugaaaauaucuauugaaaaug\n", + "cacuuccupccgccggccpccgcuggcugcacucagcgccggagccpagcuagcggccgccgcc\n", + "acuuccupccgccggccpccgcuggcugcacucagcgccggagccpagcuagcggccgccgccaugucccaccagaccggcauccaag\n", + "gccuggccggccgcguguucccggagccucggcugcccgaaupagcccagaguggcgagcggcaccccuccccccgccagcccuccgcpaaggugaccucucgag\n", + "gauuagcuucuaaagucucuuucaucucuccuaaggaagaagccuagaagaggaggaagaggaaagaaaaggagucaggaaugccucuuag\n", + "auaucucuuccaaaugcaugaugaaaaaggupaagauuacuugagccapaguugaaggcugcagugagcccuguuuuugccaccacacuccagcuugg\n", + "cucccccucccucuccaagccggapuccugaggugacagcgccugcaacugaaauuucagcagcpagaag\n", + "cuuuccccucccccucccucuccaagccggapuccugaggugacagcgccugcaacugaaauuucagcagcpagaag\n", + "ggapuccugaggugacagcgccugcaacugaaauuucagcagcpagaagauggacaagagaaagcucpcgacggccaucuucauccg\n", + "uuuuuuuuuuuuuuuuuuuuuuuuuuuuccuuuccccucccccucccucuccaagccggapuccugaggugacagcgccugcaacugaaauuucagcagcpagaag\n", + "caaaaauuuguucacuuggaaauguggagaucuuuaacuuguaaagaucuugauaaaacaaguuacaggccg\n", + "gagccggapcgccgcgccccaggucacacagcgagucagccaaggccaagaccaacccgcgcugcgaacucguggcuuccucacugcaguccuccguguuuccup\n", + "gucugagagcugugacauucaucugacucuagugaaaguccaacagccacucccuuuuuggccuccaacupcacc\n", + "aaguccuggugucuuuaaaaggaucagcuugaggaauaaggcucgucugagagcugugacauucaucugacucuagugaaaguccaacagccacucccuuuuuggccuccaacupcacc\n", + "gcugagcagcgaagccggcapagaggccggcagaggcccggcuccgguggcuccagcuuuccucccacucuggcuccccapcugcucuggaauucucucggugcccgccguugcc\n", + "cgcgccuggagaggaggcgacgcguggccggcggcuuuguggcgcgcpuuccagcgcpcpagapcgagcugapccucgagucccagcacuccgccacgcugcpcgccpc\n", + "ccuucagccucugcugucuggccgcucugucuagguccupccacpagagccccgucccuccuuucugaag\n", + "gcaccucauugugaacaugcuuucugcaacgccugcaucacccagugguucucucagcaacagacauguccaguggaccguaguguugugacggucgcccaucugcgcccaguaccucggauc\n", + "cccuucccpagaggcupacccggcaccapcaguacuguggccgcugcggccucagcuccgacupucagguugcggagacuccaggccgcuuccapcg\n", + "gaccupuuucagugaugagacaupuaugauguaacccguuuccapauguugacgaagaucuuaucugcccuauuugcaguggagucuuggaggagccaguacag\n", + "gaugucccapuauupcppuugaaauaacupuucaggaggapauggugguagagauaaaaaugugagaapagcagcacuggcgaggagucpag\n", + "ccggcaccapcaguacuguggccgcugcggccucagcuccgacupucagguugcggagacuccaggccgcuuccapcg\n", + "gcgagagcacgcggaggagcgugcgcpccccpagacggcggcgguggcggcgcpcagagcaaggacgcggcggaucccacucgcacagcagcgcacucggugccccgcgcapucgcg\n", + "gaacugcauuuuggcgaccucugaaauucaguacugcagugaaugagcuucugaucuugaggugaacuuaacaaaauuauuuuuggaaaaaucguugupaaccauuaaaagaacuccagg\n", + "gcggccpcggcggccgccgcaaccgacagguccpacupcgcugcggccucguccgcgcgccpcpccuagcucgacagcuucccggcggcugcgcg\n", + "gauuuucucaugugcccugaaauccauguaacuacaapcuccucuuuaucaccauaagugccacccugacuuaaaaccacucagagcuaaaaaaucaaggcaaa\n", + "gcaggcgcagccggccggcagucccgucagcugucccagagccugugucgcgcccgugccgguagcgcccgugccgguagcgccgcugccaccgcucacc\n", + "gcgupugaggcgapcuaaacpcggaaugaacupaguaagaugcugccgaguccpcgaaaagcaacgcaugcuguuggacaggauacgagcuugaa\n", + "auccpucuuccuccagcagcucaapccgcguagcccpaggccauucagaaagugcauccpuggccuucapaccaaggcgccpaggcacagcccccagcccccauagag\n", + "gucuggacggaucuggcugagaagauaacapccacuggaagaagcccuggcaguggcuuucucgcag\n", + "aaacugaagcaagcugugcccaggucccuguaacagcagguggcuuucugacaucagcagagacuggugcuuuuucccagguacaaaggaccuccagaccagagccagccagcagcaaaaagagc\n", + "acucuugucagagucggagcuacaggcagugccuucagcucugagcucaggcaucccggucccuguuuuugcgguuaaggacucuaaaguguugugucguguucaucaacuuuuucucaacc\n", + "cccacaugaagugucuaccuucugcagacuccaauggcucaggaacupaaugcagugccaggcucgugguauccugcagcag\n", + "gaggucaacugcgcgccgcuggcgcugapaggaaguuugcugucgagcggccupuuccgupcaaggccgupaggcagcguuggcugcuucgacacacugapcggcgcg\n", + "gcgcgccgcuggcgcugapaggaaguuugcugucgagcggccupuuccgupcaaggccgupaggcagcguuggcugcuucgacacacugapcggcgcg\n", + "guuaacguagaggaguaaguugaggcucggaaaguaauuucccuaaagucacauuugacgcpcugaaagccagcaucauuuaagaccuuugcucucccaguacuucuguaag\n", + "agcuacuuccupcggucacaauaguggcaauaacugcuguuuauugaguguugacugugugccaggcacugugguagucaucgcggcagcccuacgaaguagucguuaacguagagga\n", + "cuuccaagcacuggaaacaaacauuggagaccaagugaggcgucacucaacagccguaguaaucapaa\n", + "aguagacuauaagcuuuuggaaaacapacuaugucuucuucaacaauguguacacaacaaguagcagguuguuuggcacauggcagaugcucg\n", + "cccagucaguugcugcugcugguccuapcaggcuaucugugucpaugccgagcauuacugccacuauaaucacugaggcaucugccagagaucucauggcugaaaacuag\n", + "apauagcucccucaucuuggaucuapagcuuauaacaucuuuuaaaaggcgaaaauucaaguuaucuguggacugucagaacauuuugcauaagucauccccag\n", + "uagacuauaagcuuuuggaaaacapacuaugucuucuucaacaauguguacacaacaaguagcagguuguuuggcacauggcag\n", + "auggugucugagcuaaaagaccauuuuuugagacaccuacapuguagaaaagaagaaaauugaacagaugguucuggacuacauuucaaaacug\n", + "cccacaagguaaaguagugcagccuguuuaguuacuuugacauuguucucaauuucaaaugaagcagauaggaauucuggauuguggucacgaccuguaaaaaccguacupcagcauauacag\n", + "ccccuaccuauuauagauuuuggaaagauaaucaucuacacuaauaaccugaaaaucauucgaacccca\n", + "aggupcpaugcgaagagcuaupaaggauucgaauuccgguggauuuaaaucgcpaggagaagcuaccgcggccua\n", + "auuaaagcccugupccaagaguugugauaaccaacuuggaauuuccugacuccuaugcuuacugauuuuucccaaccug\n", + "agugagaccgcgcggcaacagcuugcggcugcpagcucccgupcgcuccgcuggcugugcaggcggcc\n", + "acuguggcacguuucaggcaggauuccuccuucauucaaacugcaucacccaggagucugcaaauuccccaaaguaggaggaaaa\n", + "cugcuacuuaacaaggugguuugagccaaguaugugucuugcpucuuugcgaaagugaaccaguuauuapcgccuaacgaccuppucaacuaap\n", + "acuguggcacguuucaggcaggauuccuccuucauucaaacugcaucacccaggagucugcaaauuccccaaaguaggaggaaaaaugaccacauucaag\n", + "uacuuaacaaggugguuugagccaaguaugugucuugcpucuuugcgaaagugaaccaguuauuapcgccuaacgaccuppucaacuaapuaagaagcccuggagaagaccugag\n", + "agacuccugcuaaaaaccaguacguuucauuuugcaguuacupapcuugcuguggcccugucaggaagaguagagcucugguccagcuccgcgcapapaggcugucacc\n", + "uuucauuuugcaguuacupapcuugcuguggcccugucaggaagaguagagcucugguccagcuccgcgcapapaggcugucacc\n", + "cagacggacacugugccpcgagcugacaggaguucacggcugcgauagaacauggagauguc\n", + "auagaacauggagaugucaupcgcgacagagccuggcpauaccagcagcguguguguguggacggcaacguugucugugcgcguguguguga\n", + "gaugaguuccacccguucaucgaggcacugcugccucacguccgcgcuuucuccuacaccugguucaaccugcaggcgcggaagcgcaaguacuucaagaagcaugaaaagcgg\n", + "agacggacacugugccpcgagcugacaggaguucacggcugcgauagaacauggagaugucaupcgcgacagagccuggcpauaccagcagcgugu\n", + "gaggaggagaaggcgguuuuccuugugcccccccuucuaacgcugcuuuucuccuucucucuuucccccucaucccgucuuccccuccucccguccucccucgccccgc\n", + "gcauguaccaggcuggcuccgacgacggaaccgccaupugcugaguggagagupaccgcggaccccpcag\n", + "aaapcagcuaguauucccauccuugucuaacaagcuguaaggagaaguuguuucugagaucugagccugaagagapaacaagucagucagccuucguggucagaag\n", + "agcuauggcauuucaauccuguaugugagagcuagagacucauacagugaccuagagcaggcaugg\n", + "uuagacacaacagcagaaacucccaggaaacaaacacgauuucacuuuuagcucugcaacaaaguggaaucuuccucuacaggaucaacuugccgaaggaacug\n", + "gagcaggcaupupucacaggcuuuggagagcacucucuguccugaucuuuucaguugagagacuucagcuguucauugcucauuuggacuuaguucaag\n", + "cacaggcuuuggagagcacucucuguccugaucuuuucaguugagagacuucagcuguucauugcucauuuggacuuaguucaaggucaugucaaagaagaag\n", + "guccuaggaagaaaucgguggcugcpaggucuucguggacupacucgaaccugaccgacccggcagugcgg\n", + "guugacgaccuagcupuaaggucuucacguccuaggaagaaaucgguggcugcpaggucuucguggacupacucgaaccugaccgacccggcagugcgg\n", + "ggaucagugacauucapauguggccauugacuucucucaggaggagupagugccugcagccugaucagaggaccuuguacapaugugauguuggagaacuacagccaccugauaucacugg\n", + "gaaguuccauuucuaagccagaugugauuacauuacuagagcaagagaaagagcccuggauuguu\n", + "gaggaguuggcpagccuupccccucuggccucagccggauuucccagccaaacgcagagagag\n", + "cuccuuuccccgaucuggccucacaggaggaguuggcpagccuupccccucuggccucagccggauuucccagccaaacgcagagagag\n", + "pacucucuupcaaccgagguucccugugcacugucaccaupccugugucucucucagcauccupcaugagcucgcugcu\n", + "agcggacuugcggacccccgupaagcuggaaacaggcuacuagaucccgacaggagupugcupauucpcugccupuccggaagcaaauuuaaag\n", + "agucccggcgagcuuugugcgcaugugcpaggugapcuuppccucgccugagagagugag\n", + "ucaacgaaauggagauacapuauuacaaaaggugccuuguaccucguccaaggacacagagcugguaggaggcagagcuggaauuugccccagagccuuugugccguag\n", + "aaagcugagupaagcuggacccuacaaaggagucupcgccpaccggaccccuucggaaag\n", + "gaugcagcucuggcccccgaguuccuggccgugacugaguacagcguguccccagacgcagaccucaapccuucuccagcggcuggagacaguaucgg\n", + "cuugagcaggagguggagcggcggcagcggcupcaggagucagcagcuaggaaagcccucaucgcgaguuccuaccacccggcacggccugaggucuacgacucacugcag\n", + "aggagaagcgcaucuaccpugccuguuuucacagcgcccuucugccaggcccugcuggaagagcuggagcacuucgagcaaucggac\n", + "ggcccagcaagaaagaacagccccuucuggccuuccugcupacagaggcucccagagccacuucugaguupuacagacuucgguggcucaucagaugaaaggag\n", + "gaugcagcucuggcccccgaguuccuggccgugacugaguacagcguguccccagacgcagaccucaapccuucuccagcggcuggagaca\n", + "ggucugguggccgagcccugapcgcuguugcucccagguggcagaauucagcaucagagagccacacagcugaaagagauggaugg\n", + "cuuuuagguuuguuugaauaagagaucugaccugaccggcccaacuguacaacucuucaaggaaaauucguauuugcagupaagaauaaguaacauug\n", + "gcacuggccapuuccggcuguauauccaugagcgccgcuggcagccpagcugcaggaaccagacupcgagcugagcaccuguagucaaucacacgcag\n", + "aaauaauaaugauacuuauguuagaagauuguuuugagaagugcauggaguuacuacaucugaagcauuuagaacaguaccuggcacagg\n", + "ggaacaaccaagacupuuaaaucucacagccugcaaguggaagagaagaacuugaacccagguccaacuuuugcgccacagcaggcugccucuugguccugacaggaagucacaacuugg\n", + "cccugacuuccuauccuapaapccggcuggagaggccaggacagagaaagcagaucccuucuuuuuccaaggacucugugucuuccauaggcaac\n", + "gccuccagcggapaaccucuagagcuccaggacauucagguaccagguagccccaaggaggagcugccgaccuggcag\n", + "uuguguuuucuaauaccaaagaggagguuuggcuuucugupugauucccagacacugaagugcaaagaagagacccuccuagaaaaguaaaau\n", + "uagccugccugcuuacgcgcgcugcggauuguugcuccguuguaccugcupaauucaccucguuacugcuugauaucuuccaccccuuacaaaaucagaaaag\n", + "ucauuugcgaggaguccuuugguuuccaguuaccucccccacaggcgcacacgcuggcugcuugcguuggcagcgacacacauccaug\n", + "ggauugauuaupaapcuauggauuagagcuccuguaaagcaccaggaggaaucccuugauuuuucagaacagcugauuuccaccaggaaagagauuuacugaaauguaguuaaauagc\n", + "ggugucuguuuaugccpuccgcuguuaauucggaguugagucauucpuggauupcagauuguggcgcgagaucuagaaaaggaucaagguugagcggaucugcuuaaaagugacug\n", + "acaugcacacugucapcuagccugccugcuuacgcgcgcugcggauuguugcuccguuguaccugcupaauucaccucguuacugcuugauaucuuccaccccuuacaaaaucagaaaag\n", + "gaauccuuupauuuaauggaguaaaggugcaaguccaaguagcucucuagaaapagacuccagcuacccugugcapcuugap\n", + "acucccagguugcggcuggacupacugguuccuuuccaguugaaucuggcagccaaaccucuccucccccucaccugacaggugcagcggccuggcupagcccgcccgcuggccggccap\n", + "gugccuccauaugcgucggagaaccagaccugcapaccaggaaaaggaauacuaugagccccagcaccgcaucugcugcucccgcugcccgccag\n", + "gcaccuaugucucagcuaaauguagccgcauccpacacaguuugugccacaugugccgagaauuccuacaacgagcacuggaacuaccugaccaucugccagcugugccgccccugugacccag\n", + "gcucaucugccgcucccuuugccgccgccuuagcccpacccgaacccagccucuccccuacccgaacaccggccccggcuccaccgaggcccpucccccagcccgucucgccgccgcc\n", + "aacccagccucuccccuacccgaacaccggccccggcuccaccgaggcccpucccccagcccgucucgccgccgcc\n", + "gccgcucccuuugccgccgccuuagcccpacccgaacccagccucuccccuacccgaacaccggccccggcuccaccgaggcccpucccccagcccgucucgccgccgcc\n", + "cccpacccgaacccagccucuccccuacccgaacaccggccccggcuccaccgaggcccpucccccagcccgucucgccgccgcc\n", + "gaggagcugacaagcacaaguguggaacacaucauugucaauccuaaugcugccuaugacaaguucaaggacaagagagupacaaapacuug\n", + "gcuuuggcggcgguugguggccgugcpcpapapaggagagaagaggagguggagaaggcuupcucgcgccgcugaag\n", + "ccucgauccccucgccgcggucccauggaggaggaggcgagccgcagcgccgcggcgacgaacccapag\n", + "guapupugcuggcggcggcugcuuuggcggcgguugguggccgugcpcpapapaggagagaagaggagguggagaaggcuupcucgcgccgcugaag\n", + "cgcguacpauggcuggcucgcaggacggccgaagguggugguuggupagcagccagcgacgagcccguagacacucguacgcgugcpcugacgugcgcgcuac\n", + "aaaaggaagcaaaugagcugauggaagaucuguuugaaacugugaguaaugauccucaagugagaacaupauu\n", + "gcggcggcugcuuuggcggcgguugguggccgugcpcpapapaggagagaagaggagguggagaaggcuupcucgcgccgcugaag\n", + "agacapucuugccauguucuggaacucauaggcucaaguaaucuuccugccucaaccucccaaagugcuggaauuacag\n", + "gcgugapccugcgcuggagccggcuugacapucugapaguggagaacupcgaggagguucccgugg\n", + "gaaaugacauuuccuuuuuaaauagcuggagucpccccaucgagaaauggccgcgucggcag\n", + "gcgaugccguaacuggcucggcacuucuuguaguuguacgauuuuucuccuccuagauuuaaguaagucuuccccaacaccgaaupauuccaucuucagacccagccagcgaugcc\n", + "gucuucugagcuacgauaauuuuuuggaacggcagaaaugauugguucuagcaacagaupaauuuggagucacucugaaauauauccuggaauaaguguguuugacuagaaccacaucuu\n", + "guauagagugauauauuuacauagaggaaauggagaauuauuaaugaacuaugugaucguugugccucccaucacuggaaugug\n", + "gacuugcaugcuggagagaaggcaagcaaggaacaaacagcacuguaaauugaauaccagcagcucacgacuugaacugccauuggaacccag\n", + "augacgacucccuccucuggaacagccgccgucuccuccgccuccuccucgguaguucacggcugccccggcuccag\n", + "gcccgagguuuccggugagcggcaguagccgguuaugacgacucccuccucuggaacagccgccgucuccuccgccuccuccucgguaguucacggcugccccggcuccag\n", + "ggugagcggcaguagccgguuaugacgacucccuccucuggaacagccgccgucuccuccgccuccuccucgguaguucacggcugccccggcuccag\n", + "cuccgccgagcucugccccggcgagacgaggcgccuccgucgccaagccgcgccgucgcpcucccpagcggcccuuagcgaccccgcccpcccccucag\n", + "cuuacaaaacacuacacagcaaaauaaugaucugcuagacugcuaacccgagcauccagcuuccaca\n", + "gugaaaccuccgccgagcucugccccggcgagacgaggcgccuccgucgccaagccgcgccgucgcpcucccpagcggcccuuagcgaccccgcccpcccccucag\n", + "cccucpcuccggccggcggcggcggcggcggcuccgcuccgcacugcccggcgccgccucgcc\n", + "gguaucuuaaaagagguucuuucucupauguggcaugagcaaaacugacaagucaaggcaggaag\n", + "acaagccgcuuuaggagcgagguucggagccaucgcugcugccugcugauccgcgccuagaguuugaccagccacucuccagcucggcuuucgcggcgccgag\n", + "auucaaacccggccggcccgaguggugucagcucagucccggccgccgccgcgcgaggaaauggccgaggagccggagccgcag\n", + "gccuggcucgaccuccacuuuggagaagaugcuccaggaacacugaapcaggucguccccgaccuucuaugaggauugcccagcucaag\n", + "gugcucuuacagccuguuccaaguguggcuuaauccgucuccaccaccagaucuuucuccguggauuccucugcuaagaccgcug\n", + "gccuguuccaaguguggcuuaauccgucuccaccaccagaucuuucuccguggauuccucugcuaagaccgcug\n", + "guugcccaggcuggucuccaacuccupcucaagcaauccuccugccucagccucuuggagugcupauuacag\n", + "cuccuguaggcaucuccugaauuaagcaacacagaaaaguccucugaagucacugaaucccauaaaggcucucuaccuuuagcacaapaggucuucaccacuggacaaagaaggaacgauaagg\n", + "gcagcagccpaccgcggccpcaggcagcagcccagcpacapaugccugccgucuccacccacag\n", + "cauagaaaccacuaacgaaaauuaacuguuuacuuuuucacugucugcccaucuccuccucaaccaguucacaucugccuccuucauccccacaucaccaaugccuggcucacagcagagcuucu\n", + "ccccccuaaaggcauagacaacaaaagaaauuuuauugagaggaaaacacaaguccuuaaacugcaaag\n", + "uucauuucguucccccuccucuugcagcaccucggcagguucaaacucuucuccpagcguggcggcgaucgcgaggucacgug\n", + "cucuucauuucguucccccuccucuugcagcaccucggcagguucaaacucuucuccpagcguggcggcgaucgcgaggucacgug\n", + "accccaucuucaucuggccuugacucugcccuugapccuapugcagccagccugcuccgagcuccccugcag\n", + "acucaggagcccagcuggcuucccccaguggagccggcacupccacagguggagcugccugccagucccpcugugagcccgcacuccucagcccuupcg\n", + "aacuccaucgucacuccaaaaugcugagaucuucgagaaagugauguugaaauucgucuuggucgccpaugcuucccaggagagugcccagaguuucacuaacgaaagaugg\n", + "pcuagccucupccggcgccuaggccggccaacgcggacgccpuugcggugauucccagcggcgag\n", + "agccccupcuagccucupccggcgccuaggccggccaacgcggacgccpuugcggugauucccagcggcgag\n", + "aguagagagaggcgcagacugcugupcacggccuuggaapapcgugcuaucaagaaaggcucuuccupaagcugagaapc\n", + "cuuggaagcuucuaccuccagaaguccagacaccuccccuguaccucucguaccacagaggacag\n", + "aggucuccuccagcugugcccccacuccccuaaaagccuuguauuccccccugcagguucccucuggccccaccaggagaagaag\n", + "acuuggaagcuucuaccuccagaaguccagacaccuccccuguaccucucguaccacagaggacag\n", + "agcaggcucagaagguccagaaaucapaaggagaccccuaucuguccuucuucuggaagagcuggaaaggaagucug\n", + "gcccugcgcgcccugcgcucgccauggcgguuupcggcgacgugagcggcuccgcggaccccgagcpccccggccgcgaccugagccgccgccgagcgcccpcc\n", + "ggcpcccugcgcgcccugcgcucgccauggcgguuupcggcgacgugagcggcuccgcggaccccgagcpccccggccgcgaccugagccgccgccgagcgcccpcc\n", + "gcccugcgcucgccauggcgguuupcggcgacgugagcggcuccgcggaccccgagcpccccggccgcgaccugagccgccgccgagcgcccpcc\n", + "gugcgcpcgcgucggccggcgapagcagcaaacggccggcggcpugccgcgcppcpcggcgcggaguagguggcggcggcc\n", + "gugcgugccgugcgugagcgugcgcpcgcgucggccggcgapagcagcaaacggccggcggcpugccgcgcppcpcggcgcggaguagguggcggcggcc\n", + "gcgapagcagcaaacggccggcggcpugccgcgcppcpcggcgcggaguagguggcggcggcc\n", + "guccuguuucccucugauuuggcaagagagacaaucuugcaauaauaaauuaacauucuagcucugaggaguucaacuaagaaauuuucucaucacuaagaguaacuggauuacugcaga\n", + "ccccguaggcugupucaaaagugccggucaaaauggaagugaaucccccuaaacaggagcaccugcuggcgcuaaaag\n", + "accgcggucagccagcggaccagcggcaggagccguuccccgacpcagcapcgcucggccuccgcgugupcugagcgcggcgacgcugcugccccgaaauccccguggauuuugagucg\n", + "auuuugagucaggagccuggacugacccpucccuccacagcacuggapupacacaucacuacapuuuccuuccaugaggacucugaggaguugacaguggaggcaaggagugagcug\n", + "ggapupacacaucacuacapuuuccuuccaugaggacucugaggaguugacaguggaggcaaggagugagcug\n", + "accgacgucccgcuaggcugagaccggugcgccgcgcgcuaguggccgcucuuccgcpcuagcpcggupcgccagcagcgcggaaggcpcacgcpcc\n", + "aaagapcggcagacccgagcgccuaggacucgccgcugcccgcgccccgccgccgcugcugcccccagccccggccccaggcgucccagcc\n", + "aggacucgccgcugcccgcgccccgccgccgcugcugcccccagccccggccccaggcgucccagcc\n", + "cauuuugaaagcgaagcagaagccguagaaucagcggcgagccuguugaaagaacccacaggugcauuucacagcacucupcgaaaauuggaugugaaa\n", + "cuacugcugcugccgcugccuguagacuuucagaucaucucccucuucugugucapaaugcuccuggcuggugcggacacaacccaauag\n", + "cauuuugaaagcgaagcagaagccguagaaucagcggcgagccuguugaaagaacccacaggugcauuucacagcacucupcgaaaauuggaugugaaaaugaagccagaccgag\n", + "aaacagcagagaaagaacuggccgagcgapacpagccpcgccagagcuagagacagcpcpcaaggagcuggcagaggcgcugg\n", + "acaagaagacaagaaaaugauuugaggacagcuucaaucgcggugugaagaagaaagcagcaaaacgaccacugaaaacaacgccg\n", + "guggcaaaauauccaaagaaapucccaagcgguacaucgucauagccggaaacagucagagccaccagccaaugauauuuucaaugcugcgaaagcugccaaaagugacaugcag\n", + "caccgagaaguccgcgugaagugcgugaaggcucugaaapcuguacgguaaccpaccugaccgcacgccuucacuggccgcuucaag\n", + "gacuggaugguuuccaugaucguggacagagaguacaguguggcaguggaggccgucagauuacugauacuuauccuuaa\n", + "gaacauggaapugcugauggacguggacugugagagcgucuaccccauuguguaggccucuaauugaggccuggccucugcugupugaauuucuguacuggaa\n", + "acuuuucuacccugagugcgagauaagaacgaupuggaagagagcaacgccagagcccaggcgcccagaggacuuucuuccagcuucugcuguccuucuuuguggagagcaag\n", + "ugcaugucuggapaccaaggaaaguguggagacgcuccaaggauuaggugaucggagcuugaaaagaaaaaaagccaaacaaauaaacaaaacccacccacccuaacaaau\n", + "gagcuagacggcggucpuaggugacggcuugguupucgcugcgapacuacuaggagcgccgaggc\n", + "ccacuuccggcuacuagccucucucgccuauccacuauccucacacucagcauccccugucuguacgagauuaaggagcucugccguccgcapccugg\n", + "cucucgccuauccacuauccucacacucagcauccccugucuguacgagauuaaggagcucugccguccgcapccugg\n", + "ugagcggccgcgucucuguuggaaccggcggcguugcgucuaaaaaggcgaaagccuugagguugaaggupacgagccuaaugaagug\n", + "gauucaguggccuuugaggauguggcugugaacuucacccuggaggagupcuuugcuggauccuucccagaagaaucucuacapaugug\n", + "agacpccuuacucugcugccuaggcuggaguacaguggcacaaucauagcugauugcagccucaaacuccupcucaagcgaaacucccacgucagccuccugaguaccupacuacag\n", + "guacugaggauggaggacaapucaguggagacccagcuuugagcagagcccugccuaagguccapcucgaucuggcccuaaccacagagucaccuugag\n", + "cucagccagacguccaggaucccaccccuugcaaaagaccaggccguggaagccauguucccaccagccapaag\n", + "gugcpaaugcagauggcugaguaggucagauugaggacauggcagcgcagcucugguaaaagagugacacucuggaua\n", + "acaguucaggaaacuuaaaaggauggcauauggaaguugagugaaggagaaagagapaaguagaaaagaggagaaaaauguuaagcaaaaaag\n", + "aggaagugcggaccgcggcggcggcggcggcggcggcggcggcggcggagcccggagcgcaggccggaggcucccggcccgccggccccggagcggagcggagcggagg\n", + "gcggaacuuuccagaacgcucggugagaggcggaggagcgguaacuaccccggcugcgcacagcucggcgcuccuucccgcucccucacacaccggccucagcccgcaccg\n", + "cauuguccagauaugaaccaagguuuggccuuuucacccagagaaaaaggacaggcucaupuacacugugcupaugacpcacaaa\n", + "papucgcggccgcacuggcagucuccpuguccggccgugucccgaggaagugcaagacccg\n", + "ccgacugaagguagagaaggcuacguggupapuppapucgcggccgcacuggcagucuccpuguccggccgugucccgaggaagugcaagacccg\n", + "gauucccgacugaagguagagaaggcuacguggupapuppapucgcggccgcacuggcagucuccpuguccggccgugucccgaggaagugcaagacccg\n", + "papuppapucgcggccgcacuggcagucuccpuguccggccgugucccgaggaagugcaagacccg\n", + "acauuggagacgcggccaccaccgcgcuggcgcggagagapaggaccpcgucaugcuguuucuggccugag\n", + "ccaaccuagaaguucucupacagaaccuuggcggacaacugaauuaauuguucuagucuccaggcccaguacauggaugcuuguuggaugaauuaaugaaccuugacccacaccaag\n", + "gcccccgagcaggagccggugcgagcggagcagagccgaggucpccgcgagcggagccggcugagcpcgccgagcucccgcc\n", + "caccgcaaagccgguucugccgcggccaguaggcggugcccugcgcuucccagugccuucccacag\n", + "gagauacccugaaaccuccccccucugaccccgcagccaggccccaggcuggccpaguggccccucacacugguucuccccacuuucucugccuguggcaucgaaggccccpcacc\n", + "ggcuggccpaguggccccucacacugguucuccccacuuucucugccuguggcaucgaaggccccpcacc\n", + "aacaccaggacgcaagacaagupcaucuguapccacagugagcucucaaugaucaucuguaguggcagcaaaagag\n", + "uucgagccccacuucaaacaacuucauaauaaaaggccagacaaaagagcugucagccaguuacuacagacacucaaugcagacaccuucagag\n", + "ucuguguuccgcggcccggccgcggcugagucuucccapucapucaggcgcuuugcugagucccuuuguggccgcc\n", + "uaccgaucuguguuccgcggcccggccgcggcugagucuucccapucapucaggcgcuuugcugagucccuuuguggccgcc\n", + "ggauaauguuuagcaaaauaacuugaagaacaugauggcgaauugccugguguggagaaacauccpcugauggacuggauugauuag\n", + "ccggugcgacgucaacgcagccpcgaguuuuaccgaucuguguuccgcggcccggccgcggcugagucuucccapucapucaggcgcuuugcugagucccuuuguggccgcc\n", + "cgcagccpcgaguuuuaccgaucuguguuccgcggcccggccgcggcugagucuucccapucapucaggcgcuuugcugagucccuuuguggccgcc\n", + "gcgcgccggugcgacgucaacgcagccpcgaguuuuaccgaucuguguuccgcggcccggccgcggcugagucuucccapucapucaggcgcuuugcugagucccuuuguggccgcc\n", + "caccggcgcgguaccugcagcpcggcggcagagugugupaucuccugucugugcgucggaggauagugaug\n", + "ggcpuuucccgcgcucggcggaagcggaapcpcuccgcgcuccuagucuccacugcugccgccgucgccgccacccgagccggagcpcupccgccaaggcaag\n", + "agcuggagcccgcggagcccacggagcccacggagcccacggaggagcccacggaggagccccagcguccgaacpcagacccccucgagccgcgaaggagcccgagaagcagccacg\n", + "gcacuaagcacaucuacaaucaaggagapcaggcuuuaccuuuugaaggaagaaguaugaaaguguaucacugacugaucaaguagag\n", + "gaauuugaauccugupccguugaauguggcugcucgcggucggcgugccccgacguacagcpccpaaaaguggcacugaggcucuggaacuucugcccagcucuccuug\n", + "cuuguguuuucugucgaaaacaugaugacuguccuaauaaauacggagaaaagaaaacuaaggagaaauggaaucucacuguacauuacuacuguuug\n", + "cuaaaaaacauucccuucaauuuaaaaaauguucccgacucuuaacaccccaguugagaacuacugaucuuagauguauuaaag\n", + "aagcacaucuacaaucaaggagapcaggcuuuaccuuuugaaggaagaaguaugaaaguguaucacugacugaucaaguagag\n", + "accugcuggccuggcgcgcgcgcpcpagcggapcaacpcggcgcpcggccpcgcapucgcpaggugacgcgcggcgagg\n", + "apacggaggcccgcgcugcccaagagcgccacpcpcpccggcggcpcugcpcgcggccggacpaguuccccggagaaggauccugcagcccgagucccg\n", + "cuauugcaguacaaggcagacaucaaugcagugaaugaacacpaaugugccccugcacuaugccuguuuuupccaagaucaaguggcagag\n", + "aggauaaagcuupuucauccuccuucccuggaucacuccacaguccucaggcuuccccaauccapacucggcgccpacgcugcu\n", + "gcggcpcugcpcgcggccggacpaguuccccggagaaggauccugcagcccgagucccg\n", + "aagagcgccacpcpcpccggcggcpcugcpcgcggccggacpaguuccccggagaaggauccugcagcccgagucccg\n", + "gcpcpccggcggcpcugcpcgcggccggacpaguuccccggagaaggauccugcagcccgagucccg\n", + "ggauaccaaggacgcgacuucuuguuuggagapuggagcuuuggagugagacccaggaggccaaaucccaaagagaaaaauaggagccuaaauaaggaucaggaccaapaap\n", + "auugauuggcugaggcpagcaggcggcuggccggcagcaguuacucpuuuccggugcgaggccagaggupaagccaucggacgucggcggugag\n", + "gugcapaagaggagguggccugagccaggacgaugaggaugcaauguugaagaauaagcuggagaagagaaguaaccggcacu\n", + "guuucapaagucaagccucucuacugcuucuuuuuauaaccuuuaaguuaauucagaacccagauaagccuugaucugaggaugauauaaccaccgcaggcaacaup\n", + "aacuucuagagaaaacaagaagaagacuucaaaaaacaugcugugaugucucccaguggagacapcacgag\n", + "aggaccccggcggcuacccaugccgaggugaguccgcpagccgccgccgccgccgucccgucccagcugccgccccgcgcggccccgccgccggccagg\n", + "ccggcggcuacccaugccgaggugaguccgcpagccgccgccgccgccgucccgucccagcugccgccccgcgcggccccgccgccggccagg\n", + "aagcgccuguugguaggaaccugcuuggucgcgucugapcuuguagguggcucuggcugaaacaggcgccugcgagagucuguaggapaaaccgcc\n", + "ggaaccugcuuggucgcgucugapcuuguagguggcucuggcugaaacaggcgccugcgagagucuguaggapaaaccgcc\n", + "aaapcccugaggcagaaggugguccacgaagucaagagccacaaguucaccgcucgcuucuucaagcagcccaccuucugcagccacugcaccgacuucaucug\n", + "ucugcagcuuugugguucaucgacgaugccacgaauuugugaccuucgaguguccaggcgcupaapcccccagacggac\n", + "gacccccggaacaaacacaaguuccgccugcauagcuacagcagccccaccuucugcgaccacuguggcucccuccucuacpcuugugcaccapc\n", + "aagauggcgcccgaaacccggaagugagcggcggcagcugcgaggcucggagaaacaggcgccgcpcuccgcgcccggccggacccpcccgag\n", + "aucaugaugcugccgccaccgccgccaccacggagcgagaagcccagauagacgccccggcggccccpuccuggagucccgccgccugcugcccggccgaggaccccaccccgccugccgcccg\n", + "gaaacccggaagugagcggcggcagcugcgaggcucggagaaacaggcgccgcpcuccgcgcccggccggacccpcccgag\n", + "caaaacuuagagaguaaccucaccaaccuuauuaagaggaacacagaacuggagacccuuuuggcuaaacucauccaaaccugucaacauguugaa\n", + "gucaaugcaucacgucaagaagccaaauugacagaggagugugaucuucucauugagaucauucagcaaagacgacagauuauuggaaccaagaucaaagaapaag\n", + "gcaaaggcaaugcauguaugagcugugccucuagagcaaauucugaagaaauugcgaaggcuauuaauuuuuacaaaccaag\n", + "auagagucucgcugcauagcccaggcuggaguccaguggcgugaucucggcucacugcaaccuccaccuccugcauucaagcaauucuccugccucaggcucccgaguagcupauuacag\n", + "cccagccugcuugaaggaccuacagguuugucucuuccagaucagaacugaggaacaaaaacccccauccupaaaaaupaagcug\n", + "acuugccccagcccagccugcuugaaggaccuacagguuugucucuuccagaucagaacugaggaacaaaaacccccauccupaaaaaupaagcug\n", + "acaugucaaagagacacacacuaaauuagcapaguguuauaaaaacuuuggagugcaagcucacagcugucuuaauaagaagagaaggcuuca\n", + "gcccccaucuucugacuuuuccucgugugacccaucuuuucaaauucccuuaccugaggaaggagcccgauuacaaggauauuuaccugcuccuacccugaucuag\n", + "ggacgaggaupaagaccgccuguggccaugagcccuccccggugcuccupcuaaggcupcugcagcc\n", + "ggcccccaucuucugacuuuuccucgugugacccaucuuuucaaauucccuuaccugaggaaggagcccgauuacaaggauauuuaccugcuccuacccugaucuag\n", + "gcucucuguuuccucgagucacucccagauuaguggugucuagcucagcacuguuucuguuauacuucauucauaauucccagcgcuguu\n", + "cccucaacuucaaagagucacaaaucacccuuaaucaaaaapugcagaaauuuuuuupcccuccccgcc\n", + "pcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "gcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "guggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "paguggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "aguccguagaguauuagcuacagaaaccuuuccauugccauacugagaaacugcagcaggcagugugccuacaggucuacaaagaaacuucag\n", + "cgcaaccucugcucccugccucgccucccgcgcgccuaggugccugcgacuuuaauuaaapccguccccucgccgaggcugcagcaccgcccccccggcuucucgcgccucaaa\n", + "uugccuacacuuaaacucaacuuauguguauuguaaaucucuaagacaauauuagucuuaccaaacuuaccugaccauuuuguuuuauuuuuauuuuuagccaagaauauc\n", + "uugccuuuuuguuccccuguccucauuccucugcugcaaaaccuucugcuuaaaauacugguucauuucuaguuacapacccacuugccaucugucauuccaggaaauuugugaa\n", + "gauagauucccagaagupauaacuggaucagapugauuacccuguguauaagaguaugugucucacugcaccuucaauggcauugaguag\n", + "ggaggcgcagcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "agcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "ggcgcagcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "gcuguucuuccpuuggaggcgcagcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "ggcaccagguuugauugacaaggacuggcggapaaagcgcggaggcupcupccgcaggccgaggcagagacaaagagguuucgccuguccccgagaguggaapccccup\n", + "cuuccpuuggaggcgcagcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "gcggaguupcuguucuuccpuuggaggcgcagcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "gacaaggacuggcggapaaagcgcggaggcupcupccgcaggccgaggcagagacaaagagguuucgccuguccccgagaguggaapccccup\n", + "cacupagaguaauaccaaagugaauauaacagcugauaaggauauucucaguccuggcaacaacccugagag\n", + "gcagcgccgcpcccaagcccpucugccagcgcgacguccucucgcggcccucapcacagcccaaggcugucagccucccggcccag\n", + "ccccuccccccupucggacgcugagcggagccgcpcpapcggacggaccgacugacgguapacpaggcgagcaag\n", + "agcuccuaccuccuuccuaggaagupaaaccuuuacauuuccgaaggcagauauuuuuagaugugaugcucuguccaaaguguuaacuaauugaguuaucagguuucuuacuuggccacagaga\n", + "aacaugacgcuggaagagcucguggcgugcgacaacgcggcgcagaaguaaguagccpcugccgccgccugag\n", + "cggaugccuuggcacugucuggcacaauccuuggcapaagupaapaacccccauccuggcaggacuaagacaaaaucuauccgugcaacag\n", + "gguucagccgacuccuacaccagccgcccaucucuggacucagacgucucccuggaggaggaccpagagugcccggcgugaaguagagagccaggcucagcagcagcucgaaapccaag\n", + "cacaaaccuguggcauuugcggugaggaccaaugucagcuacuguggcguacuggaugaggagugcccaguccapcucuggagucaacuuugaggccaaagauuuucugcacauuaaagag\n", + "aaguacagcaaugacugguggaucpcggcuagugaaagapcpacaucgccuucauccccagcccccagcgccuggagagcauccggcucaaacaggagcagaaggccag\n", + "gagaucupaacccuuccagccugagugacauuggcaaccgacgcuccccuccgccaucucuag\n", + "agaaapcpapuacugacccgaggagcggucccgcgacucuguacucccugcugcccagucccggccaggacgcugcccggcuuagcupcgccccucgagaccagg\n", + "gugcaggcpagcagcgugcagagcagcggccpuuuugcucccgccucggagccccuggcccpapagaggccgcuagccuggucu\n", + "gcagccucuccuccccuuccuccccgccgccacggccccguaggugcucpacccaccuuccaccuagcacgg\n", + "aggcgugcaggcpagcagcgugcagagcagcggccpuuuugcucccgccucggagccccuggcccpapagaggccgcuagccuggucu\n", + "acugacccgaggagcggucccgcgacucuguacucccugcugcccagucccggccaggacgcugcccggcuuagcupcgccccucgagaccagg\n", + "aguccucccccggcgccuccgacuggcagupacucagcpcguggaggucgcggcugagcgagcgagcccupcga\n", + "ggacgugcgaggaugaugcuugugcaagaaggaaaugaccgcugucccggcuccgcpagacgaaccccggcuucccgcccucapacuagcucuccapaacupacg\n", + "gugcaagaaggaaaugaccgcugucccggcuccgcpagacgaaccccggcuucccgcccucapacuagcucuccapaacupacg\n", + "gaaaugcugugauuauaaagccuucugaacugagugaaaauacagccaagaucuuggcaaagcuucucccucaguauuuagaccag\n", + "acgcauaaccupaaaauacaugaauuguggccaaaccugcauugcacccgacuauauucucugugaagcaucccuccaaaaucaaauuguauggaagauuaaggaaacagugaag\n", + "aguccucccccggcgccuccgacuggcagupacucagcpcguggaggucgcggcugagcgagcgagcccupcgagugaauuguggcugupuugacgguggagacaccccccggapag\n", + "gcguuccuguccggccggucgcgaccucugcgguuucggcugcagcagcuggaggcccugcggagg\n", + "aauapugaggcuuupucgagcucaguccucccccggcgccuccgacuggcagupacucagcpcguggaggucgcggcugagcgagcgagcccupcgagugaauuguggcu\n", + "gacgguggagacaccccccggapaggcggapaapaggcgaggccugcaccugcaugcuucccgccucccacuccccagcgcccccggaccgugcaguucucugcaggaccaggcc\n", + "aagacacgccagapaaggaagugcccgagccpauuggagccpcgucugaggapaaacugaggcugcagaaguccguguggagap\n", + "ggauugcgccugcgcgcuupagapacccgaggaagagacugguucgccgcpaccpcapcuccccgucggagugcacugcgccggacacuucaa\n", + "guuuaaguuuuugaaacugaaguaggccuacacaguaggaacucaugucauuucuuguaaguaaaccagagcgaaucagg\n", + "cucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "ccccacugcgcauggcacguugcguacuccccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "acguugcguacuccccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "guugcguacuccccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "aaauguuuuuupugccugcapauuupcgccggagaupuupauaaggaagagagcucgapapcagugg\n", + "ggcggagccaagacggucpcugcuugcuaacuccaggaacagguaccugccuggcpugccug\n", + "cccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "cuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "ccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "gcaaaggauuugaggaccugaugacugugaaucuagcaagguacaaaccaacaggagaguacgugacuguacggaggauuaaccuagaagcuuguuccaaugag\n", + "cccacugcgcauggcacguugcguacuccccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "uacuccccucccagcaaccggucuggcggcggcgcggcaguaaaacugaggaggcggagccaagacggucpcugcuugcuaacuccaggaacag\n", + "ucccaggaggcgucpcugcgccguacaacuuccggcuguaaagauggcggcuuccuagugagucggcggcugauuuagaaggagguucaggcuacggugagccgaag\n", + "gucagucaguccacuggcucccgcgccgcgucuguguccgucgcucggapuggaagccpucucgcpccgcpccgc\n", + "agcaguguaaaauguguuuucugccugccuugacucgacaagccaaaugugcccuccuuuucuuuuccagguugugccuuuuuagccaagaagc\n", + "cucggcccgcgaaggccgccagcugcpapapaggcgcggucccgcagcgcccccaggcucaugucccag\n", + "aguaagapuggcagguupccaggccagagccuggaccupaucaggaapuugcapap\n", + "gucuacauuaguaauucccaacuupuccgaaagugaacuuuugcugaagcgaaguagcuaaccgcuuccaugugcaaggcagguuccagacuucp\n", + "ggucucugucugucauccaagcuggaccgcaguggugugaucauggcucacugcagacucaaccuccccaggcucag\n", + "ggcagagacapcacugguuucccucuaccagaguuccugacccagccgagaacaaaccgcgaagcaaguucagccgaacaacgauggugaaaapuccuccugcucacagugugaauaacag\n", + "gccaugcugcuguagacccuaacagcgucucuuccuggccaagagaagccuguccccaagaacaggagagcc\n", + "aauucaagacaaagguugcuucccuucugucucuggaucaggaaucugaacccauuaccacaaacagaa\n", + "cacaguucuggaggcupaaguucaagaucaaagugccagcagauucagugucaugugaggacgugcuuccugcuucauagauaagag\n", + "guggacgcggcggccccgcggcpcagcpcggcpcggaggcggccgcuagcgcccugcccggcgccgccuccuucggcguucgccccacggaccggcaggcggcggaccgcggcccag\n", + "gcugaagcucapcccugucugcucuguggacucaacaguuuguggcaagacaagcucagaacugagaagcugucaccacag\n", + "uucuggaggcupaaguucaagaucaaagugccagcagauucagugucaugugaggacgugcuuccugcuucauagauaagag\n", + "gcagcpcggcpcggaggcggccgcuagcgcccugcccggcgccgccuccuucggcguucgccccacggaccggcaggcggcggaccgcggcccag\n", + "ugccacaccccccugucccagugcacupcuguggaucccuucaaagcugagauugccugucuguggucuccagcguuaagcacagucauuagcucag\n", + "guuauauacucccagccuuucugauuccauuguaacucuugccgaaauccpugaacggaaguagucucuuuaagaacugguaupcaggcccaaguugucaaggcuucggaggua\n", + "cucuuucuccaacaccuagccugagacuuggcggcgcggcugcuauccugaacuagcuugguaaguguugugucccgaaccagcguagagagaccucggaccagccgccuug\n", + "ucucucugcggcuuggcccguuagaggcggcuuguguccacpacgcpcggaucuucuccggcc\n", + "cucucugcggcuuggcccguuagaggcggcuuguguccacpacgcpcggaucuucuccggcc\n", + "gccgaaagcuagguccggauugcacguggapccgcccgaapcacucucggacauuaacccgcauucug\n", + "gcgaggcuagcgcuacccgugcgccugcguggaacgauucuguggcgagugccggccgaaagcuagguccggauugcacguggapccgcccgaapcacucucggacauuaacccgcauucug\n", + "gccggccgaaagcuagguccggauugcacguggapccgcccgaapcacucucggacauuaacccgcauucug\n", + "guggcgagugccggccgaaagcuagguccggauugcacguggapccgcccgaapcacucucggacauuaacccgcauucug\n", + "uagcgcuacccgugcgccugcguggaacgauucuguggcgagugccggccgaaagcuagguccggauugcacguggapccgcccgaapcacucucggacauuaacccgcauucug\n", + "acgauucuguggcgagugccggccgaaagcuagguccggauugcacguggapccgcccgaapcacucucggacauuaacccgcauucug\n", + "auuuggucguauupcgccuggucaccapcugcuuuuaacucugguaaaguggauauuguugccaucaaugaccccuucauugaccucaacuacaug\n", + "guuuacauguuccaauaugauuccacccauggcaaauuccauggcaccgucaaggcugagaacpaagcuugucaucaauggaaaucccaucaccaucuuccaggagugaguggaagacaga\n", + "uucgacagucagccgcaucuucuuuugcgucgccaggugaagacpcggagagaaacccpaggcuapacggccugaaggcggcapcpcgcaggccggauguguucgcgccgcugcp\n", + "aggcgugugugucggccpccacuaggcgcucacuguucucucccuccgcgcagccgagccacaucgcucagacacc\n", + "auuuggucguauupcgccuggucaccapcugcuuuuaacucugguaaaguggauauuguugccaucaaugaccccuucauugaccucaacuac\n", + "ugacucpccaguguagagguccucaggccgccggcaggagcagcupccaauucccuggccpagcggaap\n", + "cgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "uuuaagaggcgacgcuggagccggagccauuuuccccccuucggccgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "guccagccccgcgucuccccuccccgcgcuugcaccagccugcccucggaggcgucgcucccucgcuccgupcgccugccpagccggcuuccpcugcccccgaggaguguggaacuaa\n", + "ggagccggagccauuuuccccccuucggccgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "uccccccuucggccgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "cccccuucggccgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "gcccuuuaagaggcgacgcuggagccggagccauuuuccccccuucggccgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "gcuugcaccagccugcccucggaggcgucgcucccucgcuccgupcgccugccpagccggcuuccpcugcccccgaggaguguggaacuaa\n", + "aggcccuuuaagaggcgacgcuggagccggagccauuuuccccccuucggccgcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "aaaaucuuuucuggaccapcccgucacugugauuuggcaacacaacuggcacaucucuuuucucaucucuugaaaaaaaccaacagagaaaaaaguaccuugagaauaaag\n", + "guccuuggauguggcuguguugcccaagcuauucucagucgaggacguuuuggapucaucacuaucaauguuggauuuuca\n", + "acugccggccugcgcgguacucacugccggccuccgcgguacccacugccggccuccgcgcuacccggccgcagcgcgcgagucac\n", + "agagcaggcugcacugcgcgguacccacugccggccugcgcgguacucacugccggccuccgcgguacccacugccggccuccgcgcuacccggccgcagcgcgcgagucac\n", + "aaccccacacaccccgcpugcuaaccgagucacggcucgaggccucupuccuuccacgccaggucauucagaaccugaaacccccagcggagguggagagccp\n", + "uucuugguucagcugaugguguuccugaucagcuucauaagcuccguguucuguggccaccupcaagcuggagcuggaugcagucacgcuggcaaucgcg\n", + "guuaucaaugucacuggugucucagupauucggcuuaucuucugccugugacacccucaucucccag\n", + "ggaggcgccacgucccuugcggcggcpagagaaaucgcuuggacuucpcggccucggacggcc\n", + "augcacagaaaaaaauaauaagaaauaagaaauucaguaaguuuacauggagauguaaaggaagaaccuauagcupauaaacuagagcauccucagaaaucuguugg\n", + "auuugugccugaagcugccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "agupucucgucuccucccaagcggagcauuugugccugaagcugccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "gcauuugugccugaagcugccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "ucucgucuccucccaagcggagcauuugugccugaagcugccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "cauuugugccugaagcugccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "gccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "ggaagupucucgucuccucccaagcggagcauuugugccugaagcugccpucugcuacggcaccgcpcugcagaaacccpccaapcpcugcuugccgcu\n", + "pagcugccaccccpagcpcugcgcaguguccpccgagccggugcgccgcagacuapcgccucpccapagcgcggaggagcc\n", + "gcgcaguguccpccgagccggugcgccgcagacuapcgccucpccapagcgcggaggagcc\n", + "agcpcugcgcaguguccpccgagccggugcgccgcagacuapcgccucpccapagcgcggaggagcc\n", + "ccacaagcaaggcuuugccuauguuuucuccuggcuccuucugccuccugaccaacccuggugcuuccccguguggaccccugugacauggcaugcccuucuupagcu\n", + "cacuucuccuugcugccaccgugugaagaaggacguguuugcuuccccuuccaccaugauuguaaguuuccugaggccuccccagccaugcugaacu\n", + "cgcgcccaccggagcccpcugagapaccupagcugcggccuggccpcggcgcacucagguggccucgcuucccugcpucaccgcccgccacucgcacagcuag\n", + "guuuacaggagccgcugucuccauaugugaapccuacuuuguggcucagcugcuggccaucugcuucca\n", + "acuuccpugcgcggucccgagguacgcggugcggucucccgguacccggagcggcucugauucaug\n", + "guuuaacuuguggcccuaaagaacuggaaacccaaaggaacgaauauuccugccccacagagucccaucuuuggugaggcuguuucuggaguuuac\n", + "ugcuuccucauucucuuuuaaaacccgcuucccgcugagucugcacccaggagaccagagagcaccuugcccuucc\n", + "gaacuuccguucuuuguucuguccccggugugupucugugacapuccaacapccugguccguguccggucccccaaaucugucgucccugcccccagg\n", + "cauuggcaucaacaaaagucagaauucccpaacuugaacagaggcugcuaaauucccaguaauugcuccuuuggccuucuapacugacuucaaagaaggaaggaaagaaucaggcag\n", + "pucugugacapuccaacapccugguccguguccggucccccaaaucugucgucccugcccccagg\n", + "ggaacuuccguucuuuguucuguccccggugugupucugugacapuccaacapccugguccguguccggucccccaaaucugucgucccugcccccagg\n", + "cuuuguucuguccccggugugupucugugacapuccaacapccugguccguguccggucccccaaaucugucgucccugcccccagg\n", + "paacuuccguucuuuguucuguccccggugugupucugugacapuccaacapccugguccguguccggucccccaaaucugucgucccugcccccagg\n", + "guucuguccccggugugupucugugacapuccaacapccugguccguguccggucccccaaaucugucgucccugcccccagg\n", + "gccuggcaagguuuagcggaggccugcagucugucugcuccucagcaccaugaauucgacuccaugcagcucuccau\n", + "aaauauacucupaaaaaaaauagaacaaauucuugccguccugaccauugaacaagagacuaauuagaca\n", + "ggaaccgcuccuuccgcuccgcccgccuggaguccuucuggccggauuccgcggcauccuuccauagacccucguuguugcuuccuccuugugguaaau\n", + "aacccgcucuguggcpcuuccggucpapuccgcccgcucucgcguccuuugcupuccagacaccg\n", + "gucucgcuugauupuuucucaupucucuggcguuucuacggcgcggcucucacggacucaggccaggccacucgcag\n", + "guuuauaacuugaaaaauccucuccgucucccuucccugccuccuuuccuuucccuuuccucugccaguacaacuagacccggcgucuggcguccccggugcccagcauucugcpcaggcg\n", + "auaacuugaaaaauccucuccgucucccuucccugccuccuuuccuuucccuuuccucugccaguacaacuagacccggcgucuggcguccccggugcccagcauucugcpcaggcg\n", + "auacaggcagaagaggagacauagacacacacagaggagaagaugaugugaaaapaggcagagaucacagugguguggcuacaagccaagaaauaccgaagccaucagaaguuggaagag\n", + "augaaaccaagccggaguuguuaccaguggcaaauacaugupucugcaacaaccucaauucuugccuccucagaagaaauaauuugacugapaaauaaggcagaaggagagacugag\n", + "acccacauggauucaccaccaguagcauacguugaugccaugcgacupauauaaucugcugcuaacauacuuuggugucaugugacuuggauacauuucccagug\n", + "cagccaucagccaaucaguugucugccaacccaucaucugccaccccauccuuagucaacaaagcaggaaucaacupc\n", + "ccuuccuucuccapuuaccuucuucuuauaaaccuguucaugacucaguccaggcuccucaucccuucacuuucaugcccccaaaugcacuaccgcaaauacaagacuggugugug\n", + "acuuccuaccguacgaggcgcaggupagacuuccgcccucgcpacuggcuapcguuugaccgccggcggugaapaggcggupcgucuuggagaacagagcgag\n", + "ggaagcaguccccggugucpcaggaggcacgcgcgcggcugaggcgaggucgcucggcgcagcuguugcpcc\n", + "ucgcucggcgcagcuguugcpccauggcpaccgcgcucaagaggcugauggccgaguacaaac\n", + "ccuugagaacgugcagugagagcuugaggaagaaggccugacuugcugcugcggaauuaggapaaaaguguaugcguuaaaapaaaggcucguugguggagcuuugaaag\n", + "aguccccggugucpcaggaggcacgcgcgcggcugaggcgaggucgcucggcgcagcuguugcpcc\n", + "agcaguccccggugucpcaggaggcacgcgcgcggcugaggcgaggucgcucggcgcagcuguugcpcc\n", + "agauuuccapcccugaggaaaggaggacucagacucugcucuucagauccacacacugaucccaacuacaaccagugaccugaacuuggagucugaguagg\n", + "ggcgguggcgcugguggcugcggcggcggcggcggcagcggcgcucgagcgguuccugucapucagccggcpcccccupugguccaccugcaaaucgcggagcggcgccccapaucg\n", + "aguugacuggcugaccucgcgccguccaccacccccuucccucuguuucucuguuuuuucuuucucuuucugcpuuuccugaauuugcag\n", + "auugauuauaccggaacagagccuuccagucccuguaauaaauguuuaucuccggaugugacaccuugcuuuuguaccauuaacuucacacuggaaaagucauuugag\n", + "uagauguaacccugagugaauugacapucaaagugccauuaccuuugupaaguaucccaagacacagagauggacaccuuggccauuguupagaagaaccagagucguagag\n", + "gguuccggcguggccauuuucguuggugguguucaguuguggcgguugcuggucaguaacagccaag\n", + "ggccgcpauggcpcagcapcgccuagcugcgccpagccpccgccgccggagucguugucgccggagccuggagccgugaacccagccgcgccag\n", + "cgcugaguccgcagcgcpcgaaagagcpcuucucuuguuuuaauuaaaaucuuaucacugcaguugcucuucgaggcagcauuggaaggauuucugccccuccaagcuuccuuuccagg\n", + "gacgupucgagagcpauccgaggcuggcpuuuuggcaguagcuguggcugcggcugccpccupacgcpcggccgaggccgccgucgcagccuccucgucucgccggcu\n", + "acgcucugugaugcaggccugugcuuacaguuaagccupcacccucagugcucaguugcuucaggcagcugagcuauucagacc\n", + "cuuuuuccggcgcuccpugcgagagacaggucpcccccuaggcagcgagccgcagcgcaaucccggcgcucgcccaaggacccuggaagcuaccguuaccccgccpcagcgupcgcc\n", + "gapagacagcuccuuggaggaggaugccgcuuaupuuuccccgcugcagcpcaccccagg\n", + "ccuaggcagcgagccgcagcgcaaucccggcgcucgcccaaggacccuggaagcuaccguuaccccgccpcagcgupcgccaugagcagcucgg\n", + "cucguagcggaggcagcagcgagguguccgauuupcacgugaggcccgcgauccccggcgguggacgccaggcagg\n", + "gagcauacgucaucguucucgcuuuccgguagcuaaggcgaucagcpacuucccacugagacgagcggaugucauauuguaucapcgaaccucugaggagcgcuggcugcgcuuaggcaacg\n", + "aaucgguugagagcugagcuggacuuggcggupagccggagccugcuuguugcagcugupugaggacggcucuagcuaggugagcggcuccggccag\n", + "ccugcuuguugcagcugupugaggacggcucuagcuaggugagcggcuccggccaggugagcpcgcauaggugacggapccgapcacpuaugaguuucugccpcgag\n", + "guggcccggauguucggugcagcugccagauccgcugaucuagugcuucucgaaaaaaaccuucaggcggccc\n", + "auuuauagcgcccgucacaaapcaggaccgcugcaaaaaaauggaaucuuaaaacuuuagccaucguucgcuaaaggaa\n", + "ccgccgagcucgcuguggcccggauguucggugcagcugccagauccgcugaucuagugcuucucgaaaaaaaccuucaggcggccc\n", + "auacaguuucucuuugccagacuagacuaaagaaggagcacuaauuuauucugauaaaacaggucuaugcagcuaccaggaca\n", + "acaguuucucuuugccagacuagacuaaagaaggagcacuaauuuauucugauaaaacaggucuaugcagcuaccaggaca\n", + "guucucgugccgguagaagcugaaguaccggucagccagccuccugcugcagagccagugaacucag\n", + "uaggcaguacucaucuuggcccupaagaaacucaagaagaagcuuuugaaacauaaagcuuggaupuuugaccucugcapcagcgcccagcuauaggaguuccccugcugagcagagaag\n", + "cuguccggucauuguucucgugccgguagaagcugaaguaccggucagccagccuccugcugcagagccagugaacucaggucpcuucucagcugcgcaca\n", + "auuguucucgugccgguagaagcugaaguaccggucagccagccuccugcugcagagccagugaacucaggucpcuucucagcugcgcaca\n", + "cauuguucucgugccgguagaagcugaaguaccggucagccagccuccugcugcagagccagugaacucaggucpcuucucagcugcgcaca\n", + "gcaguacucaucuuggcccupaagaaacucaagaagaagcuuuugaaacauaaagcuuggaupuuugaccucugcapcagcgcccagcuauaggaguuccccugcugagcagagaag\n", + "cauuguucucgugccgguagaagcugaaguaccggucagccagccuccugcugcagagccagugaacucag\n", + "auuguucucgugccgguagaagcugaaguaccggucagccagccuccugcugcagagccagugaacucag\n", + "guagaggaguccuugaaggauucuucauuguuuucuuggacaaaaagagaccaguggauccaagugcuucaaauacuucucucuuauuuucuuaacu\n", + "cuucauuguuuucuuggacaaaaagagaccaguggauccaagugcuucaaauacuucucucuuauuuucuuaacu\n", + "aaaguccupaagcguggaucaguuuaaugacucuggccugguaguggcauauacaccagucaguaacauaacacaaaggaua\n", + "agacagcgucucpcuagagugcaguggugcgaucaaaguucacugcagccuugaacgucuggacucuapacccugcugaauagcupcuacaggcgugugucacugcgcccag\n", + "cuggaaugaaaccucugaagaaucgagauagcuccaauagagguccacaggcagaaaggauuucaaggaucuucaaapuaaauguacccuggaagapauacuggaccugugauag\n", + "acagaucccagcupucacccgcacugagucaacagacugagcgcguccaggccugacagcucugcggcucpcccugag\n", + "gaaauuacugauauaguuuuuaaaauugagcuguauuuucaagcagcuuugcuuggaaucauuguuacugca\n", + "pcucapapcucugugccuccguucagcagagcugcagcugcugcccagcucucaggaggcaagcuggacucccucacucagcugcaggagcaaggacagugaggcucaaccccgccugagcc\n", + "auuuaggcggugacagacagcauccgcagucaauaggaagagcugaagaauucuuuaggucucccaaaaug\n", + "auaaaaucaaagacaaaauuaaagagagagacaaagaaaaagaaagagaaaaaaagaaacauaaaguaaugaaugagaucaagaaagagaauggagaaguaaagauuuugcugaaaa\n", + "gupaaggagaaaccaaaaacaaauauagaagacuuacaaauuaaaaagguaaagaagaaaaagaaaaagaaacacaaagagaaugaaaaacggaagcguccgaaa\n", + "auuucauuggcuaucagcuucaaggaaguuccauuauuucugguaccaucagagaaagacgccauuaccagcaguuccaggacaccuaaccaaag\n", + "gcuggugucaagacugugcuaaugaccuccagguccuaagucucuuguugccuggugacaaaguuucacaguugaggaggagaagcupacuagcagg\n", + "uuuuucaugauuuuuccucacacugaucacuauccaaucagaacaauaaacuucuaacacucccuuacuaaaagaac\n", + "gaacaugacaucgagacacccuacggccuucugcauguagugauccpcucccccaapaaccgcccagccauccucaccuaccaugaugupccucaacc\n", + "gcuccugccgcuucgcuccgcgcucuccugccgcuccgcuccpucucccgcgcuccucuccccggcucggccgagcgcgcugccccgacgccgccacccagagccpccgcgccpcgccgag\n", + "acagagccgaccaucucccacucgagcugcccccgcccucuggacccgagugacucaggccuuuguuuguccuuccugguagaggcpuucccucccucggcaagaugccggagugcupaup\n", + "acagagccgaccaucucccacucgagcugcccccgcccucuggacccgagugacucaggccuuuguuuguccuuccugguagaggcpuucccucccucggcaag\n", + "gcuccgcgcucuccugccgcuccgcuccpucucccgcgcuccucuccccggcucggccgagcgcgcugccccgacgccgccacccagagccpccgcgccpcgccgag\n", + "acapccuggapcpcapccucgcagcgcacccagcacaguccgcgcggcggagcgg\n", + "gapcuccuggcugcccgcaccugcacccgcgcgucggcggcgccgaagccccgcuccccgccugcgcgucugucucguccgcaucuccgcg\n", + "cuggcugcccgcaccugcacccgcgcgucggcggcgccgaagccccgcuccccgccugcgcgucugucucguccgcaucuccgcg\n", + "uuuucaggccaucagauuuccguacucccuggagupacuucaucupaccaaaggapcug\n", + "gagccgaccaucucccacucgagcugcccccgcccucuggacccgagugacucaggccuuuguuuguccuuccugguagaggcpuucccucccucggcaagaugccggagugcupaup\n", + "accugcacccgcgcgucggcggcgccgaagccccgcuccccgccugcgcgucugucucguccgcaucuccgcg\n", + "aaagcccuuaccagcugcagaguauucacucugugcuuggccuauguggacggagcagaggagcaguugucagagaugacccagaggucccuugcaacccacaaccuaag\n", + "gcaccugcacccgcgcgucggcggcgccgaagccccgcuccccgccugcgcgucugucucguccgcaucuccgcg\n", + "cuccuggcugcccgcaccugcacccgcgcgucggcggcgccgaagccccgcuccccgccugcgcgucugucucguccgcaucuccgcg\n", + "agagccgaccaucucccacucgagcugcccccgcccucuggacccgagugacucaggccuuuguuuguccuuccugguagaggcpuucccucccucggcaagaugccggagugcupaup\n", + "agagugcaccgcgcuguggcccuugupcugcccuugcgcagcgcuccaapacpauguuuggcuucgaucaggcugaacugaguccugagcucuccgcagagg\n", + "ggacucgcgucccguggagcguuccaggcpcgcgcggcuuucuccccagacccaccgaguggcggcggaggcgag\n", + "gagcucuccaagcupccupaaugaaacaguggugcagcugcggacucuggagcugccuguagauuacapaggcuaagcggapucaccggaaucupaagaucaucagccgcaa\n", + "cauguuuucaagguugagccacgugguaguguguccagaauuggupuuguuggucucacugacuucaaga\n", + "paggacpaggcupcaugaaaucpaagccgauccucagcagcccgaccccuuccaggccaagacupauugcuccgcguc\n", + "guccugauguuuuuaguucaaagagucuugcgcuucaagcccagaagaagauucugagcaaaauagccagcaaaacuguggccaac\n", + "acuugcuagucuuaccucaaguaaupaaacgaccagaccuccuaaagagucagugugcaaguuapcuacugucccaagaaggacaccugaguccaa\n", + "ggagcgcuacuacgugcuguauauccggcccagucacauccaucgccguaaauucgacgccaapaaaugaaaucgagcccaacuucagcgccaccaggaaggugaacacpcuuccuc\n", + "ugcuguauauccggcccagucacauccaucgccguaaauucgacgccaapaaaugaaaucgagcccaacuucagcgccaccaggaaggugaacacpcuuccuc\n", + "auaaaugaauucugauuuupagcagaugccaacuuagagccucguaccaaucucucugucuuuaaaagaugaggugacuuggugauuuuccuggaaaauuauag\n", + "aauauuaaugaaacuuuaucaucuuggugagaaaagcauucuaauagcuuuauucugacauacggagguauggagagcuugaaggagucagagag\n", + "gugcccagcuaagaccugaaugccaucacccuccccapcucugcaguuuucucguggugaacccuugauggauuuguuguugcuugagaa\n", + "gcaguucccpucccucggccaccgaagccacccugcccuggugaaapcucccgcaccgcccggugcuccccaucugccuggcguugugcgcagagcuggaaagcauggcuguu\n", + "gaaapcucccgcaccgcccggugcuccccaucugccuggcguugugcgcagagcuggaaagcauggcuguu\n", + "accgaagccacccugcccuggugaaapcucccgcaccgcccggugcuccccaucugccuggcguugugcgcagagcuggaaagcauggcuguu\n", + "agauggaguuuugcuguguugcccaugcugguuuugaacuccuggccucaagugauccucccuccuuggccucccaaagcauugaaauuacag\n", + "pucccucggccaccgaagccacccugcccuggugaaapcucccgcaccgcccggugcuccccaucugccuggcguugugcgcagagcuggaaagcauggcuguu\n", + "aggcucuccagcagagaacccaggcccuucaccauacuggugcaugguuccugccacuugugcaguccauuccgaaguuucuuacagaugag\n", + "ucggccaccgaagccacccugcccuggugaaapcucccgcaccgcccggugcuccccaucugccuggcguugugcgcagagcuggaaagcauggcuguu\n", + "agacguguggagucccagcagaggccaaccugugucucuucaucuccgugagaaaggugcccccgaagugaaagag\n", + "acuccucagcugcaggagccagacguguggagucccagcagaggccaaccugugucucuucaucuccgugagaaaggugcccccgaagugaaagag\n", + "gagugagacaaagcggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "gcauuugcagagugagacaaagcggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "agcggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "agugcauuugcagagugagacaaagcggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "cggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "gcggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "auuugcagagugagacaaagcggagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "gagaacgcuggupccuguuguggaguacgcuuuggacugagaagcaucgaggcuauaggacgcagcuguugcc\n", + "gagugccpaapcuggccgcggcpugcpcggaccpucccgccgcccpcucaggua\n", + "gucgauuuggucagacaacgccaccacuuguugauuuucucaaggacauuuugagaagauauccagaaggaggacagauucuuaag\n", + "gaauuaauucagaaugcagaagaugcupcgacagaaguuaaauuuuuauaugaugaaacucaauacggaacagagacucuuuggucaaaagauauggcgccauaucagg\n", + "gucccuuuucccaagucuugaaggaagauuuauuuuggauaacuugaaaccucaccuuguggcugcuuuaaaggaagcugcccaaacccgag\n", + "gaagaccauguacucagcugcagcuucuaaauccagaacgauuugcacgucuuaucaaggaagua\n", + "gugcggcugcpacagucacgcupaacugcugauggcacuggaggaaaacaaaggccgagagacccugaugcccacagccccca\n", + "agugcggcugcpacagucacgcupaacugcugauggcacuggaggaaaacaaaggccgagagacccugaugcccacagccccca\n", + "cacgcupaacugcugauggcacuggaggaaaacaaaggccgagagacccugaugcccacagccccca\n", + "pagcgacugacugcggcaggagccgccuggacccagugcggcugcpacagucacgcupaacugcugauggcacuggaggaaaacaaaggccgagagacccugaugcccacagccccca\n", + "ggcggcccgcgcccugccugucaggccaccggcccggcccgcpcugcccccgaugcggaggcgcugucgccpcc\n", + "aggucucagagaggagccuuagcccuggacuccaaggccuuuccacuuggugaucagcacugagcacagaggacucacc\n", + "accgccacccaccagcuccggcaccaacagcagcgccgcugccaccgcccaccuucugccgccgccaccacagccaccuucuccuccuccgcuguccucucccguccucgccucugucgacuaucag\n", + "acccaccagcuccggcaccaacagcagcgccgcugccaccgcccaccuucugccgccgccaccacagccaccuucuccuccuccgcuguccucucccguccucgccucugucgacuaucag\n", + "ggauguggcgaggcagccgcggugucagaaagaggaaggcaggaggcugaggccgapcccuggaaucucgcacauuccapuucagaaagaucacggupuccaccucuggaguccacaaaag\n", + "aaaacguacaauguggccacaggccugcuuuuccaaacucgucaugguuaccauuucaugaacggcuucaaguccagaaug\n", + "ggaagucuauccpcuuucgcgucaccacccugcccaccupuggcgcguggcuuacgcaacggucacupcuccupccgcucccpccagcgapcugcgaaagaaguuguag\n", + "gcuuacgcaacggucacupcuccupccgcucccpccagcgapcugcgaaagaaguuguag\n", + "accupuggcgcguggcuuacgcaacggucacupcuccupccgcucccpccagcgapcugcgaaagaaguuguag\n", + "gcuuucgcgucaccacccugcccaccupuggcgcguggcuuacgcaacggucacupcuccupccgcucccpccagcgapcugcgaaagaaguuguag\n", + "uuugcuaauaaggcccugccaggcupapaauugucccugccugcuucuggagaaagaagauauugacaccaucuacpcacc\n", + "cauuugcuaauaaggcccugccaggcupapaauugucccugccugcuucuggagaaagaagauauugacaccaucuacpcacc\n", + "auuugcuaauaaggcccugccaggcupapaauugucccugccugcuucuggagaaagaagauauugacaccaucuacpcacc\n", + "acauucacuacaccuuuuccauuugcuaauaaggcccugccaggcupapaauugucccugccugcuucuggagaaagaagauauugacaccaucuacpcacc\n", + "acagcgcaguuugaaucgcggugcgacgaaggaguagguggupaucucaccgupuccgauuagccuuuucucugccuugcuugcuugagcuucagcggaauucgaa\n", + "gcaguuugaaucgcggugcgacgaaggaguagguggupaucucaccgupuccgauuagccuuuucucugccuugcuugcuugagcuucagcggaauucgaa\n", + "agaggaaugcuggacauccagagacaapaggcugcagcucacugcuccccagucccacaccuupccucccuuuggaacacacag\n", + "gugucucuggaggucaucccuaacuggcupcccccugcagaaccugcuucauauacpcagupcaccaauuccacacugcacuauguguggagcagccupccucuggcaguggua\n", + "gaagaugcgcgaaucpaaccccagagcgcgguggcuagaccpcuccgccgccucccccacagccccuuuccuaaucguucagacggagccuggucgacuucgccggagacugccag\n", + "gagaggaauguaaagaagugccuaggccuccuguuuuauuguuuuguuuuguuauuaaucuucauuuucuuuuggaaucugccuaagaguu\n", + "cuggaaacaaaagucucaacuuccaaccucuuugcagcuaggaguggccaaguagcauagaucuggugaaugaacugcaggupaauuucugagaagguuuccuucuuaaauagaaag\n", + "aagcgcuugacuugcuuccagacaaagguugucucaaguuuguugcucaaaccgaguucuggagaacgccaucagcucgcugcuuaaa\n", + "aagugacgugacaaucgcggccaccgccagguggaacggcaggupuucagguaccagccuggccpacccggcugupaccaacgcuuccg\n", + "auaacaagaccucugccagaagaaccauggcuuuggaaggcggaguucaggcugaggagaupugcgguccucagugagccccug\n", + "acuucugccagaacauugcacgcgacaguuucaggcacagaacugacuggcagcapcugcuccacgagupaauuugcuccagcacuucacggacugcaagcgaggcacuugcuaacucuugg\n", + "ccaguggcuccugugaccacaucgaccapugaggaccugagaacgagagcuucagcucaucupagg\n", + "acgcgcaccucccccaacucaacugccguucgucguucguggauguccguugugucccgagacuaggacguggcuccag\n", + "gagugcucpccagcugguccuuuucccaucccuccccaugaaggapaggcugguagcuuugccagcagcugcgccgcggcapuggccc\n", + "uucaggugcuccagaaggagagacugcccuguuggcupaccccagagcaacuccugacucacugupagcucacuuacuguugagugaacggacggau\n", + "cgaaauccuagcgaagcccccccauauugupagagauaccccugcgucapccccccagauccugaccacuupaggccgaggcpcggaucacgag\n", + "gaaagagguaacaccaaccccauuuuccagaggaagaaacugaggcccaagagaaguugaguccauugccccag\n", + "gcgccaacggaagupucgcaggaagaggaagucccgccucucucuccucaggcagcagcaacgcggaggaaacpagugaacggagagcguagugaccauc\n", + "uagagaccagguuucaccauguuggccaagcuggucucaaacuccugaccucaaaugauccacccgccucgaccuuccaaagugcupauuacag\n", + "ucagucaagaacaauacccaagugcucaucaacugccgcaacaauaagaaacuccupccgcgugaaggccuucgauag\n", + "cucucucuccucaggcagcagcaacgcggaggaaacpagugaacggagagcguagugaccauc\n", + "guuuuagcacaacccccucagaccacucuguggagaacagacugucapaacgupuggaggcagagagaccagaaagauuccaggacagagaugacagaggcuuaggccaug\n", + "ugccccupcaucccucccggucucuuccugcpuuucugaugaaacagccaggcuccaguaguggagccagag\n", + "gaugccuuccgugccuuccaucaagaucucaauuuugugcgcaaguuccuacagccccuguugauuggagagcuggcuccggaagaacccagccaggauggaccccugaau\n", + "aaucaaagucuucccpaggucuuucuguaaauccagagcugcagauguuugaccguguucagagapcccuugugcugg\n", + "auuccaggacupacacuucugugauucggacagucuaagcuucuaagagucuucgauucuuucccucucgcagaagaagcuccgucuacagccuccucaacuccugauuccacagaag\n", + "gccccacccccccuacuccuguccuccpuucuacugaagupcaaaauccccgagaagcagcgguguccccagccucucacucggagccgau\n", + "gagcgaaaacuacaauucccagcauuccuguggugccagaacuaccuugcccgaaagccugugcgagauuuaccccgucuuccgccucccucccaccggaaaacucugaggac\n", + "aguucuucacuaccacaaccaaggapauaugauaggcggccaguggauauaacuccuuuagaacaaaggaaauuaacuuuugauacccaugcauugguucaggacuuggaaacucaug\n", + "gauuugacaaaacacaagcagaaacaauuguaucagcguuaacugcuuuaucaaaugucagccuggauacuaucuauaaagag\n", + "accgaggcugaaagagacaggaguccuccagccgaggagaagcugaugcagcupcuugucccagapagagguagcuggagccauacag\n", + "ggcugaacaagacauccucuuucuccugcgaagcccauaacgccaapucaccacaucccgcacagccaccaucacag\n", + "ugcucccccagcagccccguaaccuccaccuggucucccgccaacccacggagcuggagguggcuuggacuccaggccugagcggcaucuacccccugacccacugcacccugcag\n", + "ugagcapugagcgcagccacugcccaacgcaaaccgugaagaagcuucuggaagagcagaggcgccgccagcagcagcagcccgacgcuggcpugcag\n", + "gaccpcgguccugagccugcgaccucgcaggcgaccucgcuggacccuaaguccaggccacagucapaapcgcugagaggcgagcgugagcccagcgacaggagagugag\n", + "uaaguccaggccacagucapaapcgcugagaggcgagcgugagcccagcgacaggagagugag\n", + "pcgguccugagccugcgaccucgcaggcgaccucgcuggacccuaaguccaggccacagucapaapcgcugagaggcgagcgugagcccagcgacaggaga\n", + "uaugauuuugaguauuggaucucuuguggccucuguacgaaacuguagaugugaauucauuuauaacuuauuuggaccuaugaaagaacuguuaga\n", + "aacccucuaacccuupagucugugugcagcagugaugugagcugcauccpcugaaaupagcucccgcuauggcacuggcucaaggagcuaaucuaaagagaaa\n", + "ugaaggugcugaacuuuggcacaugacuugacaaauucuuaagaacugccuaggaaagaagagaguccaggcuucagcucuu\n", + "auaaccuucuguucggugaugaaauuaucacuaaugguuuucauuccugugaaagugaugaggaggauagagccucacaugcaagcucuagugacuggacuccaaggccacggauag\n", + "gugucuguuucauguggaauaccugacuucaggucaapaugguauuuaugcucgccuugcuguagacuucccagaucuuccagauccucaagcg\n", + "gccagugccgcgcgucgagcpagcagaggaggcgapaggapccagagaggcaguuggaag\n", + "cagauccucaagcgauguuugauauugaauauuucagaaaagauccaagaccauucuucaaguuugcaaag\n", + "aagaaacagcauugaagcauuauuuppaaaaacacacacacaaaauccagcaacucagcauucaugagcaacucuauacuauaccagu\n", + "ccagaaagccaugucggacucggcgcccagcgcccaagcgcuaacccgcugaaaguuucucagcgaaaucucapacgaucuggaccccgcugagaggaacugcuuuugagugag\n", + "auccagaaagccaugucggacucggcgcccagcgcccaagcgcuaacccgcugaaaguuucucagcgaaaucucapacgaucuggaccccgcugagaggaacugcuuuugagugag\n", + "ggaaaaaaaacaagguccccacagcaaagaaaaggaauaggaucaagagauacguggcugcuggcagagcaag\n", + "aaaagagaucacggugugccccuuugucaucguucugucaggaagcauguaauuugucuuuagaaaccagaagccugagacaaagaaaagaacacagauuuuuagcaaaaggcuauuug\n", + "ccauaaugaaaggaaagugaccugcaaacauccagucacaggacaaccaucacaggacaauuguauuuuuguagugaaugaaca\n", + "guucccuccucccucggcagccgcggcggcagcaggagaaggcggcggcggcggcuapaucagac\n", + "ucagacauggcggcggaucugaaccuggaguggaucucccugccccgguccuggacuuacpaucaccapcggccgagucuucuucaucaa\n", + "cgaggaggccaagagcaccaccuggcugcaccccgucaccggcgaggcgguggucaccggacaccggcggcagagcacag\n", + "gacuguugcaaccaugacaucugaagaaaagaaggaacggccaauaaguaugauaaaugaagcuucuaacuauaacgugacuucagauuaugcagugcauccaaugagcccuguaggcaga\n", + "acuucacgagcuucaaaaaaaguucauaauuuuggaaagaggucaaauucaauuaaaaggaauccuaaugcaccgguugucagacgagguuggcuuuauaaacag\n", + "augagaaagaagapuauccupaagcauacuguuaccuaguuuucagauagcuuugcuuaccucugaagaucacauuaaucgcaaauaugcuuuuaag\n", + "gugcucacugagaacagcucaaagacaaagcaguugagucuuauuuuuacuccaguguucuuuuugccuguaauugaauauccuuuuaagaauugauuuugaugaaggcug\n", + "auuacaaaaaugucugccuucaaaupugaucuuauagcauaugcaacagugaauacaccuaaaccaacucugccaggauaauacaaaauuccuucuca\n", + "ggugcugccugcuggcgaaugugacucuccuccuguucacccacaaggcugauuuuuccguguuccuccucuggaaagagcauugcuuucucucuuccagcacuuu\n", + "guggcugcuucucuauuaugcucugugcuucucccugucaaaggcuucagcccacaccguggagcuaaacaau\n", + "guagaaacugaggaccaggugcuggcaaccuucuguggcapagaccacagacacagagcagacucccggccaggaggugguccucuccccuggcuccuuc\n", + "agaacaaagauaaggcaucacggacaccacaccpcacgagcucacaggcaagucaagcupaggaccaaggccpcagccpagcacccaaggcaggaaa\n", + "agcucacaggcaagucaagcupaggaccaaggccpcagccpagcacccaaggcaggaaaaugag\n", + "aggcauuuuggacuugcuaggacagugauaapccuupuacaaaaugcuccugauucugguguagcucc\n", + "gcggccgcugaupagucggagcccpcpcgagcggcggcgcggcggccaccaupaacaagcagaccaucuucaccgaagagcagcuagacaacuaccag\n", + "guagauccgauugcuccccaggacacagcuccugcauucccacauugaggccgagupcagcccacccuauucagucaccuugcuuuuuauag\n", + "ugaupagucggagcccpcpcgagcggcggcgcggcggccaccaupaacaagcagaccaucuucaccgaagagcagcuagacaacuaccag\n", + "acucugugcggagacupcggccggccgacccuuccugucgcugacggcgacugcpaggccag\n", + "uuaccuguaagcaaagugupcuacacacaucuguagucgcugaggcuagagcuugacucgagagaggaaaggaagaaugcaagcauggucaaguggcagag\n", + "gucaccuggagccupccggcccagcucucucaggauucagcagacauuggagguggcagugaaggauacagugguaguca\n", + "gccuccacagauaucaaaagaaaccugaagagccuacaaaaaaaaaagagauaaagacaaaauucaagaaaacacacacauacauaauugug\n", + "auucgccuccacagauaucaaaagaaaccugaagagccuacaaaaaaaaaagagauaaagacaaaauucaagaaaacacacacauacauaauugug\n", + "acucaaguuuuuagaagcuagaauauagaucccuuuaagaaaaaaaaaggaagaaagaagaauuugcug\n", + "uugacaucacuuguuagaagagcaacucugaaagaaaacgagcaaauuccaaaauaugaaaagauucacaauuucaag\n", + "acauccuuuaauauccccacaaagaacupaaaauaaaugaccagauuauggagaacagagccaaauauccagcacugacuuguuauaag\n", + "gcaaggaucaucagucauuggauguuaaaaccauuggaagaaaggcuguaggugaacaggauauuuacauggucucaag\n", + "cugugcugccuggcagaaugcucauguguuagcugaauagauaucaucgacagacauagaccacuauagguuuucuuuccuugugaauuccaaa\n", + "aaacacaagcauaguuaaacccaagugcuucccuuccauuauguggcaguacuuugucuugaaaacaacaagagaag\n", + "aguacuagguugaacagaaguggugagaguggccauccuugccuuguuccugaucuuagaggaagagcuuucaguuuuucagcauuaaauuugauauaag\n", + "guccugauucuuuaugugaagaaaggaauauuuaaaugacaauaauucaggaggcuauguugauagaaagaauaagugaaaagaggcaaaaaaag\n", + "agupcuuugcgagucugaacguuggcpcuaggcucguuaacugccgagagccuccpuuugcgguggaggacgcugaggcccguppcaggcacccpcgccpccucccagccgac\n", + "uggaaagauguuacuucaucucccagguuugcucacugcaaauacaauccugagaacugaacuapccuuaaaguccugacaugcauggcuugguuuuguggauugccucucucaacag\n", + "cgcuugcagcccapcgugaggugcucuuucuggaucgccagccucgaaguugaggcguggacucuggccagguggcuguuccag\n", + "aaaaguccacuguguguupaauagauuaugaapcuuugaguguaggcccuguaagcaauaggaagccauggaacagccagaaag\n", + "aucgagucuugcucugucacccaggcuggagugcaguggcgcgaucucagcucacugccaccuuugccuccupuucaagcgauucuucugccucagccucccgaguagcupauuacag\n", + "ggugaagapaacagaaaucuuugcccccugacuuuggaaaucucguuuaaccuucaaacuggcg\n", + "agugugcgcgcuccgaguguguguguauuuguguaucggcggucccgcaggucccggauguugcggacaguaugaggcaagcgcapacpaccagcagcugucgccgccgcucucag\n", + "gucccggauguugcggacaguaugaggcaagcgcapacpaccagcagcugucgccgccgcucucag\n", + "aaaaguucuucaggaaggucpcauggugacucaugccuguaaucccagcacuuupaggcugaggcaggaagauugcuugagcucaggaguucgagaccauccuggucaacaug\n", + "cccggauguugcggacaguaugaggcaagcgcapacpaccagcagcugucgccgccgcucucag\n", + "gcuccgaguguguguguauuuguguaucggcggucccgcaggucccggauguugcggacaguaugaggcaagcgcapacpaccagcagcugucgccgccgcucucag\n", + "guguaucggcggucccgcaggucccggauguugcggacaguaugaggcaagcgcapacpaccagcagcugucgccgccgcucucag\n", + "ggauguugcggacaguaugaggcaagcgcapacpaccagcagcugucgccgccgcucucag\n", + "cucucuuucccuugcuccggacccugagauccuggccuaccugagcucggcagaccugupccccuggugaggag\n", + "gaguucpccagcagccgucuacccggugucgcguucuguguuguggcggcccuggauccggcgucapcgaccpcggacgagguggagccagagucugucaggcgg\n", + "aaagugaagagaggaaauuggaaaauugugaguggaccuucugauacugcuccuccuugcguggaaaapaaagaacugcaugcauauuauucagcguccuauauucaaag\n", + "ugaagagaggaaauuggaaaauugugaguggaccuucugauacugcuccuccuugcguggaaaapaaagaacugcaugcauauuauucagcguccuauauucaaag\n", + "ggaggugcaguccguaggcccuggcccccpupcccuupagucggcgccgcucccpagcugcaaggcucgccccugcccggcguggapcgcppcgcggag\n", + "gauccagcuupuaggcpaagcagcuggagugcgaccgccgcggcagccacccugcaaccgccagucggag\n", + "acagucaccgaagaaaugaaguuacaggapcacaccguccuuuugucucugccuuugagguuggcpaacugaaacug\n", + "acggugcuguggccucuauucupacacugagcuccuccuugcucgagguuuupuccucauuguccac\n", + "agcuucacagucaccgaagaaaugaaguuacaggapcacaccguccuuuugucucugccuuugagguuggcpaacugaaacug\n", + "gcccuugucucugcucupucaggcgaggcagccacccaugaugagcucugcagccuucccaagguggcug\n", + "gucucugcucupucaggcgaggcagccacccaugaugagcucugcagccuucccaagguggcug\n", + "gcagcaagugagguguagagaauguguggagaucaggugaugcagaacucugguaaaggauguuagucuucagaguaagacuguuaaauucagcaaagucuacuaucagaagacacg\n", + "uuuuucugguugguguauuacuuuauucagugauaauaugaaaauuacuaucuucacugaaggaucuacugaauaaucauuuuaacucaacuauauugcauucuugaaagcaauccuuucaau\n", + "auuucacucuguccuuggccccucaccauugucucagaguuuaagccuuaacggaugaaggaaaaag\n", + "auuauuugugaaaagaaauuaucuaacacuucucaucuaucuaacuggaguuucacuagcuggag\n", + "cucuccacgcguucgapaacccggaapccaggcpugagugcggapaagcccuugugccaucupaguagagccgccgagucaggag\n", + "ggugucuuuuuacaggauacagccaaaacuaaaauuuagacuauauaauggagaauaauuuuuaaguuucuuuuccuccaaucucauauaaauuggagac\n", + "aupaaaacugaggcucagagacccagcaucacagcaagagaguggcagagcugguccaggagagcucaag\n", + "aguuccuagagccagacucacugguauccacugagccaccaccuuccugugcuugcgugccaggccccuucccccugcagcc\n", + "uacaucguggcguuugcagccaagguguugacaggccaggugcacgagcugaaggaccugcpaguaugacacagccgaggcccagagccugaagcccagcaaagccga\n", + "acucggcuggcuuugcggccgcacugcuugacggcagcgguguccgccccacggccggcguugccpuaacggcgagcgcgupccaagaaag\n", + "gcggccgcacugcuugacggcagcgguguccgccccacggccggcguugccpuaacggcgagcgcgupccaagaaag\n", + "cupcgaggaaagcgcggcccuuuccgaguuugguguuuugcagcgaaaggaaaucucgcucuuccgaaaguccuccapcgagagaggaaapccuag\n", + "acugcuugacggcagcgguguccgccccacggccggcguugccpuaacggcgagcgcgupccaagaaag\n", + "agucccacccpagccggcapagcggagcugcggagccgccuggucucccgcguccaucgguccauuccugcgucguucuguccuuccgaacgcacacuucaggagcagccgcgag\n", + "gagugagcacugcacgcaggauccgcccagugcuupccaagcacccuguggcauccaagcuccccuggacguuacccuuggugaaccaa\n", + "cggcaggcpugcgcggapcuggugccccgcagcaggupcpugcgguuggcggcggcggcupccpcugccggcugcgcucpccgugcgcggcggccgugcpcacgcc\n", + "cucagaguugccugauuggaaaaaucuccapcgapaucagucucgaggcugccgguuccccuggcccucapauggagccaag\n", + "gacccgagucggcccccuuuugguacucccagaugcuugcaaacaaccuauucguccucggccuuggugccauagccgaaauaccgucuccuccugccup\n", + "aacaagaggaaaguaupaaggagccaagcaggagacguucaccuuugccuuaacuuuggucuucauuca\n", + "ggccccugccgccggucggcgauguccggcuggagcugucgccuccgccgccgcugcugccggugccgguugugagcpucuccagucggcuccucupcgucuc\n", + "cuccuaugaggccccugccgccggucggcgauguccggcuggagcugucgccuccgccgccgcugcugccggugccgguugugagcpucuccagucggcuccucupcgucuc\n", + "guuguccucagaguugccugauuggaaaaaucuccapcgapaucagucucgaggcugccgguuccccuggcccucap\n", + "guugccugauuggaaaaaucuccapcgapaucagucucgaggcugccgguuccccuggcccucap\n", + "acugcpcugguccpcuccucagguucagacccgaccguuauccagucgguucguggagaggagag\n", + "acuugcucugagacaggugcggcaagucuacugcpcugguccpcuccucagguucagacccgaccguuauccagucgguucguggagaggagag\n", + "acapcaguguaguuccagaaaauaggacugaccaagaagcagaaaagcaagaugaaugaugugaagcuugcugucuupuggugaaggaacaggcaaaucug\n", + "gucccuacauccuuaaauaacugcaaauacuugguagugucuuugugacuauuacacauaguaccuugaagccagacugaguuugacagagaaaauaaacag\n", + "aaugcuucuccuaagcaccucguguguguucuucggccucacugcucuguggcuuagguaucugugcugupuuugagaaacauggugaagguguaugaacagagcuugacauuugug\n", + "cucugcugugugcgugcaccagcugccuccaggccaacuacacgugugagacagaupccugc\n", + "gugcgagccagagcccpccucagagcpuaggcggapccggcggacuggagcggcpccgcgcucpccccgccgugugcgcguccucccaucuuauccug\n", + "ccuguccccuucuccgcgcugccucacggugccugcacpacgccgcucgauccccgagcccccucgccguccccgacagcccccccggcgcc\n", + "aggugccgcuuccuguccccuucuccgcgcugccucacggugccugcacpacgccgcucgauccccgagcccccucgccguccccgacagcccccccggcgcc\n", + "aucugugucuuguaaagagcauauugcupcuuacauccguuuaucuuguuugacuguuauuuuaauag\n", + "agauggagucucacuauguuaccaaggcuguucucgaacuccuggccucaagcaguccuccugccucagccucccaaagugcuacgauuauag\n", + "capcauauacuucucuugucuugguuggaugcacaaaucugugugcagugcuuuuugcccguugccuagacgaucacuugguuucucugagg\n", + "ugccccugauguaagcuccaguaagaaaagacgucaaguacaaguacuaggaaaucacuuuauacaucuguuuauag\n", + "agcccccaauuuugugagugucccugaagcauugugacaauuccauuuuaugugucugcgugcucauaucaagacuaag\n", + "aaugaauuucaggauuuaucacuaaauaagacaaagucauuuauuuagucccccugacacagcapcaaacugaguugacauacaaguuaccuggagaaaaagagag\n", + "gguaaauaacacagagcaaaguuagcaaguugcagcgccucugcguucugauucuauggaaccuuuuuguapagaapcaggauguuuuuaacugaaugugaccucapaauacuagag\n", + "aaaauaauaaaauuucugaaupcagcguggagaaauccuaagagaaauagcauaagagcauuuuggaacacauccaggaaaagauaacuuucgacacaccuguagacguucgccagguaaag\n", + "gccccugauguaagcuccaguaagaaaagacgucaaguacaaguacuaggaaaucacuuuauacaucuguuuauag\n", + "aagaggacugucagaaggacguagaaggcacgguuuuacugugaggagcaaagauucuuuaccuacgcauuuuacaagaaaugugcagaaagccauugauaaauauaccug\n", + "cggaagccauacacccacpagcccacaccucuuggucupucggccacacagagcucuaccaccggcucauccacggagapcuccguuuauuccuggagagaugac\n", + "gcugcuguuucaagcucguucgcccaaauacaucuuucuacccaccuucccuaucgucagagagguggccugaccccagcacgugcaagcuugucaggcugg\n", + "aaaacugaaacgagcacaugguaacgcaagcggcaggcaugcucpugugcaggagaugcaccggcuugugugagccg\n", + "gauuguugcgcggucgcauuuuuccpagcgcggauucgcauucccaauuuuagguggcagucgcaacccauacuauucggacag\n", + "ucgcauuuuuccpagcgcggauucgcauucccaauuuuagguggcagucgcaacccauacuauucggacag\n", + "aaauagcuuugugaaaagapuggagagcuacucaaaauucuacguuagagagacugaaaagacaucuaauuucauugcucggcag\n", + "ugaacacuggacacguuggupaguuguucugugcugagagcauagcaaugaauacagagacagcagaccugccuucacag\n", + "acugcucuccagaauguugagauugcccgagaagugaccccagcaaaagaaaaauauugcuguaccuaaauucaa\n", + "cccuuccagccggagcucgcgagccgcgguggcggcugguggccaccccapaaauaaagccguugcugcugcagcaaaauggcucaaaguccaaccaaagucuggccuuuuccu\n", + "acucggaugacgugccgcguagaaguaucgcpaagaggaapagcguaacucuuagaagucacuauggugacpagguaccagguauuugagagcaaucgccaccgcuuuccuggaacuugag\n", + "aaaaaucugguccuucaucagaacuaggaaagcacugauuuaaacauuuggucagacauuuuaaauug\n", + "guaaauuucaucugauuuccaaguuaggaagaguggaaaaaaguguagaagcucacuguggagcaguacuugcaggaagauggaauuaugaaggaacagcauuaguuacag\n", + "agaagucacuauggugacpagguaccagguauuugagagcaaucgccaccgcuuuccuggaacuugag\n", + "aacucuuagaagucacuauggugacpagguaccagguauuugagagcaaucgccaccgcuuuccuggaacuugag\n", + "gcuggagugcaguggugugaucucgguuuacugcaaccuccaccuccugaguuccagcgauucuccugccucagccuccugaguagcupauuacag\n", + "uaaauacaaucaaguggcaucuuaaauuuuugcuggaaguggagucaugagacuaaagauaucucuuuuaaaagaaccaaagc\n", + "ugguuuccaaaaaguuupuguaaagaaacaaacccaggcagaaagcuuuguccucacaaguucugaug\n", + "guaacucuuagaagucacuauggugacpagguaccagguauuugagagcaaucgccaccgcuuuccuggaacuugag\n", + "uuaggaagaguggaaaaaaguguagaagcucacuguggagcaguacuugcaggaagauggaauuaugaaggaacagcauuaguuacag\n", + "aucgcpaagaggaapagcguaacucuuagaagucacuauggugacpagguaccagguauuugagagcaaucgccaccgcuuuccuggaacuugag\n", + "gucuacaucuccgaaaucgccuacccagcaguccpuugcucggcuccugugugcagcuaauggucgucgucggcauccuccuggccuaccuggcag\n", + "agcuuucaccuggcccugcugcggcagcccggcaucuacaagcccuucaucaucggcgucucccug\n", + "gucgcpacgaggagaucggagccpagacucgcgcagcgccauggcccccauuggccucaaagcuguugucggagaga\n", + "agucggucccuagcgcggcugcpcggagagcugcggcuggcccagcgcgcccaccugaggaggcggcpuccgcaggcgucgcpacgaggagaucggagccpagacucgcgcagcgcc\n", + "aguguuggugaaugcacgaaugcagguacccagcgacapaggugcugupuggauucacccuggcuucgcugcggcupagupcgcugcua\n", + "gaaagaggaagacuaccuagacauguugcuccagagcagaauuuccagcaguagauugaaccuucggaggccgagucccagcccaguguaaacug\n", + "gcccauggagagacugccugcaggcccuggaggauggccacgacaccagcuccaucuaccuggugaagccggagaacaccaaccgccuc\n", + "acacgcaccauggugacuuuccggccugcaucgccucugcuccccuaucccggcugacguuggacgacaaag\n", + "aucucaggaaacaggcucgacagcuggaaaaugaacuugaccugaaacuaguuuccuucagcaaacuauguacaaguuacagucauagcaguacccgagauggaagacgcgacag\n", + "guagaacagcggcuggagccggccaagcpcagcccacaacauccacaagcggcugcaggccugucugcapccagagcpcagac\n", + "gugucccuccgcggcggcugcgaggcggugcggcggcugaggcggccgaggcggccaguupuaccpapcgaaggcpcggcagaggcgaucag\n", + "guccgcpagagcugupcuuggugaguguuucguggccucucpuuggucagcacccccagccagcuggcccaggaccccucuacagaaguccaggagagcaggcgucaccaag\n", + "gugcgccuucgccgcccpccccuuaaagcccgcpaccgagucupagaccccugcacgccgcuucugcgcggagccccpcccuuuaaggaaa\n", + "gagucacugagapapaaauuggaaaaugcagucacagagcagaaaaucagugcuccaagccgcagcucauccup\n", + "gucaccaugccagcucugccpcugcagaugcugguuucagaagcgccuggcagcugcggagcucupaugcggacuuggcupcuaagauggaucgg\n", + "auaccacauugaaugaacaaagacugaacuuuguuuacagauaccuuuuauaaaagaugucuguggaguaguguuacaguucaaauaacaaaggauuuugcauuaugag\n", + "gupuaccucguguggaucguggcuggcguugcuucagauucuucuuuccucupucugcaaccagcuagaagccuggauaguccugcu\n", + "uuggaggucccccuccccacuaagugccucuuugcauagcaccaguccccacccgcacgcucucuggaccacuacagcuggacpca\n", + "gaaguggaggccggagccupacaccgccggcpagagaagcggaucccguccgagccccggccccaaguaacgccgccgccccggagccgcc\n", + "accgccggcpagagaagcggaucccguccgagccccggccccaaguaacgccgccgccccggagccgcc\n", + "agucucgcucucucgccaggccggagugcaguggcacuaucucagcucagugcaaccucugccucccpuucaagcgauucuccugccucagccucccgaguagcupacuacag\n", + "ggaaguggaggccggagccupacaccgccggcpagagaagcggaucccguccgagccccggccccaaguaacgccgccgccccggagccgcc\n", + "gaaacucuggcaaguugcpcgcgcpagcugucgcpcagcgcgcccucpaggacguggccccggcccccgcccgcagupcccgacccuc\n", + "gauuucugcucucugcgcugagcacagcggcaccaggcugagcuaagcapccgccuupcaggccuacgugguggugcaggcgagacccaggcupcaaggcgcag\n", + "uuucaguuuccaucuupucucugagcugagcagaguggcaccaggcugaguuaagupacugcccupcagaccuaccuacuagagcag\n", + "cuggaggccucupcgcgugcgcpcggucgcuaccugcggccgagccapagcgagapcgcagapcagcpcuupcagc\n", + "agaaguagcugauuuucagcuuucuguggauucuuuauuggaaaaagacaaugaccauucaagaccagauauucaaguucaagccaagagacuagcagagaag\n", + "cuaagaugugauacaguggugagugaaaucaguacuggucaaaggacuguaaauuucaaaauaaacagagagcucuuaacaaag\n", + "acagugcuacaacaaguaauugaagauggcucaaaauauggauuaaaaagugaacuuuucucuggacuuccccagaagaagauugugguugaauucag\n", + "gucuucupaacuggcuuccagcuguuuggcuaugaggaaaaacugcaguccaauccucuacagcaucucuuugaa\n", + "cgucupaguauauuuugaugaauauucaggagaaucauuuuaucgugaaaaaucucaagaggucuuaaaguugcuggagaguaaaggacuccuacugaaaacaau\n", + "cuuuccagaguguugaaucuuccaccagaaaacuugaucacaucaauaucugcaguuccaauuucccaaaaaga\n", + "uccuuuaauuuucagacagugcuacaacaaguaauugaagauggcucaaaauauggauuaaaaagugaacuuuucucuggacuuccccagaagaagauugugguugaauucag\n", + "gaaauuuuauagcaaaucucaaagaagcuuuaggacaucaaguaauaagaauaaauuaccuuggcgauupc\n", + "gaaauuuuauagcaaaucucaaagaagcuuuaggacaucaaguaauaagaauaaauuaccuuggcgauupcaugcaguuug\n", + "gucuagagacaagaucgcuauguagacacaccgugaaccauuucccacugupccugcaccaccccapcuuccuagcuucugcucuucuggaagucuuccccaucuccuccccauuccag\n", + "aaaaggaacggcuguaguagaucucucupaauggcgaccccuccucaauuuguacuguaaugcgaagugaupacuucucucuaugcaaccag\n", + "aguuucgcucuugucacccaggcuggagugcaguggcacaaucuugacucgcugcagucuccaccuccaggauucaagcgauuccccugccucagucucccaagcagcupauu\n", + "acgcaguuuuguucuuguugcccaggcuggagugcaauggcacaaucucggcucaccgcaaccuccaccucccagguucaagcgauucuccugccucagccucccagguagcupauuacag\n", + "ggacugcggcgcacuuccguagagguggacauggcgugcggcuuucgccgcgcuauugcuugccag\n", + "aguuaccuuuucgaauuucuagaaaaggaacggcuguaguagaucucucupaauggcgaccccuccucaauuuguacugua\n", + "aguuucgcucuugucacccaggcuggagugcaguggcacaaucuugacucgcugcagucuccaccuccaggauucaagcgauuccccugccucagucucccaagcagcupauuguag\n", + "pcgaggccggaacuggcggacugcggcgcacuuccguagagguggacauggcgugcggcuuucgccgcgcuauugcuugccag\n", + "ugcuacaacaaguaauugaagauggcucaaaauauggauuaaaaagugaacuuuucucuggacuuccccagaagaagauugugguugaauucag\n", + "pcgaggccggaacuggcggacugcggcgcacuuccguagagguggacauggcgugcggcuuucgccgcgcuauugcuugccag\n", + "aggcpucguauaaggaggupcgaggccggaacuggcggacugcggcgcacuuccguagagguggac\n", + "auaaccuuuauucugcuucagcuggcucuuuaccagcagugaagaucccaaagaaaagapcggaaacccpuacaag\n", + "guccagcccugcupaguuuucugccacacagauuugcggaagaaccugaccguggacgapcacc\n", + "gugccuaaggccgcgcugccpcucgagcggaggcggcgcaggcgcugaggcuggcgcggagcpcgcpccgcpugcggaaagcgcuag\n", + "gaguucgcuccggagccgcgccgccgccggcccagcaucucpcgcccgccgcccccgccgccgccgucagcgcpauguagg\n", + "augcuupauuugcuuuacauucuaaguggauuuggagaagagacaauaaagaauaagcagucaauucuauaauauauuuagaaggagaaaagugccaaggaggaaugaaaaaguagaacaag\n", + "agacagcaucuugcugccacccaggcuggagugcaguggugcagucuuagcuuacugcagccucaaacuucupcucaaguaauccucccgccucagcuuccugaguagcugagauuacag\n", + "cauuauuaaaauagacugcaguggauuuaauuggacaauucaagacauccauuuuauuguccaaaauauuacauaaaaguguacaguuuuuagccuaaaugcaaacaaaguugcuugaaa\n", + "cuccaaacucgcgagccccagagcucgcucagccgccpagcacccagapacpaggcagccgcgcagccccgagcupcaguguccccagccgcc\n", + "auccguccuagcuccuggacgcuggaccgcuccucaacucccugcucapagacuagcuccucguauuauguucagucucuacguuucucuacagaaag\n", + "cccucccaagucccacggcagcupucuucaucucuccacugcacccagaaucacacgcugacccagauaaagcucaaugcagugaacacucuugg\n", + "acacacggaggaggagacacacagagaaaaggaggcagugaugugaccacagaggcagagauugac\n", + "agagcucgcucagccgccpagcacccagapacpaggcagccgcgcagccccgagcupcaguguccccagccgcc\n", + "guauugccaucagagagucagcaaagguaguugaccaagcucaaaggagaguguugapaguugaugaccuugacuuuuucauaggagaugaagccaucgauaaaccuacauaugcuacaaag\n", + "ggcugugcguguaguagagaugcucucucuuugugaagaaggcccugcauacauuaaacaagucc\n", + "gguacuauuuuucugccuggaaauaaaguuucugagcaucccugcaaugaagagaacccapaaguuccuuuuugaaguaguuccag\n", + "aggacagagcagcugcucugucucccagcuugcaagugcagccugcauuugucacugaccacugaagugu\n", + "aacaaggcggcgguggacuggugaggacgccgagcuuccaggucgccaggaucggccaggaaugugugapaapaaggacaagagguuucacccccug\n", + "pcuggcaagguuuaauugcuuauggaugucauucacuugugguagugauugauuccauuacugcccaaacucuucaaguuuuagaaaagcauaaagcugauguuguaaag\n", + "agagcccagaucggaagagccgaguccpcagapuccgcpcucuggaggugcuggacpugcgauccgagagcagaccpcccucgcgagccucucccggccccugcccgcg\n", + "gcagapuccgcpcucuggaggugcuggacpugcgauccgagagcagaccpcccucgcgagccucucccggccccugcccgcg\n", + "gcucccugccucpcucucacccuccucuccugcagcuccagcuuugugcucugccucugaggagacc\n", + "apcccugaguaacgguggccupucagagccagguucagcugcgaggcugcugguggcuguggag\n", + "uggacgcacauccugcucupcagaapcaggacapcccugaguaacgguggccupucagagccagguucagcugcgaggcugcugguggcuguggag\n", + "agcuupcuuccuuggucgcacccaccaccugccugcccacuggucagccuucapacccugagcaccgccuggucucuuuccuguggccagcccag\n", + "aaagcugcggcggcgguucgcguuucucguguccgcuugacugacagcugcgcggcpagcpcggcgcgagcpaggcggcggcgcag\n", + "cgugcggccapucccguggccggagguguccgaccpagcggcuggagccggacgcgagcpcgcgcgaguucgagcccagagccgacacgcagcaacaagup\n", + "gcagagcuupcuuccuuggucgcacccaccaccugccugcccacuggucagccuucapacccugagcaccgccuggucucuuuccuguggccagcccag\n", + "agaggcgupuaggcugcapcacagcupccucuguccccaucuccggcugupaggugugugcgcauccggcgug\n", + "gagcapccguaaagcugcggcggcgguucgcguuucucguguccgcuugacugacagcugcgcggcpagcpcggcgcgagcpaggcggcggcgcag\n", + "gagccpcguugugagcggacugcuagaggcggcugucuguuuccgcucuaaggaaacucagagcguguggaccccaaacaagucugcgcaaaauuugucgaggagguuugccgcggcag\n", + "cugccggccccaaccuccggcgapacucccucccggccuacaggcaaccupuugcccuuccugcuuguuccucccaaccacucpcgcuaaaugcaa\n", + "cacuugacuguuuauuuucaaaucucacgaaccucaccccaagaucuucacauucuggaucucagcugcucuugaag\n", + "gagagaaaggccgagacggapagccagcggcggccgapcugguccaggcgcggccgcuaagaggagaccaagaggcpcugcacuugacaaccagcaugccgag\n", + "gcacaccuupcccaccccaccuccacauagccuuaauuacaaaucagaggacaggcuuagugagcaagacuggccagcauauuucaaggucccauguugupuugauacaucucaaauugag\n", + "ucagaagaggcagaaguggaugugagagaaagagagacacagagagacagagagccaaagapcaagagacuugacuuuaagagacuccuguacugacaacucc\n", + "agacggapagccagcggcggccgapcugguccaggcgcggccgcuaagaggagaccaagaggcpcugcacuugacaaccagcaugccgagaug\n", + "gccauccguugcacacugguaaacugcacaugugaauguuuucagccapaagauuaaccugaggacuugugaucaguguaaacauggcupuggcacaug\n", + "ccuuggauaagcucagcacgcagcaccuguaccaccccacccaaguggagauugugcaguccaacgucguguuugacaucagcagccug\n", + "cggcggccgapcugguccaggcgcggccgcuaagaggagaccaagaggcpcugcacuugacaaccagcaugccgag\n", + "agcuguuaaacugagcaaaggcaagcuupagucacaaucuaugcauaaaugauapauaucugugcagaag\n", + "auauuuggacucggcugcccgugcccaggaauuucccgucaugccucccgccgccccguccgucgcccggagccpapapagcgagguucggacaccggcggcggcugccuggccuuucc\n", + "aggaauuucccgucaugccucccgccgccccguccgucgcccggagccpapapagcgagguucggacaccggcggcggcugccuggccuuucc\n", + "caccggcggcggcugccuggccuuuccaugagcccgcggcggacccucccgcgcccccucucgcucugccucucccucugccucugccucugccuggccgcggcucupaagugcgcaguccg\n", + "cugcpacagccccugccucagccgagaapagcagaapuugcgccccgcgccagcggugapccgaacggaaggag\n", + "acguuapugugaccccgagccpauuccauucugcgccugcugcgcccccucggccaccugcpacagccccugccucagccgagaapagcagaapuugcgccccgcgccagcg\n", + "caaggacauuggagucccuaucaccgguugccuagacaacuucaupaaggcccuupaaucugag\n", + "aggaucgcaaagcacgccpaccgguugguuugguuuugaagacguggauggcpaauucucgcuucuggccugg\n", + "ggucucugccgcgccaggcuacccugcggucacaugcuccuccuguccuucuggcggagcgugcuucccgcugcpacguucgagca\n", + "agcgagcccuuggcguucaguucgcggugucagccuccgccuccgagccucaguugucuucucugugaggupaaugccggugaauccugccgcuggcgugg\n", + "gucucuggaacagapaugcauaggcacuuggcagauuuggugguggccagcaaugcgguacagaugaagugugcugcuugaggagugagcuggaaugaapcguguggaggugugagaauuag\n", + "cccgccgcaccacgcucccgagcucccccgcggccuggaguggugcgccccggccccgcccccugacgccggugapcguggccccgucacgugacpagugaccucgccgccpcgcc\n", + "ugaaagcaaguugaauacauuggugcagaagcuucaugacuuccuugcacacucaucagaagaaucugaagaaacaaguucuccuccacgacuugca\n", + "gagcccggcagcucaaugacaaaucgguggaggacggcupuccggccccpapcpcgcguuuaagagcugcpccpugcggacggcggaggcggcpacuggucccug\n", + "pacgcggacucpagugcgcacauucgcagcccpcagcccugcugcgcaccpccucgcgccccgcgccccgcgccccgcgccccgcgccccgcaccg\n", + "cuuugcugaauuggccupaaugcugccccuggaaggcauuggacagaacapacaguccuguugcgugapc\n", + "accgucapacgcggacucpagugcgcacauucgcagcccpcagcccugcugcgcaccpccucgcgccccgcgccccgcgccccgcgccccgcgccccgcaccg\n", + "cuuugcugaauuggccupaaugcugccccuggaaggcauuggacagaacapacaguccuguugcgugapcaugg\n", + "aaaaacaucugapagcgcupucggagccguccccaccccucccagccucacguagccgugaguuggcaagucuacccggaauccag\n", + "acacuucuuccpaaagagugaapccccacugcccuuugccauccagcuuccucuggcuuugcuaauggcccuapcaggagaccaacugcuggaaucccagagcccuggag\n", + "uguguugcacuggagcacagaggacacucgaucgugcggcgcgcapcppccgccgcugccuccccgcp\n", + "gcuuucuguauuugucugaaugcuuucacpaguguguugcacuggagcacagaggacacucgaucgugcggcgcgcapcppccgccgcugccuccccgcp\n", + "gacupaguuuucauccucuugaauaagaacucgacaacagagupaacuuucugucuugugauccauugccug\n", + "cuaaguaaaccagagccccgupcuggaacgcgccggaaucugaggugugaguagagccupagaguggauccaggugaapcagag\n", + "ggcuugagucagugugaaaaucpaupugagauaucucccuccagcagcagcacuuaggccacauuacccucugaggaauccacauuugucuuagaua\n", + "gacupaguuuucauccucuugaauaagaacucgacaacagagupaacuuucugucuugugauccauugccugguga\n", + "agagccccgupcuggaacgcgccggaaucugaggugugaguagagccupagaguggauccaggugaapcagag\n", + "aacgcgccggaaucugaggugugaguagagccupagaguggauccaggugaapcagag\n", + "aaaccagagccccgupcuggaacgcgccggaaucugaggugugaguagagccupagaguggauccaggugaapcagag\n", + "cgcauguggaauuaucgcucuacccaggcgguggugucgaucuacguuccaauupccguacc\n", + "uauuaaugcauucaaaguacuagacacuaugcagapcuauaggaggcauaaauaugaauuauagaagacuugcccuuaggagcuuuauaucuagaag\n", + "guccucugaucaacauaggcuggupaguacaggacucgccuccucapuucccugugcugccacuuuucagcc\n", + "ugugguccucugaucaacauaggcuggupaguacaggacucgccuccucapuucccugugcugccacuuuucagccauggccacaag\n", + "agcuguaaacuuaccucccugaagucuuguugcuggcaaacaauagagccagaccupcagagcuggagcuguuguccacaguguucucacuuccccgcgcugacuccaug\n", + "cugaucaacauaggcuggupaguacaggacucgccuccucapuucccugugcugccacuuuucagcc\n", + "gugguccucugaucaacauaggcuggupaguacaggacucgccuccucapuucccugugcugccacuuuucagcc\n", + "gaucaacauaggcuggupaguacaggacucgccuccucapuucccugugcugccacuuuucagcc\n", + "gcccuuucggugccggcguugcpucgcpagauccpucugugcucugauucccggcccugcccgucucucuuacaggcucucccaccugucacc\n", + "gugguuaucugagcuucagupcacauuccuaucucuupcuuuacuaacccuuguacuuggaaguucauccagagaacucacaacgauacupcugcucucacauacucacuuugcag\n", + "gucgucccgacccccpcucccpupaaggagcagcupcugcgcggagcaggcccccgugagccccpaaggagcgcagcgcagg\n", + "acagugcaucgcuauaauucauuaauacaucauaaaucgugaagcacapuuauaacgaccacgauccacaaaucaagcccuccaaaaucacccaa\n", + "ccgccgcugccaccgccucugauccaagccaccucccgccaggugagccccgagauccuggcucag\n", + "aucagagacacugcccagcccaagugucgccgccgcuuccacapcucuggcuggacgccgccgccgccgcugccaccgccucugauccaagccaccucccgccag\n", + "gccgacgccuccccccapucagcugcpcucccaggccuaggcgcccaugaccccuacgccaacagccgccuggacaccgccgccgccacugcgaccuagcgccgccgccgccpccca\n", + "cuccgcagaagccgagcgccaaacucaaacuuuaucaggacccggaccucucaggcuaaucccgapccpccuguupcuuuucugcacaccagccgaggcagcgagccaac\n", + "agaucupcagaggaaccaaapaaaagccaccuucccaggcacagccauaacauccaccucacucaacugcuugucaaguucaccaccaacacagap\n", + "ggcaauauggaggcgauguaaguucugagcguuagucccaaggucccapucucapagcggcgcgaguggccapaag\n", + "aagguggagaauccaucagucucauuugccucuucuuucccccuuauuccucuucuccuaagaggcaagaguguucagaagaaacaagcagagaguaaaagccagauaaag\n", + "gccccccaagaccaaguucuucuucacggucaucccucagcccaucuuccugagcccaggcauaacccucacgcuccccaucgucuuccggccucuggaggcg\n", + "agagcccaagaacacugguggccaaaggauggugucuugugaaaggapcaagcaaaaguguaggacaaauuuugcuuupauuuugguuacaccugcag\n", + "acuaucccacagaaggaggaacagcacugaaauccuuucucgcaaucuuccugcauuguacacag\n", + "aagccccpcccgcaggacagcggcpagagaupagaagucccgcaggaguugguucggaaguacuupuguuucagcaguccuuugcuggcuuucccaacuugaccpag\n", + "gccucggcaggcgccagcggagagcuagccgcaucuucpcagcccggcagcugccggcggcgcggcgagagagcggcugacagapaugcgag\n", + "gcggccgcgapcpcggccpccuggcugcgcccccggaccucgcpaccgcggcggcgcag\n", + "ccccucugaaaucaaagagaucuugcaucuggcuggacucaaugagcuggaggugauucccuuggugcagacauuuggacac\n", + "cccuccaauucuuucccguguguguppacccagguugccuacugcucuaguccaggaccagagacccccaacuauauagcag\n", + "agagcgugagcpaggcggagccpagagcggcucucguagcucacccuggccccaggccpcggcucgapaggaguuaccgccguucuucg\n", + "acaaguuacacccacugccuccgccagcagccpaaggcugcugcuuccucauuucuguuacuggaaguuupacaugugaagccagacpagaaacgugcgcgccuuguugagcagcg\n", + "acuccagcucuggcuucupcuccgaggapupacggupacggupacaucaggcugccccgcaguaccapagcgacugaagugcccaugccgcuugcuccggagaag\n", + "cccagguguggccucacucacaucccacucugaguccaaauguucucucccuggaagauaucaauguuucugucuguucgugaggacuccgugcccaccacggccucuuucag\n", + "guguggccucacucacaucccacucugaguccaaauguucucucccuggaagauaucaauguuucugucuguucgugaggacuccgugcccaccacggccucuuucag\n", + "gacucacgccuucgccguagcaucuuucgcagcggaccgaagagaagaaaaguaggccagagccg\n", + "aacugacaagcgcupacaguggcguccuugucuugccuuugucgcucccgccccgcucuucccuggcupcuggcggaggccuugcug\n", + "auuggcccccgcggcgucccgucgccgcgucgcguugcuggcccgucggagcgacgccgcucpucagucggcggccggacupaag\n", + "gcgccggcacaccuauuggcccccgcggcgucccgucgccgcgucgcguugcuggcccgucggagcgacgccgcucpucagucggcggccggacupaag\n", + "uaaccaguagauucuccaagcugcuuuuccgugacgagaaagagaaacagugaauuuguaucaucpucuuaguuucuupuccuaagagagagagaaagagaagga\n", + "cuacucugaccuacgacacucuccgguuugcugaguuugaagauuuuccugagaccucagagcccguuuggauacupuagaaaauacagcauuuucacag\n", + "aaaaggacgagaucuugucugauguggcaucuagacuuugguuuacauacaggaaaaacuuuccagccauug\n", + "gcgccggcacaccuauuggcccccgcggcgucccgucgccgcgucgcguugcuggcccgucggagcgacgccgcucpucagucggcggccggacupaagauggacgcag\n", + "gcuucaggccccaccpcgcggagagucccaggcccggccpaccpacggcguccgagugcca\n", + "ggcgguacccggagcuucaggccccaccpcgcggagagucccaggcccggccpaccpacggcguccgagugcca\n", + "ggagacguccccagcccaguccccggcugagcgcuggcggucggugcggcgucaggugcgcccgccag\n", + "auugguuuaucuuggaagcuaaapcauugcucauccugaagaucagcugaccauugacaaucagcc\n", + "aguccccggcugagcgcuggcggucggugcggcgucaggugcgcccgccaggugagcgcgcucccuggcaccguuggcccccggapucpcccaguugcggcgagcgg\n", + "gagcgcuggcggucggugcggcgucaggugcgcccgccaggugagcgcgcucccuggcaccguuggcccccggapucpcccaguugcggcgagcgg\n", + "auugguuuaucuuggaagcuaaapcauugcucauccugaagaucagcugaccauugacaaucagccaugucauccaggccucuugaaaguccaccuccuuacaggccugaugaauu\n", + "agaaaaccuacaacccaagguucaguguuaccccucaucaaccagcccagcagcaucuucpauuccca\n", + "gacacaggcuggacugaucupagccgcgaapccugccuucacaaapacguaacgcaaguacugcpcaguguuugaau\n", + "cupcuccgcgccpuccgagucccacgaagccccggcccgagccgccggaugcccgcgcgcagcpcccag\n", + "gguccuapugcuuccguggucggcggcugcupcuccgcgccpuccgagucccacgaagccccggcccgagccgccgg\n", + "gucacacucaucugapcuccagacacauggccugugcgucuguccugcccagcgucucccaccugacgcggccaggugcccaguugcucuucaaggccuuuucag\n", + "guaggaccaggugucacacucaucugapcuccagacacauggccugugcgucuguccugcccagcgucucccaccugacgcggccaggugcccaguugcucuucaaggccuuuucag\n", + "agcupuggagccuaaagccgagcccucuccugugaccucggcugaaaagaagaagccaguguuugagaaaagcuucgug\n", + "ggcugaaaagaagaagccaguguuugagaaaagcuucguggucuguguucucuaguuguucccucuucucucugacauuccuuucgucgucgccag\n", + "aauuuuuguggauuuggugguuguaugaagaauaagugaaucuaccagaacuuccuaguagcuaag\n", + "aucuugauucccagaggauccaguaacugagacaccugcacacuuuacaauaaauaaaagacaaaggaugacauaagaacccauggugcuuauaguuaca\n", + "gcucaucupcagaggaagcuucagaaagcugccaaggcaccaucuccaggaacucccagcacgcag\n", + "accuucugcacugcucaucupcagaggaagcuucagaaagcugccaaggcaccaucuccaggaacucccagcacgcag\n", + "caccuucugcacugcucaucupcagaggaagcuucagaaagcugccaaggcaccaucuccaggaacucccagcacgcag\n", + "aucugagupacauacuuuugaaggaugugcaauguucaaucauaagugugacaaaaacugacaagcaggaagcuuauguacucag\n", + "aggaggcaccuguapuggupcugguggcccaggagaagucaggaapagcccagcuggugacaagagagcccagaggugccupcugagugugagagcccggaagauuucagcc\n", + "cuuucgauucuuccauacucagaguacgcacggucugauuuucucuuuggauucuuccaaaaucaga\n", + "ggucucgcucugucacccaggcuggaguacagucaugugaucacggcucacugcagccuugaccucccaggcuccagugacccuuccaucucagccucccaaguagcupaccacag\n", + "agcauccuggccagaacaagccaaggagccaagacgagapacacacggacaaacaacagacagaagacguacuggccgcuggacuccgcugccucccccaucuccccgccaucugcgcccggagg\n", + "gucuuupcugccucugcccuucguagauucucugcupccuuuggaacuaacacagcaacuuccapucucauguugaagacuuuaugg\n", + "acucuugcccccuccaccuuuggagguccucuuupaucagaggcccaucucugccapccugaagaccuacauccuggag\n", + "gguaccucccuupagaucaauccccuguccuccugcucuuugcuccaugagaaggauccaccuacgaccuccaguccucaaaccaaccagcccaaggaacaucucaccgauuuuaaaucgg\n", + "gcugaugugugcagaacagacugaaggcaucapcagcaagaggagaccaggaggcagcugugacauugcacucaagagaaaugguggcaguuuggacucagugaaag\n", + "gcagccauuuuggugcgagagaaacaauaggacggaaacgccgaggaacccggcugaggcggcag\n", + "agcuuccuaggugacagacagguacacuguaugcuagcccuguaucugucugagcaguggaaugugccaggaaagaaggagcaaccacugacug\n", + "cuuccuaggugacagacagguacacuguaugcuagcccuguaucugucugagcaguggaaugugccaggaaagaaggagcaaccacugacug\n", + "gaggcggcagguaaagcucgcguccuauggcccuagugcccgaggagcuuugapagauuuuuucaggcuacupaaacpaucucugaucauuggagucucccag\n", + "cccuuccaagapaugccagagccuucuguaagcuccugagaugucacugguaucuaggcaacap\n", + "ggugcapcpcucggccuggccgcagccauuuuggugcgagagaaacaauaggacggaaacgccgaggaacccggcugaggcggcag\n", + "gagccaauagugapcaccpagcgaggugcapcpcucggccuggccgcagccauuuuggugcgagagaaacaauaggacggaaacgccgaggaacccggcugaggcggcag\n", + "agaauguugaagagucugaaaugauuauauuaaauaaagguuucaaggaguguacacauacaacguucauaugaagauuuauauuaaaugagcugucuaaa\n", + "cgccuccccucgucuucucccggcuggcggcgaccggccucagcugcagcpcccpcgupccugg\n", + "agccgagucugagcaucucggaggaugcggcgcggcgaucggcugcapacgcgcgcaaggugaacacpcugcggcgcgcag\n", + "cggaggaugcggcgcggcgaucggcugcapacgcgcgcaaggugaacacpcugcggcgcgcag\n", + "guguucgcugcugcacagcaaggcccugccacccaccuucaggccaugcagccauguuccpagcccuaauugcacagaagccc\n", + "guucgcugcugcacagcaaggcccugccacccaccuucaggccaugcagccauguuccpagcccuaauugcacagaagccc\n", + "acgcaggcuguggcagcgacgcggugaggagacggcccacggcgcccgcpcupcggucgcuucuuccuucuccguggccuacgagg\n", + "aggagacggcccacggcgcccgcpcupcggucgcuucuuccuucuccguggccuacgagg\n", + "uguggcagcgacgcggugaggagacggcccacggcgcccgcpcupcggucgcuucuuccuucuccguggccuacgagg\n", + "cccagcgccacggcaccuuagaacagaccuuuuucuuucucgcgupccugacuccuucagugaagccucuccacgcccucuaucugcagguccccagccupuaaag\n", + "guggcagcgacgcggugaggagacggcccacggcgcccgcpcupcggucgcuucuuccuucuccguggccuacgagg\n", + "agcgacgcggugaggagacggcccacggcgcccgcpcupcggucgcuucuuccuucuccguggccuacgagg\n", + "aggcuguggcagcgacgcggugaggagacggcccacggcgcccgcpcupcggucgcuucuuccuucuccguggccuacgagg\n", + "ccapaugaccccacucapaccggagcagcccucaacucacucuucagcuucccugcuguguugcagcccagccgcuccauc\n", + "ccggaagccucgagguuuagucccgccccccucuccucgcugcuuaggcuccgcggccuccaagcuguagcu\n", + "auugauguggacaucuucgagccccapaucagcaagcuggaugcccaggccucuuuccugccgaaggaacuggcagcccaaacuaucaagaaguccuucucaggaaaaaag\n", + "ggucaugugcuguuccgucccaccgugagccagcagcaguccugccccacaugcucuacauccuuacugaacpcacuucaaggugaccuacgaugucagucgagacaagaucugcgaccuccug\n", + "aaupaaaacacugaaauauguugguagagcgucuuacuuauucauaauugcccugcuuggacupcaaaaaacuuggagagcacagcaguuucg\n", + "acauuugccccuccuuccagacccuggcagccaccauucuacucuuugccucuaugaauuugacuauuguagauagcuc\n", + "cgccucucugucguggcgcggcuucccgcggucuucucugcaaaupcuccguggccuagcgcccccguccccgccacccgugaucgugcgccgaggcccgcgapucgccgcccag\n", + "ggaauacaaaaggaggaacccagacgcucauggagacagccucgguucauaaaucaggupccapcupcccacacgcc\n", + "ggcggcgaaggapaagaagagccgcgaccgagagaggccgccgagcguccccgcccucagagagcagccucccgagacag\n", + "ggapaagaagagccgcgaccgagagaggccgccgagcguccccgcccucagagagcagccucccgagacag\n", + "gcgcgcagugugaaacccggacguggcapcguguccgcgcccgaccgacccucagcugcupcgaaaacacaaguggaccucagucuuuagaacuag\n", + "cccacapccacaacagguuucugcaucugcuccuauggccacuccuucuugcccccagcucuccugcugccaag\n", + "gucacucgcucaggcugcucuagaggccccauagccapcccggcucugapccccacpccagcuucucapcuguguucuuccupccaaggcugcgugcucagcag\n", + "aggcugcgguaaauccpcuugcggccgcuggcguagucuguggccpuggucguugcugcgcgccccgagccccgagagcc\n", + "gaagauccccagcgcugcpcucggagagcaguccuaacggcgccucguacgcuaguguccucccuuuucaguccgcgucccucccupccpcuggcacucuugccuuccccgucccuc\n", + "gcgcugcpcucggagagcaguccuaacggcgccucguacgcuaguguccucccuuuucaguccgcgucccucccupccpcuggcacucuugccuuccccgucccuc\n", + "agcagaugcuggagcugcuggugcuggagcaguuucugagcgcgcugccagccgacacgcaggccupugugcagccgucagccgcuaagcupaggaggcgguggcccugcuggaagaguucugg\n", + "augcuupauggaagaaguuugagugaccuauccuguguuuauccuccuugccguagcugaguugaucuuuuugaaacccucuucccagacucuuggauuuauuuauuuuauuccaguguga\n", + "cugaggcgcagaucgcuggcucucgacgcauuacucuuuacgccuuacauuucugucuuccuuccupucagugauucccggacccuggaagagaagapuggcuaaugauuaag\n", + "gugcgugccgcucgcgcgcccgccagccaggcucuccgcgcccgccgcccgcgccgcgcuggcccpcucucccgcccgcgcuuc\n", + "gcgacuccagcuccgcggcgcccucgccpugcgugccgcucgcgcgcccgccagccaggcucuccgcgcccgccgcccgcgccgcgcuggcccpcucucccgcccgcgcuuc\n", + "cccccuuccucucugucuuguguggucucuugcccuuuugccuuccacuaupaugaugcaccagcagauuccagugcuguguucuuggacugcccagccucuagaaau\n", + "ccuucuguuauugugugucaaaaucacaagcucccugaagacuaaggaugugucuaagauaacgucuccacucauagcaggcaauauu\n", + "uaaaaacgcacccaaaacgccucaccuggaccccgcgcgcacccagaaggaucacguucagagacagaggugcaacaugagucaag\n", + "gaucauuuuagcuauguucaguugaggaacgcagcagaucuggaugacagaagaaaccgaauauuaaccag\n", + "ggauuaccgapugcpaugcugaugcugaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "augcugaugcugaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "agcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "uguacaguauuuucuccaagguacacuccgaucggaauguauacccaucagcagguguccucuuuguucauguuuuggaaagagaauauuuuaapaauuuccaccuuacccaaaaccug\n", + "cugaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "auuaccgapugcpaugcugaugcugaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "pugcpaugcugaugcugaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "acpauuaccgapugcpaugcugaugcugaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "acuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "gccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "gaacuggccaagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "aagcupapaagaagaaapapapagaaucgaggacggacggccuagccaggccaaga\n", + "ggcccapcccaggagaguauaaaggcgauguggapugcccggcacaaccagacgcccagucacaggcgag\n", + "acacuggcccuugcuuuggagucaggaggccucucuucuucccacagagcccupaugcaccggccagaggcc\n", + "gacgaacacgugacgcggucpcggaccacugcagacugagcgguggaccgaauupaccgcuggcuuauaagcgauc\n", + "uccgguuaugcaggaaggaaauugacgaacacgugacgcggucpcggaccacugcagacugagcgguggaccgaauupaccgcuggcuuauaagcgauc\n", + "gacuuccgguuaugcaggaaggaaauugacgaacacgugacgcggucpcggaccacugcagacugagcgguggaccgaauupaccgcuggcuuauaagcgauc\n", + "cggucpcggaccacugcagacugagcgguggaccgaauupaccgcuggcuuauaagcgauc\n", + "gcgugagccaccgcgcucggccuuuuuaaauuuuauauuucucuauuuauuuguacaacuuuuugaguugaccauugcaucuucuauuuuc\n", + "cuuuuugcuucucugcgcccagagcuccaguccuucucuucacugcucugcguccucugcuccuggaggccaagccucuguggccuuguguccugcaaguauucgcagauuu\n", + "cucugcucuggacuupaggcuccguugccugcucccggapagacgcgcugccgaggagaacccagcgg\n", + "ucucugcucuggacuupaggcuccguugccugcucccggapagacgcgcugccgaggagaacccagcgg\n", + "gaupupcgccpcgccpcgccaggcagugaupccuucccgcgcugcggccccacugaggaggaggcucpacagcaggagcacpcugcccgcgcggugcggacc\n", + "uggcugcagagagacuaccggccaccgccgccgccgccgccgcgagcugucccugcggcgcgucugccuuggcggagccgaccgcagugcgcucaggcguccg\n", + "aacuaguggcpaggcugugagcugagcggupucugcguacgccuggaguccuuccccgcugugcucagc\n", + "uaguggcpaggcugugagcugagcggupucugcguacgccuggaguccuuccccgcugugcucagc\n", + "aaacuaguggcpaggcugugagcugagcggupucugcguacgccuggaguccuuccccgcugugcucagc\n", + "aguggcpaggcugugagcugagcggupucugcguacgccuggaguccuuccccgcugugcucagc\n", + "uccucuguaagcaggaagugucccagucugacguggcugcugcguaaauguguccggaauugguuccuuccaguggauucuuggucucgcugacuucaagaaugaagccacggacugucgcg\n", + "ggcaguucagcccgcgccgcuccugcpucggacupcuguggcpagagaagaugccgcagcccgagucccagaaggcggcgauccupcugcpcaaggcg\n", + "auuuugaguugauuuucacauagaggupaggcuaguuucauuccucugcauaugaauauccaguuuucccaguaucaucuauugaagauacuguccuuucccca\n", + "gucuauagugagcgagagcugcuacuuuuuacuupcauucauucaaaguguugaagaauaacagccucuaccaucccuuauucacuggcucaucagcugucccagguuuugcucuucuag\n", + "cugcpucggacupcuguggcpagagaagaugccgcagcccgagucccagaaggcggcgauccupcugcpcaaggcg\n", + "uuucacugccguugguucucugagcauuaacccacaggccugagguuuucauuguugaacccuuuuuaaaaacucaguacuauccauacaucuucuuguauuugaauauccguuaacu\n", + "cccugaagccgugugcucapapugugcucapaggagccgguguuggcucugcuuuucuuugcccgaguugucugucaccaupagaauaaaguggcccc\n", + "agaagugcgagcggcagcggcgcggccgcgauuguuccugcgcuucpcugcccgccgcguccccgcgcgccgccgacccgcgcccgcuggcuuccgcgccucugccpagcggcccgcgg\n", + "gacagapcuucaggcacgcggcugcugcugccacugcugcucugagacaagguggaugagucugcugccggaucaagaaaaag\n", + "aacuguauuucagaaaaaagaaacuacaguuuuagcaugcagaaaggaaaapagaacaagccggaucagaagacgaaaacucugcggaaguucugaaucaagaggag\n", + "agaupucuuucuguguupcaggcupcucaaacuccuggccucaagcaguccucccgccuuggccucccaaaugcupaauacaga\n", + "gcggccgccggcgccuaggugagcuaguaggacuuccpucpccuccaguugcccpuaacpagcagagucggcp\n", + "auugagcauuuccacagaaauuacaguuuuguccuuuuugaaaaaauagaacuguauuucagaaaaaagaaacuacaguuuuagc\n", + "gacagagugagacucugaugccaacaagcaggucuugcagaaauaggacauggagcugagaaguccagacuguuguucuugcugccag\n", + "ugcuggccagaggccguuapcccccacuaccaacuccauguuacucucucucaccaguggccaccacc\n", + "gacggcgacacuuugcuacggagugcaucggacgucgaagccuagagucucugcgucuuucccucuuccgcugccucauuccuuuccuuccuagccuuggucgucgccgccacc\n", + "aaagugcpucggccpugcupccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "pccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "pugcupccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "cggccpugcupccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "ggccpugcupccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "pucggccpugcupccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "gcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "ccpugcupccgaggccgaggccpcpauccagagcpagccggcgcpaucupacucggagcpauccggagcpacccaggagccggcgcpcc\n", + "uuaaaaaggcuccugcaggcaacaugccugcacacuaacgugcagaaapacuguacuacucaaaaccaccaaggaaguggcagag\n", + "cucuuuccuucccaagcaccgaggaggccccagcucccuapcugagaagcuggaguccupcaapaggagcugagcccuacucuugcaagacccccggccuccucaccccacgcpaagc\n", + "guccupcaapaggagcugagcccuacucuugcaagacccccggccuccucaccccacgcpaagc\n", + "gcucccuapcugagaagcuggaguccupcaapaggagcugagcccuacucuugcaagacccccggccuccucaccccacgcpaagc\n", + "gcucaggcuggagaapccgcpacccpaacgcggccuggaggacgaggaggacupuucccggaggcaacaggaccggcucggcaucuacagcuacu\n", + "gaaaaagugcgaguucucugupcagcggcuggcggcccccgccuuccagagcgucagguggaggcgcgapcccgcaggcccucgcp\n", + "aucccapaccugccugcucccagaggugacagaggaagaucaaggaaggaucuguguggucauugaccucgaugaaacccuugugcauagcuccuuuaag\n", + "cggagucucpagccggagcpcccccgcccaggccccccagcccagcccagcccgcgcgcccgcccguccucccgcccagccagcccpcccgcpauuguuag\n", + "gccuuucccggaaggcapaggcagcgccggccuccggaggcggccupcgauggcggcggaguuuuguccauaacgupcaaccgcgcagcuggagg\n", + "gcuacuuaagguccugcugcgugagccauugacguguuuggagcuggagacggccupugcuggcgaagcggaggccggag\n", + "uuaauacacgaggaacucaugcaaaggapacuuucggaaauccaaacuuagagugccuuguauuuagaauccggaaggaaaaggaa\n", + "uuaauacacgaggaacucaugcaaaggapacuuucggaaauccaaacuuagagugccuuguauuuagaauccggaaggaaaaggaaaugaaaugugaagaaacuc\n", + "gaaaaacacguucaaguuuuuauucacaaaguacagagaauacaugaaguuccucacuaagugaucauuaugccaaaaucaaaauuucag\n", + "ccuuuuguuugucucacguuuugcgupaggcggucccpauuucapucuaccggcucucuuauggcgaaugcaacccgaagagagagugag\n", + "ggaggapuggugacacgguggagacaccggcuaggccapccugcccuupacagguccagaccc\n", + "uccuucuapaapcupaggapuggugacacgguggagacaccggcuaggccapccugcccuupacagguccagaccc\n", + "cuucuapaapcupaggapuggugacacgguggagacaccggcuaggccapccugcccuupacagguccagaccc\n", + "uaguucccggugacugucgcagccucuguugcccucugacuugcagaugcugugagauccagagcuaagacuccacgacaucccggaagccgaaaa\n", + "gugacpacupccucccagcugucagcuccggagucugcggacuggaguccccggcaggcacagcucggccgucgaucaccuccpcacaggaugcgag\n", + "gaacuguugacauucapaugugaccauagaauucucucuggaggagupaguuucugaacccugcucagcagaguuuguauaggaaagug\n", + "gcuuaguauccucugcucuaguaguucccggugacugucgcagccucuguugcccucugacuugcagaugcugugagauccagagcuaagacuccacgacaucccggaagccgaaaa\n", + "aaucagucucaguguuuccuguuuggauugccaugaggacaucaacccagagugacuguagacccucuucccagcaccugagagucuuugagacauuugagguuguugugugcagacup\n", + "agcugucagcuccggagucugcggacuggaguccccggcaggcacagcucggccgucgaucaccuccpcacaggaugcgag\n", + "aguaguucccggugacugucgcagccucuguugcccucugacuugcagaugcugugagauccagagcuaagacuccacgacaucccggaagccgaaaaaug\n", + "auugcuuaguauccucugcucuaguaguucccggugacugucgcagccucuguugcccucugacuugcagaugcugugagauccagagcuaagacuccacgacaucccggaagccgaaaa\n", + "ggapcagcaguggucucucucucucucuaaauaacuuuuucccuuguccccacagaaugccuuaaaugaca\n", + "gguuucucauaaucacugapaguggcagauuucuagguauaagaguuacacuugaggcaucuuguuucugagcagugacuaaaauacauuccacauguggcagaggagcaagcucugag\n", + "auuccggccupagccggagcggccaggccgccgucugcccgucccgcuggacgucccgcgguccgcccucccgugcguccgucugccggugagcccgcccgcccgccggcccag\n", + "aacagagaacagaagcucagagaagugaagcaacuugcccagcuaugagagacagagccaggauuugaaaccag\n", + "ccccugcguccuucagguggacuuaggaguggacagagccugugugugccccupcaagaccuccugaacuucauggacucuguacaauuupcagugguugcupucaccup\n", + "aguauuccucugacgcccaggcuggagugcaguggcaggaucugagcucacugcagccucugccuccccuguucaagcgauucuccugccucacccuccggaguagcupacuacag\n", + "agcuccaguucuucucuucacugcucugcguccucuguuccuagaggccaagccacuguggccuuguguucugcagguauccgcagauuu\n", + "ggcuccpuggcggucggacagugucuagcacgcucaguccpcuupccccgcggcggagaaggagguagapcggcggcggcggcggcggugguggcggcacc\n", + "agugucuagcacgcucaguccpcuupccccgcggcggagaaggagguagapcggcggcggcggcggcggugguggcggcacc\n", + "ggauucgcuggcgcgacpcpccupugcpugccgcguggcggccgcagcgcugap\n", + "gauucgcuggcgcgacpcpccupugcpugccgcguggcggccgcagcgcugap\n", + "ggccacggucuccaugcucugcuccucuggccgcagcagaacccugugaaccccaggcaaugacagcaggauccugaagcccaugcaggcucugaaccacgcggccauccagaap\n", + "agcacugcccuccaagaucuucccuupcuuuucagcaguaapacaugcaccccaapccuccacuuggccugaccuugcugcpcucucuguccccaggaacaguagag\n", + "auaaauggagcgacguaauuucgaccuguccuuucccpaguuagcgaucccucaaccccugcacugcgcuaguccuaaagaggaa\n", + "guaauuucgaccuguccuuucccpaguuagcgaucccucaaccccugcacugcgcuaguccuaaagaggaa\n", + "aaucguggagcagcuuggcugcuugucauaaauggagcgacguaauuucgaccuguccuuucccpaguuagcgaucccucaaccccugcacugcgcuaguccuaaagaggaa\n", + "gcauuaaccuaaagugcugcagagauaaacuuaaagcaggaagcaacauaccaugaauguacugcaapaacacauuugugucaugugaagagac\n", + "aaagagcgcgcucggaccuccuucccggcggcagcuaccgagagugcggagcgaccagcgugcgcucggaggaaccagagaaacucagcaccccgcpacuguccgucgca\n", + "agagcgcgcucggaccuccuucccggcggcagcuaccgagagugcggagcgaccagcgugcgcucggaggaaccagagaaacucagcaccccgcpacuguccgucgca\n", + "gcuagcuccgugugccucgcaggcguggupcgcguccuggcagccgcccgcuugguucucgcpauccpcuccggcucgacgccggcucucuuuuugacgccccgccgccpuugcc\n", + "gcgcucuuaacggcguuuauguccuuugcugucugapccucagcucugaccaaucuggucuucguguggucauuagc\n", + "ggacacagcguccggagccagaggcgcucuuaacggcguuuauguccuuugcugucugapccucagcucugaccaaucuggucuucguguggucauuagc\n", + "aggugcgagguggccgcgcpaucuupugacapcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccag\n", + "gaucuupugacapcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccag\n", + "ggccgcgcpaucuupugacapcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccaggugcgcgucccag\n", + "gaagaagaaauugucgagacgaauaacaugaggucauauagaaucccacuuuuggugauuucaagucaagaaaguaaaa\n", + "gcgagguggccgcgcpaucuupugacapcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccag\n", + "paucuupugacapcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccaggugcgcgucccag\n", + "apcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccag\n", + "ggccgcgcpaucuupugacapcaccgapaaggaggacgcgapcagccaggcccuapagcapagaguggcucpcucagucgcguggccccag\n", + "ucuuaguucagucggcucuuagaguaguaaccgccagaaaggagucggaagaggucucacgaggcugucaucaccgcc\n", + "gcgcacccaccugcugcaucuuaguucagucggcucuuagaguaguaaccgccagaaaggagucggaagaggucucacgaggcugucaucaccgcc\n", + "aaguuuguaaaagucupcuaccggcgcggcguaguggaugcagcauccuaguggaggacgccccugug\n", + "ggauaacaacuuccgcucpaaguuuguaaaagucupcuaccggcgcggcguaguggaugcagcauccuaguggaggacgccccugug\n", + "gauaacaacuuccgcucpaaguuuguaaaagucupcuaccggcgcggcguaguggaugcagcauccuaguggaggacgccccugug\n", + "uugcugaaccuguuugcaugaguugcuccugacggcccuuuaggauacuuccaugucuguapucuagagugacaucuccuccccuccccugacgag\n", + "gccggacugcapugcgaucuuggcucacagcaacuuccaccucccpuucaagcgauucuccugccucagcuucccaaguagcupaugacag\n", + "auggagucucacucuguugcccaggcuggaguacaguggcgugaucucggcucacugcaagcucugccucccgg\n", + "gcuggagugcaauggcgcgauaucggcucgccgcaacuucugccuccupuucaagugaaucuccugccccagccuccugagcagcupaugacag\n", + "uuccgcucpaaguuuguaaaagucupcuaccggcgcggcguaguggaugcagcauccuaguggaggacgccccugug\n", + "gagccagugaccuucapacguggccaucuacuucucaapaggagupcgugucuggaacccagccagapcccucuaccpacgug\n", + "aacaacuuccgcucpaaguuuguaaaagucupcuaccggcgcggcguaguggaugcagcauccuaguggaggacgccccugug\n", + "aauaaapucugagccggucgccugagccugaaaagugcugucacgucagcggaaggaggcgucccagaucuucucagcugucuug\n", + "pcggugapcpcccguacgccgauuccauaupcgccggcgcggagcgccgcpcagcgcpucgcc\n", + "gcgagcgcagcggagccuggagagaaggcgcupcugcgapcgcgapcgcgapcapcaaccggaccccgcccgcaccc\n", + "agucgapcuagcgagcgcagcggagccuggagagaaggcgcupcugcgapcgcgapcgcgapcapcaaccggaccccgcccgcaccc\n", + "gapagcaggaaggcaguguguccccpugcuggcagaccgauuugaacucuggcuaugucuucuugcaguggccgccgccgacagcggcaucagcccucpccguguggcaguuccgcaaa\n", + "gagcaagugacguuugaggacgugguagupcuucagccaggaggagupcagcugaagccugcccagaggacccuguaccgugaugua\n", + "uauuaaacuuuaaupuagcugguagacaauuaacacucupapcucaaaccacauaaccaaaugugccaagauaauccugagcucacucauugucag\n", + "uccugaagauuuuccucagagaaucuuucaucucuuugcuccugagacuauauauuagaggauuacagagugguguuaucacagaauagaacaag\n", + "uggauuuuuaucugagaucuacaacuuaagaagaauauaagugauguauauucucuucuacucuucauguauggaauagapcuugcacaguag\n", + "aggaaagguacuagcucuucuuuaugcaucugguagaacucagcugugaauuccugugauccupcuuuuucug\n", + "ggauaaaguccuccacugupugguggaagaggcuucuucuaccuccuccccauaguuccugaaggcaccaagacugucacaguaauug\n", + "aacucuagauaaaugcuauguggacuaauuauaguuucuuuaauuuucauaguuauauuaugaaaagaguaaauugaagaa\n", + "acccaaagucuucaagccuggaguuccugcuugguucuuccugaggucugagcaccuucuagacuacauccagaucug\n", + "pcucugagauapagacaacagaaaaagacaaacagcgauggagaugaaaacuguugauuugugapccuccacagagaaaaacapaag\n", + "guaacaagaaaugcaugcaucuacagcaagaaagauggaugcuacagagagagapacuuccuggugaugagaggagguggaaauu\n", + "gaguacaacucugccucuccaaggagaacpuugugaccacugaacaaaacuugcccauugaaagcaaacccggaacagcuggaua\n", + "cggcgcugccucuggauugccugcgugupaguacaacucugccucuccaaggagaacpuugugaccacugaacaaaacuugcccauugaaagcaaacccggaacagcuggaua\n", + "cccuuuccgcgaccgccccgcccacucccaggaaggcccpugcccagagcucgcgguggacuccgacccggcgcaac\n", + "gccugcupccugguggccuuguccggaauauuuauuuugugaacucuucacuccagugccugcacuuucgaccucuguagucgacccagcugcccagucucuaccucaccugaucca\n", + "caguuacucuagcgcgccaggccgaaccgcagcuucuuggcuuagguacuucuacucacagcggccgauuccgaggccaacuccagca\n", + "aguuacucuagcgcgccaggccgaaccgcagcuucuuggcuuagguacuucuacucacagcggccgauuccgaggccaacuccagca\n", + "ccaguuacucuagcgcgccaggccgaaccgcagcuucuuggcuuagguacuucuacucacagcggccgauuccgaggccaacuccagca\n", + "acucuagcgcgccaggccgaaccgcagcuucuuggcuuagguacuucuacucacagcggccgauuccgaggccaacuccagca\n", + "cuucuacaaaacucagapacucuucaggagccacaugcucucaucaagcagaaacuuuuuaagagguagacaacaacccagaguggacacagagcuggugcucuuccaguagag\n", + "ggagaugacupagcpagcuggagaauacugcccaguuacucuagcgcgccaggccgaaccgcagcuucuuggcuuagguacuucuacucacagcggccgauuccgaggccaacuccagca\n", + "cupagcpagcuggagaauacugcccaguuacucuagcgcgccaggccgaaccgcagcuucuuggcuuagguacuucuacucacagcggccgauuccgaggccaacuccagca\n", + "acpucucacucuguugcccaggcuggagugcagugaugugaucauggcuuacugcagccucaaccucccagucucaagacauccuccugcuucagccucccaaguaguupauuacag\n", + "cuuugacgugugacccuccucucugcacaggcucggucupuucuugcagcuggcaccagcccucccggccccggccgcccacccgccgcpaag\n", + "ggcggcgccagcggacaccggagcpcaggagcagcggccgcggcgccgcapaccagcpcccag\n", + "gcucggucupuucuugcagcuggcaccagcccucccggccccggccgcccacccgccgcpaag\n", + "gccgcgcucucccugcagccgccaccgcagccgccgccupccgcuccguguccccgguggagccgccgccgccgccgccpagcucgaugcggacggagcccpccgagcc\n", + "pagcggcggcggcpcapcccpccpccuggaggacaggcgaggcagcggcgagugcpccggcggucpapcggugcc\n", + "uucuuuccucccuugccaguccgccugucuuccuccccgucuucccugcccggccucccccuucuucccccgcuggcccccuccccggapauaauauggucuccggcg\n", + "gagccugcuuccuucuuuccucccuugccaguccgccugucuuccuccccgucuucccugcccggccucccccuucuucccccgcuggcccccuccccggapauaauauggucuccggcg\n", + "gauacgccuuugaguaccuuauugaaacauuaaaugacaguucacauaagaaguucuucgauguaucuaaacuuggcaccaaguaug\n", + "auguucugccuuacucaauacpucuuguuggaagcugcuguacgaaauugugauggcuuuuua\n", + "cauuuuccupcuccpcgcggagaagcugcaucccagaggagcgcguccaggagcggacccg\n", + "uuucauuuuccupcuccpcgcggagaagcugcaucccagaggagcgcguccaggagcggacccggugag\n", + "aguguccacucuggcupccagcuggaggccuucaguacagccccagccaacucucacugaacagcuggagcaccgacacccupcacucauuucaaauc\n", + "caucuguaaagugagguaggccccuucaagacauguaaggaguaucuauggcuguggaaugcaucuuuuuagacuggccgcucugcauggaucugaucacgg\n", + "gugaccaaaagccagccccacugugaguugaacucuuucguguugaccggccacucuccgugcucugg\n", + "agagcggcggcuucucucgcgaggacggacgccauuaucgcaucuccccgacaaacaccacgagaauuccgcagcccacacg\n", + "aguauucuupagaaagauaacapaagugaggapuucagcuguggaagugcupauggcugauccgagugaccauggccuagacpuuuaaacccuggacugaagaaagugccg\n", + "gagcggcggcuucucucgcgaggacggacgccauuaucgcaucuccccgacaaacaccacgagaauuccgcagcccacacg\n", + "gcagagcggcggcuucucucgcgaggacggacgccauuaucgcaucuccccgacaaacaccacgagaauuccgcagcccacacg\n", + "uucucucgcgaggacggacgccauuaucgcaucuccccgacaaacaccacgagaauuccgcagcccacacg\n", + "gaugcagaaaguagaugacauuccauccacacugugugagcaaauuggagagauugccuugauagaggacugauguuuuucacugaugagaug\n", + "gcgcagagcggcggcuucucucgcgaggacggacgccauuaucgcaucuccccgacaaacaccacgagaauuccgcagcccacacg\n", + "cggaaggagagccaggccggaaggaggcugccggapcpaggcaggagcpccaggagcugcupcuggagcggcggcgccgcc\n", + "aggccggaaggaggcugccggapcpaggcaggagcpccaggagcugcupcuggagcggcggcgccgcc\n", + "auuuaagcaacuggccuccuuagaggccacuccuuggccaugccaggcgcpcaucuggccagc\n", + "cuauuuaagcaacuggccuccuuagaggccacuccuuggccaugccaggcgcpcaucuggccagc\n", + "cuucuugauccugaacupuuaggugccgcuguugcugcucguguugaaucuagaaccguagccagac\n", + "gucacaauggcuggagcucugapcccaggcucccugagccaggaggagaggagaaaguccaaggaaag\n", + "gagccagcucucaaugaagccaacuugagcaaucugaaggccccauuggacaucccagugccugauccagucaaggagaaagagaaagaggagcggaagaaacagcaggag\n", + "guccucccuguggcccagugaacugcaaugaaaagaucgugguccuucugcagcgcuugaagccugagaucaaggaugucauugagcagcucaaccug\n", + "gucaccaccugguugcagcugcagauaccucggauugaggaugguaacaauuuuggaguggcuguccag\n", + "accgcuuucgcuuucccuucgcggugcccacuccacuccuugugcggcgcuaggccccccgucccgguc\n", + "ucuagcaggaaaggagapagcuuuccccgaagacccuccuggaccagccccaggcuccugugcug\n", + "cuagcagguugcacgccapccuguacugaccaccuccacgugccacupcuguaaggaggaauggcggccgupcagccugcuugg\n", + "ccccaugcagucuagcaggaaaggagapagcuuuccccgaagacccuccuggaccagccccaggcuccugugcug\n", + "gcugcaccugugauaagcccuuguccccaugcagucuagcaggaaaggagapagcuuuccccgaagacccuccuggaccagccccaggcuccugugcug\n", + "ugaccaacuucugcuuuuggaaaaaccucuacaggcgguucugagaaguccaapuugcupagag\n", + "gcagucuagcaggaaaggagapagcuuuccccgaagacccuccuggaccagccccaggcuccugugcug\n", + "guugcacgccapccuguacugaccaccuccacgugccacupcuguaaggaggaauggcggccgupcagccugcuugg\n", + "guugcacgccapccuguacugaccaccuccacgugccacupcuguaaggaggaauggcggccgupca\n", + "ugaccaacuucugcuuuuggaaaaaccucuacaggcgguucugagaaguccaapuugcupagagguug\n", + "guuggaaugcaguggcacgaucuuggcucucugcaaccuccgccuccupuucaagcaauucuccugccucagucucccaaguagcupacuacag\n", + "aaccucuggauggacucuuccupaagcuuugcuacuuugcagcagcuggaccauguuccucauuaacaucugucuguccgcuuagucaucacaucauuucacugug\n", + "guggcapacucagcucggaauucuguauagaaaaagcaccuggaucccagucuuucaauggcuucaagacaaccagaagugccugguaaacuuaauucuuuuug\n", + "ggcgcggaggaggaggcggcggcgucgguggcggcggcgacggcggcgcggaggcgaaggcagcg\n", + "cuaugucugauagcauuugacccuauugcuuuuagccucccggcuuuauaucuauauauacacagguauauguguauauuuuauauaauuguucuccguucguugauaucaaagacaguugaaggaa\n", + "gagapacuugaguucuguuaucuucuuaaguagauucauauuguaapucucpuppuuggcaaaauccuggagccagaagaaaggacagcagcauugaucaaucuuacagcuaac\n", + "uggaucgcagcuccaagaggaggcaggugaagccuuuggcagcuucucugcuggaagcucuugauu\n", + "ucccgacgcgcpccgcagcggccaagcccgapugcguggcgcccccgcccgcccggcccggcccggcc\n", + "uggauaagagcuaaaccaccugccacupacuuccauacucucggcucccuugucaucugauggcauuuugauugucucgaggccaagugacuugcugucc\n", + "auuaugugcgucgaggauaagccaaccuuuauagguaagagugcuagucauuuuauggacucauaggaucacugaauuugaaagcuagacaggaucgucaggcugaaggaaucuugguaaaugg\n", + "uggccgcacgccgcaauccuaccggcugcugcggcuccagcpcggcpuggcuuccapcaccggcggccgcggcccggacuccgcggupcgagcgcccugugag\n", + "gugcuugguuguauaaguguacucugguguguccuccaugacuaugagaaagacaugcccagacuagcucacugacaccacaaggaggaugagaucagcugccucaupcaugugaacuaa\n", + "auguucccuuaucaguuuucauguauggacugaguacugauuauaacuguguaaugcuggaugccauugaagagug\n", + "ggauugugaucuaauguuggaacuaagcaguugauaggugucaggapccaucaaccauguuacgaa\n", + "auccuaaaucccgacagcuuuauagagcccaggccuggcaggcucccagaacuugaagccaccagaccccac\n", + "ccuaaaucccgacagcuuuauagagcccaggccuggcaggcucccagaacuugaagccaccagaccccac\n", + "cuggaaguagcaguggucacaacugagagagccaaacauuucuacagcccccaggacauuccugucacccucuacagcgacgcugaugaaupag\n", + "gucagugugagaagaagauuguuucugagcuugagaagcuucuggaggauugaagaguauuugaagucugugucaaacauccauaucauaaguggaauuuuggagauauucaaag\n", + "agugccgcgcugccapagcaccgagcaccacggugucgugcgcuucgaggcgcggcgupaagaaggcug\n", + "gcagaguauauacugaggucuguggauccuaaggcucagaggauucucgccgcagcguuguucggcccgaaaaggccauuguggaca\n", + "uccccagugccuaacucugcugucugcuauauuucagccuuucauccgcuguaguuuacaaugcapaucugguugaugaagcaaagaaguuucaucugaggccugaacuucggagucag\n", + "aaacugaapucagaauuccaguuguggaugaaggaaaugguguuaugacugccucaagguuuuguagcaagucauapaaccaagaggaaucuuguuuuccucagag\n", + "aagacgcucagaggauucugacaauaucuuuaccggagaagaggcaaaguacgcucaaagccgaagccacagcuccuccugccgcauuucuuuccugcuugcgaauuccaagcuguuaaauaag\n", + "agaucacucauguguucagugauucagguucuguugaagauaccaaagauauucgguuggucaaaaugacpcauauaaaggcuucucagguuucugag\n", + "aggcgcugcgaggcgcugcuggcccucpcugcpagccpcuaggacgccgagcggugacuccccgccgcucccpccgugacg\n", + "gagaugccuacauagaagagugacagcagcuagacuaaauguuuaacugcugaacuaguuccucagguauccuggcucuagagauugcu\n", + "aacaggugccgcagccgcagcugcgcccgcagcgcgcgcggaccgcapauaaggucuucuuuuucuccpuuuuuuuggag\n", + "gcuggcccucpcugcpagccpcuaggacgccgagcggugacuccccgccgcucccpccgugacg\n", + "guuccgguugcggauggugagugugucppcuuggcggcuuuucuccucaguuuucuggagugcuuuggaggagag\n", + "gcuuccgcguuccgguugcggauggugagugugucppcuuggcggcuuuucuccucaguuuucuggagugcuuuggaggagag\n", + "acaaggucuugcuauguugcccaggcuggucuugaacuccuggccucaagcgauccucccaacuuggccucgcaaagugcupacuacag\n", + "acuuucaaaccucugguugaaagaaauauacccaguucagucacugcaguagaauuccuuguagauaagcaacuggauuuuuuaacugaagauagugccuuucagcccuaccag\n", + "gacgacauagacagccuaaacccaguucucapacaacccgcagcuucaugaggaagugaaagucupuaaaggaacaaaagguucaggagauuuuu\n", + "agagugcugaagguccugccaacggcucucuuggcgucucaacguucggaucagcagcuuuuuuccauucucucucuccacuucuucagugagcagcc\n", + "gaccuucgccucugcauuuguccaguaacucuggcugugccggauacugcuupuaaaacpcaccccaggaac\n", + "aacgacgupcggccagcgcagccuggucaacaaguggacgacguuccugaaggcgcggcuggugugcucggugcccggcgucgapcgacacccacuucgaucagcucc\n", + "aggauguguuucuguuguccucgcpaccaccggaccccgcugcucuaugccgucuucuccacguccag\n", + "auccupcagaguccapcagcucaaggcuccuccacacacacacccgcugaacccugagcacccugagcugcugag\n", + "gacuccucuuccagauccupcagaguccapcagcucaaggcuccuccacacacacacccgcugaacccugagcacccugagcugcugag\n", + "gcagaguccapcagcucaaggcuccuccacacacacacccgcugaacccugagcacccugagcugcugag\n", + "agcagcpcgcgcucauaaapcacagccgapuacguggaucgcggugcggagacugagguuagaaggcacagguggcgag\n", + "gcacaagcuuucuugucugccacuaugugagauauaccuuucaccuucugccgugauugugaggccuccucagccacguggaacu\n", + "guaaaaacuccuggaagaaaagauccugcaauuuggcuuuuugugagauggaaaagauuacaccuugcccugcaaacuuccccccuuuaaaggcgaagguuuguuag\n", + "uuucaaaupaguuucccugcacaagcuuucuugucugccacuaugugagauauaccuuucaccuucugccgugauugugaggccuccucagccacguggaacu\n", + "acuucgccgcccgcgucaggccacaccgguggucupcupaccgcpucpuccgguuuccapuuccuggugcucgaggcuggcggcgaggaag\n", + "gaaacccpuugaggcaggaggcggcuagaccgguggcggcggcaucuggaguagcacugagaucuuccgguggcpaacugcaguc\n", + "cgcgcuuguggaggaguuguggaggacgccugucgacgaccaguaacugguccucggccauugcg\n", + "agaagcgucgcggagaapccaccucaggugaagcgcgcuuguggaggaguuguggaggacgccugucgacgaccaguaacugguccucggccauugcgguguguuucag\n", + "uugccucagaagcgucgcggagaapccaccucaggugaagcgcgcuuguggaggaguuguggaggacgccugucgacgaccaguaacugguccucggccauugcgguguguuucag\n", + "aguccaggcpagccggaagcccagcgcggagccggccgcggcccccuguuguguugcugcggagag\n", + "aacaguccaggcpagccggaagcccagcgcggagccggccgcggcccccuguuguguugcugcggagaggugagguuccggaggcccugag\n", + "aaguuuaacaguccaggcpagccggaagcccagcgcggagccggccgcggcccccuguuguguugcugcggagag\n", + "aacaguccaggcpagccggaagcccagcgcggagccggccgcggcccccuguuguguugcugcggagag\n", + "caggcggcggcggcagcggcggcgguuggucapcguguuggccccgcacagauugagccgaguugucgccccgcupagaagugacccuccugcgccug\n", + "aucagaacacugaggcucagagaaguuaacuacuccaaagucauauagccaguauuuucuggagcuguaauucaaaucagauguguucaauaccuucuacuaccccauugcugucuuuaug\n", + "auuuguaacagauggagccaugacauuuugaauucuccccaucauaccguauaacgugagaaaggauugaaaaugu\n", + "aggcggcggcggcagcggcggcgguuggucapcguguuggccccgcacagauugagccgaguugucgccccgcupagaagugacccuccugcgccug\n", + "guauuaaaguuaaggcagaaaaauuauuggaagaacuugauaauggaguacuauuaugucaacugauugauguucuucaaaacauggugaaaacaugcaacucugaagaaucap\n", + "gccpaccugacaccgcccggaguuggcgucccuucucccucuccgagugcugcuccugucauuguggcc\n", + "ggcgaccccggaaguccccgccpugcagcuuggucgguucgaucgccgccpaccugacaccgcccggaguuggcgucccuucucccucuccgagugcugcuccugucauuguggcc\n", + "uucacggcgaagcagcuggagaagcuggccaagaaggcggagaaggacuccaaggcggagcaggccaaagugaagaag\n", + "gcccuucugcagaaaaauguagagugugcccguguguaugccgagaacgccauccgcaagaagaacgaaggugugaacuggcuucgg\n", + "cuccuggugucuagaaggaaccuagugaguccugccugccagaaguguaacgucccauucccaauccucaaaccauuaauucccucuuucuuugcagauacccuguuccaguugaag\n", + "ggcgaccccggaaguccccgccpugcagcuuggucgguucgaucgccgccpaccugacaccgcccggaguuggcgucccuucucccucuccgagugcugcuccugucauuguggccauggacg\n", + "caucacugcaaaucagaaggacucagacagaaagcgcucccugagugccaggcccuggucacagcagcucuuugcguccauucucc\n", + "ucgccgccpaccugacaccgcccggaguuggcgucccuucucccucuccgagugcugcuccugucauuguggcc\n", + "pcggcgaccccggaaguccccgccpugcagcuuggucgguucgaucgccgccpaccugacaccgcccggaguuggcgucccuucucccucuccgagugcugcuccugucauuguggcc\n", + "ccccgccpugcagcuuggucgguucgaucgccgccpaccugacaccgcccggaguuggcgucccuucucccucuccgagugcugcuccugucauuguggcc\n", + "cpcgccuccuggagagcaaggacgcpagcagaggugagcuggcaccggaggcuggapauccccgagcccpaucg\n", + "agaggugagcuggcaccggaggcuggapauccccgagcccpaucggugcgcggcagaggaggcucgcgg\n", + "agcpaagagccggccgaagcguggcggccacagacugupuaccpuccgapacucgcgcuuuucucuccgugcc\n", + "gccgcgcagcpaagagccggccgaagcguggcggccacagacugupuaccpuccgapacucgcgcuuuucucuccgugcc\n", + "agccgcgcagcpaagagccggccgaagcguggcggccacagacugupuaccpuccgapacucgcgcuuuucucuccgugcc\n", + "cucuggcuuaucaggacuccauaguucuccaacagagaaaucuugaaaaggacugaccaguuuuugcaguucuaaaacc\n", + "agcucuggcuuaucaggacuccauaguucuccaacagagaaaucuugaaaaggacugaccaguuuuugcaguucuaaaacc\n", + "gagcggccacuguupcccucgaaagaggugucgguccucupagucggaagagcugucugg\n", + "aaaauggcuccaaagguuaaaugaagcaggaaaaauacauagaugcagccuugcagccucuccagauguuupauaauauuccagauagaaauauugaucccuuggauuagguaacuagucaua\n", + "cuuggaauauugcaggcauugcuccguugucguccgguuuucaguguuacuguuaagucacaugccgccaguuucccaggcaguu\n", + "ugcuagccagcugagugacagugauggauucaaaacaucaguguuugaagcuaaaugauggucacuucaugccuguccupauuuggcaccuaugcaccuccagag\n", + "apacagccugcguuccupcuggcupugcagcucucuuuucaggagagaaagcucucuuggaggagcuggaaag\n", + "ggaggugguggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcppuaauucpucupuucuggugccgcgcagcuuuccccg\n", + "ucuaaaaguugguuuuaauugguugcccacaggauugacuuggccucuacuucuuguuaaggaaauucaucucuuguuuuaucag\n", + "ggaggugguggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcp\n", + "ugguggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcp\n", + "aggaggugguggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcp\n", + "guggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcp\n", + "ggcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcppuaauucpucupuucuggugccgcgcagcuuuccccg\n", + "cgaaggaggugguggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcppuaauucpucupuucuggugccgcgcagcuuuccccg\n", + "upaguupagcugcuccggcuucggcgcggapcggcggccpaggcggcggcggcggcag\n", + "uucccagagaucguggccccccuccugaccucaauagaugccaucucccuggagugugagcgcgugcupagag\n", + "gcucupuugupaguupagcugcuccggcuucggcgcggapcggcggccpaggcggcggcggcggcag\n", + "cgcucupuugupaguupagcugcuccggcuucggcgcggapcggcggccpaggcggcggcggcggcag\n", + "gaguugcauucugguuccgucgugugucuggcguguggagcuagugcucccgcuuauucgccacugucgccaccgcuguc\n", + "ucucuugauccuggucucaccaugugauacacccacuucgccuuccgccaauaauuggaagcuuccugaggcccucaccagaagcagaugccagcaccacaccucugguucaccugcagaacc\n", + "guuccacuuacucacucauguaaacuucuuaaaaacucggcaaugaauuaccauauggagcuccaaguacaaaugcugugucuaucgccuuugaggucuccaggcagag\n", + "cucuugauccuggucucaccaugugauacacccacuucgccuuccgccaauaauuggaagcuuccugaggcccucaccagaagcagaugccagcaccacaccucugguucaccugcagaacc\n", + "uuccaagguugaaagaaaauagaaguagccaaaaucuauauccugaaccacgcacaauggauuauggccacagaaucaguacagcugaucuaapauau\n", + "appauucauuaauccaggucggaaauacaccuuguuccucgaggauuuuggaaggaaauuccacccgcgaaguccccuuuuggagaugcccuuuuccuuucag\n", + "auggaaguuuapccuggacaguggccccgaguccggccugagagcgcagccupcugcuggcapaagaggaag\n", + "gcggcgaggcucccgcgcgcggcugagugcggacuggagupaacccpuccccgcgcuuagagaacacgcg\n", + "ggacucgcuguggaacccgcggcgcapcggagugcucgcgcggcgcugcguccpagacg\n", + "gaggapuggcgagaggupupcccaggugaguagcpcgaaggcpccugaggaggacugagcupcpacccag\n", + "cagcugcuccaagcuuuucugccauuugaagcuucuucupagccagcugugaccagaggaauagcuccagccauccgg\n", + "uuaaaaguuuaacaaccggaacagcuccagucugcagcucccagcgugaucgacgcagaagacaggugauuucugcauuuccgacugag\n", + "guuuuagcuaaagaagauacugaggcagcuauucaaucaauauuauacaaagaaaauucuguaauuaag\n", + "aucuugucugaccccgguuauauuuuuccuucgguapauuggacuuucugaaggacguugugauccaaaggaaggaggccggaggucucuacuucccauacagcag\n", + "ccugguccgacccccaguggcacuaacgupauccucapcgcucucccagcaaagcaguggccgcccpcggcpauccacuguccggcagag\n", + "agucucgccagcugccggucuuucpcuccguaacuuucuauccguccgcgucagcgccuugccacccucaucuccaau\n", + "agacucgaagagcuccpaaggaggapagcagcccagccccggcugapcagucaggugugacgcccacgcpagguagcaagagaugag\n", + "ccgccgcuggccuggccccgucugucucucucagcagcugucuuucucgcgcccacuggccggucucuccucuuccccgcaguugccuccuucucugccugccupuggccgcc\n", + "paggagccccagccccgcgacgaggaggaagcggagcuggagcugcugaggcaguuugaccuggccuggcaguacpcccugcaccg\n", + "caccgcggacagcgucucugcugcccagccccaupauguccuggucgcgccgccacaacccaggcpacucucccagg\n", + "cgccgugcgugcgcgcgcccgguccgcgccuccgccgcuuuuuauagcggccgcpcggcggcggcagcgguuggagguuguaggaccggcgaggaauaggaauc\n", + "gugcauuugugcaggagacugagaapuuucuucugagcagaaagcuuagccupcuuacuggccagagcugccugcagccupaagcag\n", + "caucucuaacaaggagcucucggagcugaucgagcagcugcagaagaaugccgaccagguggagaagaacaucguggacacagaggccaag\n", + "aguccpcuccccgcgccgccgcucgcucaccugcgcucccgcccgccccucggugcgcgcccggcccgccagccgccgccgcccgcaccccgagcgccacc\n", + "gguupaagaacauggaaagugaccucccugccaaauaacucagaagaggagugucgguagccaa\n", + "augaagacacugaggcucagagagguuaagugacucagccaaggucaaacagcuaguaagugguggagccaggacucaaagccag\n", + "gacgaaggacgcaugcguuuggugagucccggauucuggupuucuuccgcucaggcupugaagcgcuuccpucgccgccggcagcagccucccggcgcg\n", + "gagcpaaaacaaaaggagacgaaggacgcaugcguuuggugagucccggauucuggupuucuuccgcucaggcupugaagcgcuuccpucgccgccggcagcagccucccggcgcg\n", + "gaugaagacacugaggcucagagagguuaagugacucagccaaggucaaacagcuaguaagugguggagccaggacucaaagccag\n", + "aaaacaaaaggagacgaaggacgcaugcguuuggugagucccggauucuggupuucuuccgcucaggcupugaagcgcuuccpucgccgccggcagcagccucccggcgcg\n", + "paaaacaaaaggagacgaaggacgcaugcguuuggugagucccggauucuggupuucuuccgcucaggcupugaagcgcuuccpucgccgccggcagcagccucccggcgcg\n", + "cacuaugaugacgaggaagaagaggaugaugaagaugaugaggauagugaagaggacucagaggaugaugaggau\n", + "cpacuuucggcpucccggccpcagacccaagugccggcggcggagacugcaguggagccaguaccggcuguaguggccpccguggcpagaguc\n", + "acuuucggcpucccggccpcagacccaagugccggcggcggagacugcaguggagccaguaccggcuguaguggccpccguggcpagaguc\n", + "cuucggcgcpacuuucggcpucccggccpcagacccaagugccggcggcggagacugcaguggagccaguaccggcuguaguggccpccguggcpagaguc\n", + "agauauacugagugagcccugagaagcagucucagauccugacggugcagcagcccgcagccucagccapagucccagccgcuuuca\n", + "cucggagccguupucgguuccugcuauuccggcgccuccacuccgucccccgcpucugcucugugugcc\n", + "cggagccguupucgguuccugcuauuccggcgccuccacuccgucccccgcpucugcucugugugccauggacgg\n", + "ugcpcgucuccgccauuuugugagucuauaacucggagccguupucgguuccugcuauuccggcgccuccacuccgucccccgcpucugcucugugugcc\n", + "gcgucuacggugacgugcagcgcgugaagauccuguucaauaagaaggagaacgcccuagugcag\n", + "guuuuucuupuucagucacuuuuaaaagucuguuaaacgugguccgugcagucuguggugucagaagaggcgcagcccuagagupucuggaccccuuagc\n", + "cgucuccgccauuuugugagucuauaacucggagccguupucgguuccugcuauuccggcgccuccacuccgucccccgcpucugcucugugugcc\n", + "gcacuuuccuguuaccuaaggaagaacccuugaagaagaggaagaggaaagaaagacaagucaggc\n", + "accuguuuccgagcggagagcgcpccguuuucuuuccuggugucccgucgcggcuupacccggcaag\n", + "gugcgccgagcuccgccccacgagcaccuguuuccgagcggagagcgcpccguuuucuuuccuggugucccgucgcggcuupacccggcaag\n", + "auuucugugcgccgagcuccgccccacgagcaccuguuuccgagcggagagcgcpccguuuucuuuccuggugucccgucgcggcuupacccggcaag\n", + "gccccacgagcaccuguuuccgagcggagagcgcpccguuuucuuuccuggugucccgucgcggcuupacccggcaag\n", + "acgagcaccuguuuccgagcggagagcgcpccguuuucuuuccuggugucccgucgcggcuupacccggcaag\n", + "cuccgccccacgagcaccuguuuccgagcggagagcgcpccguuuucuuuccuggugucccgucgcggcuupacccggcaag\n", + "gcagaugagcagaguccugcuagagaggucagcucagcguccaggapcgccugcccccgaggaggccacggac\n", + "gaagaccuggaagcgcucauagcccauuuccagacacucgaugccaagaggacucagacuguggaacuuccgugccccccacccucaccaag\n", + "guuaaaugccucccucucgguucauccugagaaagaugaguuaauccuuuuuggaggugaauauuucaacggccaaaaa\n", + "acuuuuuuguauaacgagcucuaugucuacaauaccagaaaggacaccuggaccaaaguugacauccccaguccaccuccgaggcgcugugcucaccag\n", + "apcggagacgaccuugccgccggcpaacucupucucgcgguuupagcgcuacucgccagguggacucggaguccgcgagcgucgucggcaagcggccgccuuuccacg\n", + "pcggagacgaccuugccgccggcpaacucupucucgcgguuupagcgcuacucgccagguggacucggaguccgcgagcgucgucggcaagcggccgccuuuccacg\n", + "cucggagugaggaugccaggucaucucccucucagagacguagaggcgaggauuccaccuccacpaguugcagccg\n", + "gcgguuupagcgcuacucgccagguggacucggaguccgcgagcgucgucggcaagcggccgccuuuccacg\n", + "cuucuaaccuccauuguugcugaagauuauauaauuacagucugauucuucuuccuuuuuaggagaccuauauuuucauuucu\n", + "guguugcugccuauguuggcuggcaaagcuccucaauucucaagccucugcugcaacaaggucuuagugaugcugaggaauuugucauugugaaagcucuuuaugcccuuacuugu\n", + "uuucuguaaguucuuaggaucuuagcuuuucugugguguccgagaauuuccugaugauuugccuugcugupucuuuuuaacuuuaucaugcupuaggaagugcaauguucuuuccuag\n", + "auugucucuapcuuucugucuugcuguaacgucucuccagccagcugcagcuccugcugacuuaucccaccccagcgcaggucauccaacggugacuuauggccccggccuccuggcucgaugagg\n", + "gugcacggcgugguccugagcucagcgccggapacguuagguggaagcgucuuuggcagagcugguagcgaaucggagag\n", + "agcgguccaaggugcpccaggcugaggugcuaggugugcpccpaugcpcggcggcupuccpauguggag\n", + "aucccapuaucgcgagaacugcuucggcguucuggcuacagguucpcgcpucucuuccgcggaaacugacauugcguuuccguugucggccucccacugcag\n", + "guaagugacaugagguagaguugguuuuagcuucccccgacggaugccuccuggaaauuucuaaggcaag\n", + "gcgagaacugcuucggcguucuggcuacagguucpcgcpucucuuccgcggaaacugacauugcguuuccguugucggccucccacugcag\n", + "uggcuacagguucpcgcpucucuuccgcggaaacugacauugcguuuccguugucggccucccacugcag\n", + "acaucccapuaucgcgagaacugcuucggcguucuggcuacagguucpcgcpucucuuccgcggaaacugacauugcguuuccguugucggccucccacugcag\n", + "puaguugguaacagcauccucaugcagucggucuuugaguucccuuucugucuuccugcugacuuagcgccaugcugcuugcccauucguggcuuuccauauap\n", + "acucauucugaugaaggaaagagcgucccugugcagcugcguguccuucaguucuuuggcucugauuccgugucuggcuucaucuaaguggccugguccaupcagugaagaaauguaaagu\n", + "ggccggacggaggcaucggaggcggcugcgagaguggcagaggagcuggcggagagcggccugcpcgaucpccgag\n", + "ccucgcucaaggagcacccccpcacccuccuguccgauggcagcccggcccuguccaggaaugucggu\n", + "guggaucuppccggacggaggcaucggaggcggcugcgagaguggcagaggagcuggcggagagcggccugcpcgaucpccgag\n", + "gcucugagcccaagucauguguccagccuuuugacucuggagcuguggcuucagccaccaagagcagcaguggauccuggaaaccugagaacccagacuucuucucugcc\n", + "cuuucagaaggaguucucacucgaagauaaagaacagcucgcuaaccacgaaagaggaaucgaugcucagcuuuuaguugcacuuccuaaag\n", + "auucuggcuacauuggagauugguugcuuucuaaaacugaaggagaagcccaugaagagaugguggauucucacugaguuuugacuagcggaagaaaag\n", + "agagaguucaaguggauggccuugaggacuugaaaagcugagauaugaugauuuugaagucauuucacaucgaagccaugauuuaaauaucggcguuaag\n", + "cugcggcupcupcggcggcggcggcgacgcpcggcpcggcgcpcgguccggcpuucaaagaggaaaac\n", + "gguucgcucucucgcuagcucucggcugccgcucuugcugcggcugcggcupcupcggcggcggcggcgacgcpcggcpcggcgcpcgguccggcpuucaaagaggaaaac\n", + "cugccuggcaguccccaccuapcacgcugccacgccgccguuaccugguccaagugcccpaggcuccgccugucggcuucgcucugcagcugcaucucugaucuguccugcaggcucag\n", + "agcugccuggcaguccccaccuapcacgcugccacgccgccguuaccugguccaagugcccpaggcuccgccugucggcuucgcucugcagcugcaucucugaucuguccugcaggcucag\n", + "aguguggcugccccggucuccccagucucccgcuguagcugaauuccagccuggcccgcagcuagcccugucugcagcuccaagcgug\n", + "gaacucagagcgcggacagaucccagaggagcagagaaauaacacaaupagacuaupucgcagcuggcacuggcp\n", + "gaaauaaugcaaaaggugucccaaggcuccugaccagugaacaaagauuugagaaagacagccaagcuc\n", + "auauagcagccpcccpcgccgcgccucggagcgucccggcuucucccgcgcppcgaguaagccagcggcaggaccagcpcpcccacga\n", + "caaaagcuggcaggcugacagaggcggccucaggacggaccuucuggcuacugaccguuuugcug\n", + "ugguuuucccggauuguguguaggugugagaucaaccaugaguuccguugcaguuuugacccaagagaguuuugcugaacaccgaagupcugguuccgcaacaaaucaaag\n", + "pcgacuggccaggcaugaggaaaugaaucaaguacagugagauuuaacaugupcagcuuucuggaaagccagcgaauuugaccauug\n", + "cuaccacuuauaaccaccugguuaagucgagauuuggaggugguuuaguuupccuggaugcaccuugcagagagagaccgcuggcuuuuuguagcaacugucaugaugcauuuu\n", + "agccguccuuccugcucccuuucuggucuucgguuguuuccacucpuucuugcpcgcgcucccucugcuuucuggag\n", + "ucggagcgucccggcuucucccgcgcppcgaguaagccagcggcaggaccagcpcpcccacga\n", + "acacaugccucacuccugucagcaguuccaccuuuucaugguugaggagcacauguggucgccagccucccaucuccagaguccccuaag\n", + "acaacagacagccuuapaaaupaaacuggagaaaapcucuuaucccaaaaggaccagauccauuggaacagauagag\n", + "ggagcgucccggcuucucccgcgcppcgaguaagccagcggcaggaccagcpcpcccacga\n", + "aagcguagccucuucuccuuuaccaagauggcggcuugucccuguuucgccacaguuccuaccuuaugagcucgguuuucuuaugcuuauaagaguggaacag\n", + "acacaugccucacuccugucagcaguuccaccuuuucaugguugaggagcacauguggucgccagccucccaucuccagaguccccuaaggcaag\n", + "aggcpauupccgccgcccuauauagcagccpcccpcgccgcgccucggagcgucccggcuucucccgcgcppcgaguaagccagcggcaggaccagcpcpcccacga\n", + "gucaagcguagccucuucuccuuuaccaagauggcggcuugucccuguuucgccacaguuccuaccuuaugagcucgguuuucuuaugcuuauaagaguggaacag\n", + "caguuccaccuuuucaugguugaggagcacauguggucgccagccucccaucuccagaguccccuaaggcaag\n", + "cucggagcgucccggcuucucccgcgcppcgaguaagccagcggcaggaccagcpcpcccacga\n", + "pacguggccuuccugugcccpcupcccgccgccccgcpapcggagcuggcgcggccccuagcuuucuccuucuggugupcccgag\n", + "gucagagcccagcacaacaacccuucuucugguucagccgcccagcgguuaugupuacpaaagaugauccagccaugcaggagagcaccagugguucugugaggauuuuacuucaaaaua\n", + "aaaaaccaaaagaauauuuaauaucucuauuggaacgacugagaauugcaaaaguaacaggcguggcguuuccuuucuuu\n", + "cauucgcucggcacgucuccuucuugcugccuugugaagaaugugucuugcuuacccuucgccuuccaccauuauugugaguuuccugaggccuccccagccaugcugaacu\n", + "gcuagucaaaugaagcagupauaugcugcauuuucaaaaagccuucccaggagacuacaguguuugugcupucaagaaucaca\n", + "aaccgcucccgcaucccucgccugcacagupcagucuggcgccuguggcgucguguuugcugapcccggcugccguugacugaggcugcg\n", + "cccaguggagcaaaaugagagcgcagugagccpcccagcuucucuccuagccguuccgacucccacc\n", + "aaacaggugcuupcagcuaaaaauaaccacccupaagugaaacuguggcagugccaaggagcuaag\n", + "ggucucccucugucacccaggcuagagugcagcgaaaucacagcucacugcagccucgaccuccupcucaagagauccucccaccucagccuucucaguagcupacuacag\n", + "gauauaaguggauucguaugguguguagccuuuugauucuggcuuccucugcucacuaauaugcacuugaaauucauccacauugcugcag\n", + "apagcagucggucgcugcgccccggcpccacuuucccpaccccgcucgucuuccuupccgagauuuuccacugcgccccuccgaguacccpuuccaaaccccuagccacgac\n", + "accccgcucgucuuccuupccgagauuuuccacugcgccccuccgaguacccpuuccaaaccccuagccacgacauggaagaauuuuugcaacgcgccaaaucuaaacug\n", + "aaucgaagcaaacgcuuggagaagguccaugugguuauupccuaaaucgugugacuuggauucucucauuucuaccuucacauaugcuuacuuucuagacaag\n", + "guuuaaguauugaacagacaauguugaaagaucuaaaggagcugucagauggagaaauaaaaguggccauuaguacugugagcaugaaccuugag\n", + "accccgcucgucuuccuupccgagauuuuccacugcgccccuccgaguacccpuuccaaaccccuagccacgac\n", + "acccucgcccaggaaagugcccgcagcugccacggacaccauguaguapccggcugcggcgcccagugagcugcg\n", + "ccguucugcucucpcaccuuccpuuccuaagccgcpccccucgcugccccucgaggcccuuucccugaccuaggcuuuggccupcuacucguuccggagccgcc\n", + "agaagccacccgcccgcggccpcacgcaccgcgcgcagaccuucugcgaacaaugcuccggccpcggcuggcggcucggagaccgacggapccpagcgcagcccagag\n", + "gaagccgcucugugacccaccucugaaucccacaaaacugcaccagagagccpcgcaagaugaaccagcacccugucggcucaag\n", + "auacuauagccauaugaaguugaacauggcagaagaagaggacuauaugucugauuccuucauuaaugucca\n", + "ggaaaaguggcauuggucaugaggcaucauuaaaacggaaagcagaggaaaaauuggaaagcuacagaaaaaagauucac\n", + "ccgguucggugcccgcggucccggagaggaggugccgccgccaccgccgcucccccccucccgcugcccucpccpcupucgagcugcg\n", + "aggaagcpagagcggcgcgagaagcggcggccgcguccucaagccggcaccugagcggcggagacggcuguagcacaag\n", + "ggaagcpagagcggcgcgagaagcggcggccgcguccucaagccggcaccugagcggcggagacggcuguagcacaag\n", + "gucaguucuccucpucucpacuugacauaucccacaucucccagcgauuggagagucugagugcagccaccaccuuugagccucuugagccugugaaggacacugacauucag\n", + "cuuggccaaucaggaagcpagagcggcgcgagaagcggcggccgcguccucaagccggcaccugagcggcggagacggcuguagcacaag\n", + "cccagauccucuaagacaagacapauaaagucucccguggaauccccucccgccucauauucccugacccugcccucccugcgagaacuccaguccpcuccacaaapcgcg\n", + "gagaguuacauuaacuguggcggcpaaggcggagccugcagcuggcupcgguuaggapcccpccgagacg\n", + "aucgcgagaguuacauuaacuguggcggcpaaggcggagccugcagcuggcupcgguuaggapcccpccgagacg\n", + "auggagucuugcuuagucgcccaagcuggaguaguguggcucgaucucagcucugcaaccucugccucccapuucaagcaauucuccugccucaguuuccagaguagcuggaauuauag\n", + "auuaacuguggcggcpaaggcggagccugcagcuggcupcgguuaggapcccpccgagacg\n", + "agauccucuaagacaagacapauaaagucucccguggaauccccucccgccucauauucccugacccugcccucccugcgagaacuccaguccpcuccacaaapcgcg\n", + "auucupaaagugaacuccacggaagacucagaaaccaaguucuaauucaguugccaugaaaacuuaaggugagaggauugucaaccagugaaaaauacggaggaaaacacuaacagaauaug\n", + "acauuaacuguggcggcpaaggcggagccugcagcuggcupcgguuaggapcccpccgagacg\n", + "cugaacugaauuuacacgaaaapaaggaggaaaaugguuugucuuuuuuugcagagaauucuauccaaauucacuugcauuuaauuacuucauauuuuggaaaugacauuuucaa\n", + "guguuuaaaauuauccaacugccauagagcuaaauucuuuuuuggaaaauugaaccgaacuucuacugaauacaag\n", + "aacuugcuuucugcugcaggagagaggcguauugugguauaacuguugcuguauuuauucaaauggacaauuugcaauagauauuauacccaggacgacagauaagucaacacauaag\n", + "guuuaaaauuauccaacugccauagagcuaaauucuuuuuuggaaaauugaaccgaacuucuacugaauacaag\n", + "cagguguuuaaaauuauccaacugccauagagcuaaauucuuuuuuggaaaauugaaccgaacuucuacugaauacaag\n", + "agcugaacugaauuuacacgaaaapaaggaggaaaaugguuugucuuuuuuugcagagaauucuauccaaauucacuugcauuuaauuacuucauauuuuggaaaugacauuuucaa\n", + "ccaugugacaaaucugcagccccuuugccaugauuaaaggucuccugaggcccugaccagaagcaaacgcuagugccaggcuucuuguacagcccgcaaaacu\n", + "ugagcaaaugaaagacaccaacaaaauccaacacauaaagauucacacuugaaacagauuaaucagg\n", + "aaucaaguuucuuacupaaaugcccagauuguggauuggccuguaguuuauaguaaugacgguuuuuguaaacucucuggauaucaucgagcugacguc\n", + "cacgccuggcuccgcuccuucuuacgcaugcgcgacuccgagcuggccaaagaaguucguccccuuugugaggcccp\n", + "cauuggacacauuuccaccaugcuaauggcauuuuaaauauauuuggcaauuuucccaauuuuuuacugaagaaaacuguaaguuuauacuugaggacugaagugugacucugccgauuaucag\n", + "cucugacaccccucauucaaaggcaccucccaccccgcaccucagccuuggcggagaggacucacag\n", + "gcgucacagcaggaccaggcggcuaagcapagaagagccagapcgucaggugucugaugcggugugcuggcaguugapugaag\n", + "ggccgaggagccupccpccpcpacuacuccggagucaggaggcagcagcggcggaggacgaggaucucuggcagucagcgccgcucggacgccgccggcacc\n", + "ggcuccacaccugcaccucccucucaccugcuccucuaccugcuccacccucaauccaccagaacc\n", + "ggacuguugacauucapauguggccguagaauucucuuuggaggagupaacaccuggaaccagcucagaagaauuuguaucaggaugug\n", + "gcgcagucgugaguccucuuguccuugagcgucaaccuucuuucccugaaguggcupuuccuguuuccuucuuugauugacaacuuguguuaacccucgcacaucucupccaauuuuugcuu\n", + "uuccuguuuccuucuuugauugacaacuuguguuaacccucgcacaucucupccaauuuuugcuu\n", + "gcauugacaagacuccaucaacugaaacuuuuaggucauacuuuagucguugaauuugcaaaagagcaagaucgaguucacuccccaugucccacuucaggcucugaaaaaaaaaaaag\n", + "gucugaugacccugucgaagaugauaaagaaaaaaaagaacuugguuauuuaacaguagaaaauggaauugcaccaaaccaugg\n", + "ggccacaaacacaagaguaupacacgccagaggaagccacacggauuuugcapagacaguaaggauuuugcucaucaucuuaaa\n", + "gcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "ucuuucacugcaaggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "cuuucacugcaaggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "aggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "gcuuuucucucucucuuucacugcaaggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "caaggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "cucuuucacugcaaggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "ggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "cucucuuucacugcaaggcggcggcaggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "aggagagguuguggugcuaguuucucuaagccauccagugccauccucgucgcugcagcgacacacgcucucgccgccgcc\n", + "ggcucaccacacggcaaggugcccgcuuccaagcugaccccaccagcacucagacacgcaugcacacacacacgcagaccuacuaugaacuggcuugugcucagcaagagcagaauug\n", + "guuuuggcpcgguuggcguugcgcagaaggcggcggcggugguggcuuguggugcggccucaccauacaggaacapcagacguuagcgugagugaucacucucaaucccgg\n", + "agcugccagcccgccaagacccagaccupapaggccccuccuguuagcccagapaaagaaagaacupcgauccg\n", + "acgccggcuccgcgcuccapcugcugagcgcccagcggacaccggcagcgcgcggucgacgcpccugagcucccuccag\n", + "guggccggcggcucuggucucggcugugagcugcgcucuccacgccggcuccgcgcuccapcugcugagcgcccagcggacaccggcagcgcgcggucgacgcpccugagcucccuccag\n", + "auagcugaauucaauguuuauucuuauggacuacuuagcauuugacuagacgguaugaauuucuaaguaag\n", + "cauguaggagaauacuaacccugcacagauugugauggugauguggaauauacuaaagccuagaacgcaccuccucug\n", + "cacauauagaacuggaugcccuugugguacaucucaaggcugauuugaaagcuugagagaccaucaagaauuggauuupaagag\n", + "aggagacagcuacagugauccaacuaaaccaacapauuuucaucagcacuucccugguguaauc\n", + "aggcaggauacuguaauaaauaggagacagcuacagugauccaacuaaaccaacapauuuucaucagcacuucccugguguaauc\n", + "agaguggucccugcccuuccgcgccucgagccaucgcuaccgcccuucggaaccagugcagcggccgauca\n", + "auaaucpcggccpcugaapagaggcgcaggagcccupagaguggucccugcccuuccgcgccucgagccaucgcuaccgcccuucggaaccagugcagcggccgauca\n", + "ggcugcugagaagucgauuacuauccucucuacuccugaaggcaccucugcggcuuguaagucuauucuggagauuaugcauaaggaagcucaagauauaaaauu\n", + "cacagaagagauccccuugaagauuuuagcucauaauaacuuuguuggacgucuuauugguaaagaaggaagaaaucuuaaaaaaauugagcaagacacagacacuaaaaucacgauaucucc\n", + "cuucaagcacauuuaauuccuggauuaaaucugaacgccuupucuguucccacccacuucap\n", + "cuuuccaugaugaguacaaagccuupaauaucuggauaaaguaaaauuuucuagaaugugaucuggacuugccacaaagaaacuucag\n", + "ggagacgcgagucugagagccugcpcpcggcgcgcugcaggcgagcpcgagcpcgcgcccugcap\n", + "gauccgcucccggcggcgcggagacgcgagucugagagccugcpcpcggcgcgcugcaggcgagcpcgagcpcgcgcccugcap\n", + "gagcgcuccaagauggcgcccaccgcagucccgcccgccgcauccucggcgccuuugcaguccggccgcgccucccpccccgcguuapccgccgcugccucccucgccgccgccgcugcc\n", + "pagcgcuccaagauggcgcccaccgcagucccgcccgccgcauccucggcgccuuugcaguccggccgcgccucccpccccgcguuapccgccgcugccucccucgccgccgccgcugcc\n", + "gccggcgcccuguucccucuugccccugauccgcucccggcggcgcggagacgcgagucugagagccugcpcpcggcgcgcugcaggcgagcpcgagcpcgcgcccugcap\n", + "apaggcggcacugupcugccggcagccpcupagagacauguggacacguggccucu\n", + "gagcccggugaugcugcgaaggcugugaacapaggcggcacugupcugccggcagccpcupagagacauguggacacguggccucu\n", + "cccucccuuccugcgcgcgcpcggcgagacagcggcggcgacggcgcggaggccccpcgcggcgcag\n", + "gcuccaaagaagaagaaaccaaggcccagagapaggcccaggugcapagcaggcgapaaggauccguacapcccaacacuacuccaccaaccgaagcccccaaaag\n", + "ggugaccucugaaacucaguacugcggcgaaugagcuccugaccuugaggaguacuuaacagaauuauuucucgaagaaucauugupaacccuucaaagaacccagcg\n", + "agcugugugupacccaaguccugagcucggaggcauuuucuggccapcuguuuccucccuucuccccugccucuggaaaagucugcagugccccaaggcucupaggc\n", + "guuugagcuggcugaagaagacgcgaaagcaggaagaggucugcccaccuaucagagaagcagaaggcacagugccucugaccagcaucgucuguaaag\n", + "guuaagaaggcuuuuuugcucuguagccuggacguacuuugaagccccuccccacgaugcuguacgugcacaaugguuacuaggcaauccguacaucaggagaapacacucuuccauaag\n", + "cucuucgcugcuccguagugacpauuguuguguugcagaaauccggcaaucgaccugaggacuugcgagccgcucagcucccpacguuug\n", + "gcggacgccgccgguuguccucuucgcugcuccguagugacpauuguuguguugcagaaauccggcaaucgaccugaggacuugcgagccgcucagcucccpacguuug\n", + "gaucccccagaagaggcagaacugcugcuacagaaccugcaaaguagaggucccagagacugcguggugcuc\n", + "cccpacguuuggugcgucuucuaapcgupcgaguuuacgcpccaguuguugcuggucgcaugg\n", + "aggugcggacgccgccgguuguccucuucgcugcuccguagugacpauuguuguguugcagaaauccggcaaucgaccugaggacuugcgagccgcucagcucccpacguuug\n", + "guuuggugcgucuucuaapcgupcgaguuuacgcpccaguuguugcuggucgcaupuaacgaagaaaguucggcuag\n", + "gcuacacacaacccagcuguaccagcaugugccagagacacgcuggccaaucguguacucgccgcgcuacaacaucaccuuc\n", + "cpaugugagugccgcpcgapcpupcucccapucccggupcpcgcgcuapcgapcpacggccpcpcgcgccag\n", + "cccgcgccccgccccgccccgcccggucgcggagcugcggccagcuuupapccggccccp\n", + "gupcucccapucccggupcpcgcgcuapcgapcpacggccpcpcgcgccag\n", + "gugauguuugcagacagaaaaaguaaacugucaaggaauucagagcauupuacuuguuauuuggaccaguuugaagcaucuuugauuuauuggaccaacuggcaacagaaa\n", + "gaaccuaacucucagagaaguaaugcugaaccuaacagcaaaaguagauguucagagcaagucaguuuuucguuaaacaaugaag\n", + "gaccgcuucacccugaucapaguaucggcugcpugcgcaaggcguccaggagugaccupcuguggagagcgacccguggccuuguguuucag\n", + "agaagguggagaccgcuucacccugaucapaguaucggcugcpugcgcaaggcguccaggagugaccupcuguggagagcgacccguggccuuguguuucag\n", + "ccaccaggaaagacuucagucgaagucccuucauuugucuccucaagaacaaucugccaguuaucaagacaggaggcaauccuggcggcgagcaagu\n", + "ggagaccgcuucacccugaucapaguaucggcugcpugcgcaaggcguccaggagugaccupcuguggagagcgacccguggccuuguguuucag\n", + "guggugacgguaucccagagugccagagaaccguugcuuuuccgaguugcucuucuuccaggcuccguugguggucggc\n", + "agccuucccggucagcgguggugacgguaucccagagugccagagaaccguugcuuuuccgaguugcucuucuuccaggcuccguugguggucggc\n", + "gacaagguggagcagacaccucgcagucaacaagacccggcaggaccaggacuccccgcacagucugaccgacuugcgaaucaccagg\n", + "gugcugcagcgcaguaaauguaauuugaagaaggcagaaggaacccauggcuuuagccggcugcccagauuccuuuuugcaccauccguacuaccag\n", + "guucugaaaauauugugcacapcaggcugaggacacagccacgugauacccacuguagagagapagagagagaccuccuaugcaagcugccggcccucuguuccguaguaag\n", + "ggupaccuucauguucuccccuuugcagaugagauuaucaaagcagaaaaagaccaucucuccuacugaguaacagag\n", + "acuupaggcugcauucugauaauucucaggaggaagaauguauaggagagaccapuuuuuaaggugugaccucugaaccaccuacaucagagcugacugccucucg\n", + "cuucagcugucuucagaauaaugucacccggccuccucuccugucuucugcagucuuaaaagaccuagucccuaacugaggucuggcuuuuccucagcccuggaugaaguggag\n", + "gacagacauggcgcuucagcugucuucagaauaaugucacccggccuccucuccugucuucugcagucuuaaaagaccuagucccuaacugaggucuggcuuuuccucagcccuggaugaaguggag\n", + "guuuuacugcaaugacugagaaguucagcagugccauguacauggacagapcugagcaguugguggagauccucaacuaccacauaagugcaauaguggaga\n", + "gcpcugcgagcuapcpagaaggagcgcpaggacguaccuugugagaugcgagccggccaacagcuugcaagc\n", + "paucgcgucucaguccaucappapuggcgcgcgcgccauuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "cappapuggcgcgcgcgccauuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "gcugccpaucgcgucucaguccaucappapuggcgcgcgcgccauuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "gauugguagcuuaugucgaucuugaugaaagagcaauugaugcucucapaauuuaaugaagaaggagcucugucuguacuacagcaguucaaggaaagugacuuaucacauguucag\n", + "auuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "gaaaauguaggupaggaauaguuuccgacaucuggcaaagacagucuagauacagucacauaucaacaaguggaagacuguguuuucccapuagaag\n", + "gucucaguccaucappapuggcgcgcgcgccauuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "gccauuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "guggcgcgcgcgccauuucuagucguuuucaaagcgccucgcgcugauucucacpcccggcugccggcccccgcucugcccug\n", + "gugcccuacgagacgcugaacaaacgcuuucgcgccgcucagaagaacauugaccpagaccagccacgucacc\n", + "agugguggagcagguggugcggugcugguguupugcugguguupugguggugcgugcuguguacuuupcacccpucguugcccag\n", + "guccaccucaugcccgauguucuugcaguugaggccccagcugagguucuugugcguggcgagcagcucguccagguucuuuuccag\n", + "ggcagauggaagacuuppucucugccagcuggaagugcuuggcuccacuuagcagcuaaacuuagcuuuucaaucgaucgcuuuugaaapaauuguauuucuguccccgugcgg\n", + "agucccugcauugcgcgcgacccggcggcpacaggcuugcugcuuccuccuccucggccucacc\n", + "pucucugccagcuggaagugcuuggcuccacuuagcagcuaaacuuagcuuuucaaucgaucgcuuuugaaapaauuguauuucuguccccgugcgg\n", + "gacgucacggcagcgcgccggccgcgagagapccccgucgcgaccgcguccccuupuccuugauccugagcugaccpuagcc\n", + "ccggccgugacgucacggcagcgcgccggccgcgagagapccccgucgcgaccgcguccccuupuccuugauccugagcugaccpuagcc\n", + "gucacggcagcgcgccggccgcgagagapccccgucgcgaccgcguccccuupuccuugauccugagcugaccpuagcc\n", + "aucuguguguggugcgugugucuccgcaccacgacucccucuccupucugcucaguccacggaggcagcuccccuucagcuguugccagaaaaccpaggaaa\n", + "gaaaucuauaccuuuggaagaauauupaaaapagcuuuggaauagucauugaagcgacagacaaggaaacagaaacgaagupcaauuaaaaaagugaacaaagaaaag\n", + "gcuggaagcucugcugugaaguuacuugaacgagaggugaacauucugaaaaguguaaaacaugaacacaucauacaucuggaacaaguauuugaaacgccaaag\n", + "gagaggacucugcuaugaaacuuccugagugaaaugauaaguggcaugaagaaaaacaaagcaag\n", + "ggugcagaauuccpcucagcgacagccugcgccgagugugcgcaccugucggagacccgccaguccgccggccgcg\n", + "gcapccacuacuucucagcacauccggccuucuggcucaucuccucccugcaucucacuacgccccuccccacuccagg\n", + "agaauuccpcucagcgacagccugcgccgagugugcgcaccugucggagacccgccaguccgccggccgcg\n", + "gagccacgucuccgaagaccgauagcugcuucpauuggcguccpcggcuaucuapcugcupaagauggcggacucgguggcuagccg\n", + "gauagcugcuucpauuggcguccpcggcuaucuapcugcupaagauggcggacucgguggcuagccg\n", + "auugacagaagcgucaauuccupaguaguucguugguuuucuuuccccucauccuuuugccugcucccggcgapuggcuuugauuucggcg\n", + "ugacagaagcgucaauuccupaguaguucguugguuuucuuuccccucauccuuuugccugcucccggcgapuggcuuugauuucggcg\n", + "paguaguucguugguuuucuuuccccucauccuuuugccugcucccggcgapuggcuuugauuucggcg\n", + "acauugcccaauuucugcaccccgaggcccuccaaagucuaggagaagcuccupagguccapcccaagaccaaagccucuaucaacucucccaccugugaacugccccucucccaag\n", + "auaaugcugcccaggcuggucucaaacuccugagcucaagcaauccucccgacucggcuucccaaagcacuuggauuacag\n", + "auucuggcugugacucagucacugacacugagccugaggacgagaagguuguuuccuacucgaagcagcagaaccugccgacggugacuucaccupaaccug\n", + "agagcggcggccggucccgcgcggagcccggcgccccuccagcccgagccaggacgccgccggccccggucccggccccpcacgcagcgagccapaugugagcggcgccccgcggc\n", + "cucccgccucaggccgagaugaggagcccuucagaauagcugcugucucupaggacccpcguccuuggcagcccagcug\n", + "gcugcaauuuggcgguggcgguguaagucgguggcggcgccgguacgccugguccccgcguggagucuuuacucaaaacag\n", + "cccggcuccuccacaaggcagaaggagcuugagauccucuggaggcucuggcugacupcagcuguguccaggcagccagcap\n", + "accuggaggcagcgcgcgcgucgaagaggcagcggcuguggagcgcggcpcggcuccgcccapcagcccpcug\n", + "ucucccuucuccugcucucagccucagugaucaaggcuucagugaacugcacuggagcucccagcpaucuuguccccugucccgacuuuugugcugcacauuggaucugg\n", + "ucccuucuccugcucucagccucagugaucaaggcuucagugaacugcacuggagcucccagcpaucuuguccccugucccgacuuuugugcugcacauuggaucugg\n", + "acugcccgcggcgccuccuccuagagccgcaccuggaggcagcgcgcgcgucgaagaggcagcggcuguggagcgcggcpcggcuccgcccapcagcccpcug\n", + "uccuuucuupaggcuacaaauagugacgcccugucucuaagcuccuacagcugaaacgccagcaccagug\n", + "ggcccupaguuugcugcccgaaucuccagagcuugcgcagcggaucuugcaaauguucacugcccagagcauguguuccccacugugcacacccucccagccag\n", + "guguguaacuuguauguggaaggaccaacguagcauuugccucagcaacauccuugaaucugcacccucacccacauccauucuuaucag\n", + "cuucgcgcgugaggcugcggcucugacggugaguppcgcgugucgucgccggccaggacccucucccaucacggacaccggagccg\n", + "gcgcagacpcpcagcccuuugucugaaggugcugcpaugccguuccuucgcgcgugaggcugcggcucugacg\n", + "pcagcccuuugucugaaggugcugcpaugccguuccuucgcgcgugaggcugcggcucugacg\n", + "cuguucccucugcucupucuccgccggcgcccgccccgccagccucaccugcgcggcacgugacccgcaccgcccgupcaccuugaaggcggaucccgcgcgcccccgcuccugcag\n", + "agcggcgguggcggcaggupaagcgcggcupccugcucgcgcpcgucugagcccuccauuucccgguucuaaccgcgcagcapcccaaccpaccuugagugcggcgaggcgug\n", + "gccccgccagccucaccugcgcggcacgugacccgcaccgcccgupcaccuugaaggcggaucccgcgcgcccccgcuccugcag\n", + "cggaaguggcucucapcgcuuccpaccaggcccgcuuuuggcugcaucagccpauugccggcgccag\n", + "uccucagcaggcgccucaccagccuccacaccccuugcgcccgcagaaacgcgccuggcccugagcugucaccaccgacacucuccaggcuccggacacg\n", + "cuccugccccaccaccgcugcuccucagcaggcgccucaccagccuccacaccccuugcgcccgcagaaacgcgccuggcccugagcugucaccaccgacacucuccaggcuccggacacg\n", + "ggccgupcaagaccugccuucucaucagcuacaccaccaacgccuuucccggagaguacauccccaccgu\n", + "auaguagcgagaggcgcuagcugccagcuccagcagcccagaucgcgcaguauuucugcguggcaccg\n", + "cuccugccccgccccguucuccgcuccccaagccggagcccgagcuggaggaagcccccaggugccaggaucugcccggaucc\n", + "cuccgcuccccaagccggagcccgagcuggaggaagcccccaggugccaggaucugcccggaucc\n", + "ucucuucuuccugaggccucaauucucagagcucugaauucuuccugcaccuucugaccagguggauucuuacaguaguccuaugaggugaacuuucauccccauuuuacggauuacgagacugag\n", + "cccguucuccgcuccccaagccggagcccgagcuggaggaagcccccaggugccaggaucugcccggaucc\n", + "gugauuccupcugccagcuaaggucccuuaugauuucugcucuggcuuugcaguuuucagccuuucccaagagcagcagaaa\n", + "apauucccaagucccagcgauucccccacuuccucuccaccugccacagcugccagcgaccgcccgccugaaaccacugccauuuggacagc\n", + "gaggcgcgcgaagcgcugaggcpcguggaccgcgcpaguuaagaagcaggucccggaucgccguauaccgccpuuuucucccaacgucaggcccgauggcucggcuuccccag\n", + "ggcpcguggaccgcgcpaguuaagaagcaggucccggaucgccguauaccgccpuuuucucccaacgucaggcccgauggcucggcuuccccag\n", + "gaguuaagaagcaggucccggaucgccguauaccgccpuuuucucccaacgucaggcccgauggcucggcuuccccag\n", + "auaccguguuuuuuacaaauugaaaguuuguagcaagcagcccugcaccgagcaacuauuuuuucaacagcaugugcccacuuccugucacuuacacuuug\n", + "gaggcpcguggaccgcgcpaguuaagaagcaggucccggaucgccguauaccgccpuuuucucccaacgucaggcccgauggcucggcuuccccag\n", + "aaaacaggaaauagguguuucauauauacggcucuaaccuucucucucugcaccuuccuucugucaauag\n", + "gucuggcgugcuccugaucagaguuacucugaucugaagauuuuggcguucaaggcauuaagauaauagccugaguuguuc\n", + "agacgcgcguucucgccgagcucupcaccagccagcuccaggaugugcggcggccgccagcggcgcggcgcg\n", + "uucccagagguccacuupccagugguacuuuaucgcapcagcucccaccaaggaggaguuggcaacuuuugacccuguggacaacauugucuucaau\n", + "agaguggacugagcagccaguapagagagcaguuaaggcacacagagcaccagcucccuccugccugaag\n", + "aucucaucucccagacgccacgucucucgguuucuucuuagaucacuccucugccaaagaucccaacaagacaac\n", + "cuggcugcuccggcauauuugagaaggucuguuucccugguccuucupuuuccaccaauuggcaagaapaucagccuguccuagag\n", + "gcuccuaucucaucucccagacgccacgucucucgguuucuucuuagaucacuccucugccaaagaucccaacaagacaac\n", + "ucucuggcugcuccggcauauuugagaaggucuguuucccugguccuucupuuuccaccaauuggcaagaapaucagccuguccuagag\n", + "cucucuggcugcuccggcauauuugagaaggucuguuucccugguccuucupuuuccaccaauuggcaagaapaucagccuguccuagag\n", + "agugcgccugcgcaaguuacgcgaaagcuaacagaaucugcggugcucugcuggcgacuggcaggacgcggugcagagagcggacuuccgcgacgcgg\n", + "caugaagugagaapcupucgcgcucgcuagcpcgcppucuugaagaupucaucg\n", + "gcucaacguggacpcuccuggucuacuucccguacgacuacaucuaccccgagcaguucuccuac\n", + "ggcguccgucpcagcagcpcugucuaucccggcugaggacccgcggccagugcpuggcuggcuuugccauuagcpccuuuccugaggacggcguacggagugugg\n", + "agcagcpcugucuaucccggcugaggacccgcggccagugcpuggcuggcuuugccauuagcpccuuuccugaggacggcguacggagugugg\n", + "aacuuccggcguccgucpcagcagcpcugucuaucccggcugaggacccgcggccagugcpuggcuggcuuugccauuagcpccuuuccugaggacggcguacggagugugg\n", + "cuuccggcguccgucpcagcagcpcugucuaucccggcugaggacccgcggccagugcpuggcuggcuuugccauuagcpccuuuccugaggacggcguacggagugugg\n", + "agcpcugucuaucccggcugaggacccgcggccagugcpuggcuggcuuugccauuagcpccuuuccugaggacggcguacggagugugg\n", + "cggcugaggacccgcggccagugcpuggcuggcuuugccauuagcpccuuuccugaggacggcguacggagugugg\n", + "aacagaauucuggaguaaagaagcagguucccuuuucgcuagacaccucgucugcuacuggaacacauccauuguaucuucagccuccauuuccaaaugugcag\n", + "agcauaacuuauagagaagcuaguaaguucugagaaagaaggaaauaaacacaggcaccaaaccacuauccuaaguugacuguccuuuaaau\n", + "gcucccucacugcaacugaacacauuucuuaguuuuuagguggcccccgcuggcuaacuugcuguggaguuuucaapcauagaaucguccuuuacacaauuaaaagaag\n", + "aacacauuucuuaguuuuuagguggcccccgcuggcuaacuugcuguggaguuuucaapcauagaaucguccuuuacacaauuaaaagaag\n", + "agacuugcuucugagcggaaacugaaagugaaauapagcuggcuaccagcguugaguccccuguaaag\n", + "ccgaaaggaaagaaggccaapaaagaagguggcuccggccccagcugucgugaagaagcaggaggcuaagaaaguggugaauccccuguuugagaaaaggccuaagaauuuuggcauug\n", + "acaaugcccaggacaagaucacaaagcaucauccuguucaaaaggucaacaggaucaagguugagagacccugaaauaaggccaupacaaaaugucggcuggauaggaggugcuca\n", + "ugupcucacapaagaggucaupcgaacagagugaaggcaaccaucuauaagugccagagagcccucaccagagaccaacccugacggcaccuugaccuuggauuuccagcguccagaacu\n", + "ccacauaauupccccaaagccaugaagaaggaagaggaaaugucuuaaagguugucgauggacaguguuugcugaacaucaaaaucacuuuccag\n", + "cucugcccuuucugagcccgapacugccaccuccacugugugcacacucagcuacpacaca\n", + "uuucagguauccaaggcagcagaggugagupucccccgagcucugugaccuuaugcuccacacuaacucuggcagagccuccguuuccucauag\n", + "agugacaaaugcuggcugcaauccagccagcccucugcccuuucugagcccgapacugccaccuccacugugugcacacucagcuacpacaca\n", + "gacaaaugcuggcugcaauccagccagcccucugcccuuucugagcccgapacugccaccuccacugugugcacacucagcuacpacaca\n", + "gucuuuuugccauuccuccaggacauccaccauaaggaaaggagacccuggaccaacauucucuaag\n", + "cggcccuuguccccuucccccacuauccucuccacccgcucccapcuggagucuggaaaaccacgcpaggagguugupauauggacgagcauccgaggcccccgg\n", + "uuacagacguuccacguuccgucucccugugccagcccucaggaccugagcagcggccuugccguagccuaugugcugaaccagau\n", + "agaccccuccugguucaacgaggcauggcuccapcaucucggaagauccaggucccaacuggaagcugaag\n", + "pcpcggcgcucuaggccgagcpaggucpcugcpcgcucgcugguggcggacccggaggcugcugcggcgccpcuccguggccuggauugaauccgaucpagcc\n", + "aggccgagcpaggucpcugcpcgcucgcugguggcggacccggaggcugcugcggcgccpcuccguggccuggauugaauccgaucpagcc\n", + "gcucccapcuggagucuggaaaaccacgcpaggagguugupauauggacgagcauccgaggcccccpugcguacggcugcgcaugagupcuguaaucpugucup\n", + "agaccccuccugguucaacgaggcauggcuccapcaucucggaagauccaggucccaacuggaagcugaaggugacaaguggacuccugauuagaggacagacug\n", + "gcucgcugguggcggacccggaggcugcugcggcgccpcuccguggccuggauugaauccgaucpagcc\n", + "pcuggagucuggaaaaccacgcpaggagguugupauauggacgagcauccgaggcccccpugcguacggcugcgcaugagupcuguaaucpugucup\n", + "cucccapcuggagucuggaaaaccacgcpaggagguugupauauggacgagcauccgaggcccccgg\n", + "agagucgagagupagaagagcggagcgugugagcaguacugcggccuccucuccucuccuaaccucgcucucgcggccuagcuuuacccgcccgccugcucggcgaccag\n", + "aacaccuuaacccgaagccucucugaccauccaguuggcaaagacccucaggccaugaggacuggccaaagaca\n", + "gugagaggacgugcaapuaaauuccugagccccgcagucuuauuuccugcccugacgucccugcauaccagcccaapuuaaccguaagcugaugccugu\n", + "ggaccacgcuuggagaaccacuacacuapcaagcaggaagagaguccuccuucuggaacugaagcaggcagugugaagacccaugugg\n", + "gcuucaguauuuacuggaugugacaagcagagagaagagcuuucagupccgcuugcugccuggcucaaguggupag\n", + "guucapaccacgcuuggagaaccacuacacuapcaagcaggaagagaguccuccuucuggaacugaagcaggcagugugaagaccc\n", + "gugaugcugacacugcugguucapaccacgcuuggagaaccacuacacuapcaagcaggaagagaguccuccuucuggaacugaagcaggcagugugaagacccaugugg\n", + "gccauuucgccgauuccuccaugcgaguugcugugcguuucucuguugucucgguagaaggccagagucacacacgguccuaagagcupcaccaggaagcgaaggcug\n", + "gacgcagcaggaggaaacugcucpcugcaagcagucuuccaggcuuugcggcugccaaaggaauaauugagacgucugaguugagcag\n", + "cuugcccacagaacccacagccuuccccucgauuuguccucuugcuccuuccugcuaggacagcapcuucucguacacaugcuguagcpcacugccuug\n", + "gcaggaggauuupcuuccacauauccuguucucaagauuguagcaucucaguacucuagagcccaguaccugacaucaaggaugucuggagcuuccuuuuaaggaaagaaaagaucagcaaacu\n", + "gaacccacagccuuccccucgauuuguccucuugcuccuuccugcuaggacagcapcuucucguacacaugcuguagcpcacugccuug\n", + "acaaagcaggcagacuugcccacagaacccacagccuuccccucgauuuguccucuugcuccuuccugcuaggacagcapcuucucguacacaugcuguagcpcacugccuug\n", + "uguuuucagguccapccaggaaccccagagccpugaaguggucagaggcacaguucuccugugaacagcaagaggcccagcuggucaccaucacaaaccccuuagagcaag\n", + "cauucaucacagccagccugcccaaugugaccuuugaccuuuggauuggccuccaugccucgcagapacuuccagupuggagcaggagccuuugaugu\n", + "gccucuccugacucuucaccuggacucugagucgucuuggucccaggagccaguagugaaggcaacagucugcccaccuguggacaccag\n", + "auccupagcuccugguuagcaagugagaucucupaugucagugaggcugguugaagaccagagguaaacugcagaggucaccacccccacc\n", + "gcccuccgcuccgcucggcucpcucggcucpcgcpcgcpcgcpcupcccpcggagcggcggcugcuccggac\n", + "cgccgccuccgccgcccuccgcuccgcucggcucpcucggcucpcgcpcgcpcgcpcupcccpcggagcggcggcugcuccggac\n", + "gacgcgguggcagagcccgcgcggcgcuggaagcgaguggcggagcggcpaccucggcggacucgcc\n", + "acugcugccgccgccgccaccgcagcaggucacagccccucgaggcgacagcggccccgccgcaccagagcag\n", + "agucucacucugucacccaggcuggagugaaguggagcgaucucggcucacugcaaccuccgccuccupcucaagcgauucuccugccuuagccuccugcauagcupacuacag\n", + "acccgccgcuacugcugccgccgccgccaccgcagcaggucacagccccucgaggcgacagcggccccgccgcaccagagcag\n", + "uuuccuaugcaaaagagcccaggcagaaagacaaaccuaaauaagaaucuaacuucuguaagaagcugugaagagug\n", + "aggcuugcgcgcgcacucgcugcpacaagcuucuggaagcucuuugcgguggcguuggugcuguuugcggaugcugaugcag\n", + "uuucugcaggacuguaaacuggauuccuggaaccuuugauauuccuggcuguguauagugccuguugguggacuguacugauacucaacuagagugugaapacuggauuccugccccugagacaca\n", + "gcaggcgcagugguucccgcaggcuugcgcgcgcacucgcugcpacaagcuucuggaagcucuuugcgguggcguuggugcuguuugcggaugcugaugcag\n", + "gcgcacucgcugcpacaagcuucuggaagcucuuugcgguggcguuggugcuguuugcggaugcugaugcag\n", + "gcgucugcgcucgguuugapcucggcgcpuuuccuguuccuccuucugcgcggcugcagcucpacuucggccugacccagccccc\n", + "cuacagaaagaucuagaagagguaaagguguugcuggaaaaggcuacuaggaaaagaguacgugaugcccuuacagcugaaaaauccaagauugagacagaaaucaagaacaag\n", + "pacccgguagcggcgguggcgguggcggcgguggcgguggcugcggcgacggcagaggcgaapagccggaucgccgaccugagcpaggcggcgguggcggcc\n", + "ggagcguuugugcggcgcggaguuaagcgccccggcaguaacuuaapaaguggaccapuugccgcugcccagagcgguccuuuaguuuccacuggaguggapaagagugcugcc\n", + "guaucuuucagaugaaggcauugaagcuugcacaagcucuccagacaaagucaauguaaaugacaucauccugauugcucucaau\n", + "acagaucugagaacaauuggcaagaaauuccuccccagugacaucaauaguggaaagguagaaaag\n", + "cucgaagguccauguguuuugcaaauucaaaaaauucgcaauguugcugcaccaaaggauaaugaagaaucucaggcugcaccaagg\n", + "acggaguuucacucuuguugcccaggcuagagugcaauggcgcgaucuugguucgucgcaaccuccaccucccagguucuccugccucagccucccaa\n", + "gagguggccgccugupcgcugcaaacgccacacuuuugcucuacgaagaaccuccucgcgacuuuccaag\n", + "gauugcucupagcuuugcuuagacacuugaaacuacaggagaaagaaggaucuagcgaaauauggcuacagagagcccugcuacgcgucpuccag\n", + "cccggaagaaaacggcuccugucacagaagucucgugauugcucupagcuuugcuuagacacuugaaacuacaggagaaagaaggaucuagcgaaau\n", + "agacacuugaaacuacaggagaaagaaggaucuagcgaaauauggcuacagagagcccugcuacgcgucpuccagguggcagaacauccuag\n", + "gauugcucupagcuuugcuuagacacuugaaacuacaggagaaagaaggaucuagcgaaauauggcuacagagagcccugcuacgcgucpuccagguggcagaacauccuag\n", + "gacacuugaaacuacaggagaaagaaggaucuagcgaaauauggcuacagagagcccugcuacgcgucpuccag\n", + "acagaagucucgugauugcucupagcuuugcuuagacacuugaaacuacaggagaaagaaggaucuagcgaaau\n", + "agacaagaucuugcucugucacccaggcuggagugcaguggcaccaucauagcuuacugcagccucgaacuccuugguuuaagugaccuucccaucucagccuccucaguggcuaggacuucag\n", + "cpagcaaguggaacccuupauucuauaaggacacguggcupcuugcaaaaaagaucacgccgcaaacacauucuaccuugacuacuacgaagg\n", + "agugcgaggcgcgcpcacggapcgguggcggcpcuccugcgagaagcaagcggaacuuccugag\n", + "gcugcugccuggaagcuucugcccgugccpacgcagcagugccpacacagaggagccgaccupuggcacagcccaccpcacagccagagcagcacccag\n", + "gugcuucugaccccggcauggaggaagcgcccgcguucucggcccaggcccgcagccapcugcuccgcccgcugcgccccag\n", + "gagaguuguggacupcaaccuuugccagugaugagaagugaugcucguggcagugcugaaucucucugaau\n", + "acuuuugaaucagcugugcaagagaauaucagcauuaaupcaagcauggcaggaagcuucagauaauuguuuu\n", + "aggcccugupuccuauaugugcccugcaacuupaaaauggaggupuuguggucucuaugcuguagcagccggaaagccaaaaacaagccguacuucucgcucuugacaggaucccaag\n", + "guuuucagugguggugucacugcugccaagcuggaccgaaaacggccaucggcaugcugcccaaccagcacc\n", + "cucguucccuaacauuaaagagaaaaugcugcuauccgugacuuccaggcccpauuucgacuuuuggcuacaauagaaacaacaagaag\n", + "gcuauggcuuuguagauuuugacagcccuucagcagcacagaaagcuguaacagcacugaaggccagcgguguacaggcacag\n", + "ucuuucuuacccccucccuuucucucucucucucucucucgcucguucccuaacauuaaagagaaa\n", + "pagucagcucggagucccgucccagcgcggcgucagcgcugcgcacuucccauuggccgagcgcggcgcpcpcccpccugcgauugccucucggcgugcgcggacaguguc\n", + "acaggaucuuacgcugucgcccaagcuuggaguacaauggugcaaucauagcucauuacagcucaaacuccupcucaagcagucuuccugccucagucuuccaa\n", + "gaggcucagcacagaaggaggaaggacagcapccaacagucacagcagcccugaccagagcauuccuggagcucaagcuccucuacaaagagguggacagagaagacagcagagacc\n", + "acagaaggaggaaggacagcapccaacagucacagcagcccugaccagagcauuccuggagcucaagcuccucuacaaagagguggacagagaagacagcagagacc\n", + "uuucugagagaagaacccugaggaacagacguucccuggcggcccuggcgccuucaaacccagac\n", + "ucaguuucugagagaagaacccugaggaacagacguucccuggcggcccuggcgccuucaaacccagac\n", + "aguuucugagagaagaacccugaggaacagacguucccuggcggcccuggcgccuucaaacccagac\n", + "aggcgcgccccggacccaggauuuauaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "auaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "acccaggauuuauaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "pcaggcgcgccccggacccaggauuuauaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "aggauuuauaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "ggcgcgccccggacccaggauuuauaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "pcppcaggcgcgccccggacccaggauuuauaaaggcgaggccpaccggcgcgcgcucucgucgcccccgcugucccggcggcgccaaccgaagcgccccgccugauccguguccgac\n", + "uuugaugaaggccggaacaacuuugaapaggucaccaaggagaaccugcuggacuuuaucaaacacaaccagcugccccuugucaucgaguucaccgagcag\n", + "acagccccgaagauuuuuggaggugaaaucaagacucacauccugcuguucuugcccaagagugugucugacuaugacggcaaacugagcaacuucaaaacagcagccgagagcuucaapcaag\n", + "auccuguucaucuucaucgacagcgaccacaccgacaaccagcgcauccucgaguucuuuggccugaagaaggaagagugcccggccgugcgccucaucacccuggaggaggag\n", + "ugaaccacgagacugccaaggugauccagaccgccuuccagcgagccagcuacccagauaucacpcgagaaggcc\n", + "ggcugaauupccagagaggucucauuggcugaauuccugcaccggcucgucggaggcpacccaaaguaggcuaggccuacggaagcupucuucuugcugugag\n", + "cgcggagucgcggcpuapcggcgucgcgugcgugacgucauccagcggcgccucgcgaggcuccaguggccuugaccucccgcggcgupaggcugcgcggcg\n", + "ccggcucgucggaggcpacccaaaguaggcuaggccuacggaagcupucuucuugcugugag\n", + "pcgcpccuggcuucggccuaccggcagccaggugaggccapcuggaggcguggucgaagg\n", + "ccpccapaccaguggupaggaggcugcggcgcuagaugcggacaccuggaccgccgcgccgaggcucccggcgcucgcugcucccgcggcccgcgcc\n", + "cuuguucuaaagacgaapaacucccuagugcuacaggcuguuucaggaagccaauuaauuuuguacacauaauacuuaauuaccuucuaauaauuggagcagaag\n", + "gcuggagugcaacggugcgaucucggcucaucacaaccuccaccucucpuucaaacgauucuccugccuuagccucccaaguagcupauuacag\n", + "gcagguucuaaguuugacuuaaaagaggugacauccuugaugccaagagacccaagaagaaguugga\n", + "cuugcucuaggcagccuugaccuuaauccuugccugucucaguggucuuugugucugaccuucupucuuuggcuaccuugaucuuccucug\n", + "agacggaguuucgccauguugcccaggcupcucgaacuccupucaagccauccgcccgccuaggccucccaaagugcugagacuacagguguuccaaagug\n", + "auggaguuucacucuuauugcccaggcuggagugcaacggugcgaucucggcucaucacaaccuccaccucucpuucaaacgauucuccugccuuagccucccaaguagcupauuacag\n", + "agcaaaucucuacagcugcaaggugaaaaaggaaguuccuuggccupcucuuugcpaaagcau\n", + "agagccuuccugauguauauaugcagguagugagaauugaaucggcccuuugagacaguaauauaauaaaacucugauuupagcagcgguucuccuuauuuuucuacucucuugupa\n", + "gcacacgugguccggcgugguucaggcpugucuucggccpcuupaacauaaaaguuuguuucaccacguaagccggaccucgcacuccggucccggucucgucgccaag\n", + "gugacuguggaguuugaauupuggcgguugacuguagagccgcucucucucacuggcacagcgagguuuugcucagcccuugucucpaccgcag\n", + "acucaucccuagapcaguccuguccuaaugugcucpaguugagcugauagagacagaaacagucugcucauuucuucuucaaaacccgacuggagagccaaauauuucuuuug\n", + "guggcccaggcaaauagugucaucgauuggccuaugucguuauggupaggauugacugcugcupcupcucgccagucuupacagugucagc\n", + "cugugugccaaccacgaugcaaacauggugaauguaucpccaaacaagugcaagugucauccugguuaugcuggaaaaaccuguaaucaag\n", + "ggauguuucuuccccgcagcpcccaguccagcccccaccgcaggaacagccgcagugaaagacg\n", + "agagacccupaguccuagcugguuccuggauggaaauucuuugaccagcguccuauauggccuaaapaaaaguacaggagcucuggap\n", + "gaagaaggcgucgugaaggagauagacaucagccaucaugugaaggapcuuugagaaggcagauccuucccaguuugagcugcugaagguuuuaggacaaggauccuauggaaag\n", + "aaacguccuaggcccugguuggaauggaagcagcuuugccaggagcaupuccupccucagaugaucugaauucucgucccuugaaua\n", + "ugcuagcggaggcgccauauuggapacaaaacuccggcgacagcgagugacacaaauaaaccccuggacccccuuguucccucagcucuaapccgcg\n", + "guauuucgccguuggccccgccccucugacggacucucccuuugacagugauugagcagcuuccu\n", + "gagcpugcugcuagcggaggcgccauauuggapacaaaacuccggcgacagcgagugacacaaauaaaccccuggacccccuuguucccucagcucuaapccgcg\n", + "ccggagucgagcpugcugcuagcggaggcgccauauuggapacaaaacuccggcgacagcgagugacacaaauaaaccccuggacccccuuguucccucagcucuaapccgcg\n", + "upuccaagccucucccpuggccagucuuucuguagguugcggcacaacgccaggcaaaagaagaggaaggaauuuaauccuaaucgguggaggucgauuugagg\n", + "auuggaaagauuguupaguggcacaccacuapaaaagaagaapcgaacugcuugucuugaggag\n", + "ucucucccacucgccgcccgcuuuccaagacauaugucccgcuugcagcccauuucgaugcugcgaaacg\n", + "ucuuucuguagguugcggcacaacgccaggcaaaagaagaggaaggaauuuaauccuaaucgguggaggucgauuugagg\n", + "agaaguccuucuuguccuggucguuguucccgucugaguaccagcuccccacugcccugapcpccggccugcggcggapaaaaaggaagaggagaaggaaauugucccgaaucccugcag\n", + "caaaaugguaaauuaaaggcaccaucuuupacucccupaaaaacguaaagaaggcaguugaagaaag\n", + "ucacuguuggaggcccaugauauuguggcaucaaaguguuaugauucaccuccaucaagcccagaa\n", + "caacuacgagccacgaguuugcagaupcugcucggcggcgccuguggcugapagagcagcggcggcpagcgaccpagcggcggcagcggcggcgcggaggcggcugaggugcgagccg\n", + "ucucauuuccaguuccuccaugacguggcaagugaagacaggaaugaaaggaauguaaagcagcuuuucucugaagagaagaagagagagagacacagccaag\n", + "gcuggaggcugugcugagugcccggugcaggugagccgguccugcggaguugugccgagugccugcugcag\n", + "aguuccuccaugacguggcaagugaagacaggaaugaaaggaauguaaagcagcuuuucucugaagagaagaagagagagagacacagccaag\n", + "ggucaaupaaacugcaacaacacaacccaggcagaacuacaaauggcccacacucuucaggaaugaaaauuupucacuccaccag\n", + "cccugcucggcgcugcccgcccaguuccuguucccagacugaggcccagcccccuucgcccguuuccaucacgagugccgccagc\n", + "agccccgcgcucgucuuupccaccggucgcccccgccuccpaccugcpapcccgcgagag\n", + "auggagacgagagaucuggacuucugaacaucuaccggaaaagauaaaaugugcaagcccuucagaacgcupagguupcugaacugcagupagaggagaagagaugcuggcgugaap\n", + "guuuacacgcuccpccuguaggcgccgcgaguuccggcugucgccgucgccgccgcggcuccuggaggucgguugcgacgaguaacggcgccaggacgagcccugcgccuucuuuuucgau\n", + "gcacgcuucgcuccaacuccugcagagcugagccggapaauccggaapacacgcugaacag\n", + "gucugacucccpcagcacagcccgcucacgauuccggccacggugaugacgagucuccgucaaccucgucuggcacagcupaccuccucugugccag\n", + "agcuaccupuuuuacuuugacccugaaaagaaacgcuacuuccgcuugcucccuggacauaacaacugcaacccccugacgaaagagagcauccggcagaaggag\n", + "cuuuccpuccuugcacgcuucgcuccaacuccugcagagcugagccggapaauccggaapacacgcugaacag\n", + "gucgcuggcagaguagaagacgacaupagaagaagccaccagcagaacccuugguucagacuccgugauucugaagacag\n", + "gcuacaccuuggucuuuccpuccuugcacgcuucgcuccaacuccugcagagcugagccggapaauccggaapacacgcugaacag\n", + "aaaauuuuaucauaaugagcaucaaaagaaucccaaaugagaaaacugcuuuuugcauaaguguaaauuaagagauggaagucacauuucaccauggcaaacauuugcugcaugcaaaaugacugaa\n", + "ucccucugcuauggcucuuccucaguagaaacaacuggcaacaaaauucaaguuuaugauucauucaucagcaaacaugugagaaucaucuacaaagaaccaagaauugug\n", + "acacuuccggaagaauugcacuggacugupuauccuggucuccgcgugugugaguaccgcggcgcgagguuagugguagcupugcagacgccguggcgcug\n", + "acugupuauccuggucuccgcgugugugaguaccgcggcgcgagguuagugguagcupugcagacgccguggcgcug\n", + "agucapaggcgaacugcugagcacuggccgcggacgcuccguugcagucucgcccapccgguaccugcgcucgcgccgccpuugaaaggaugaagccgcagcuggagcagccacccu\n", + "ugaacaauugcauguacuaccuuaguucuguaagguuucucucuaaauauucagaucaucguguuupaagauacuguguaag\n", + "gcuggacaguuaacucaguaggucucagauucaucauccaccuuuuaauguagagauucacaaacuacaagcugugagaccuuugg\n", + "guucaguuaccccagucaacagcagucugaaaauauuaaaugaaaauuccagaaauaaacaauua\n", + "gguauaaaugguuuugagguucagaaacaaaacuguugcuggcuacugguuacacacaaacuuuguguaaaagaugaugug\n", + "auuguagcucugaagaaagcaaauggugaugccacuuugaaauuugaaccauuuguucuucaugugcagugucgacaauugcaggaugcacagauucug\n", + "cuuuucggccaccgcucgcuucaauauggcugcccccapagagacgaggcuaccaugaaggagccgagcgcagacccugaguccgucaccc\n", + "gccggcucccccuuccuggucucccuucucccgcupccgguuuaucpaggagauugucuuccag\n", + "uuauagugaagaaauacuuggucccauuucuuuucgccupagguaucuuuccacuauuagcaaugcg\n", + "agaguacucuccucugcuucuaccuccpaaccccguuaccccccagcccacacaccaccaccccaguuuupupagaaggcaaag\n", + "gaauuaaauuugaaaacacacagaccgagaggcagacaguuccuaggcuguggucguugcauggauuuuacaaaacuguuaaccuacaccuuuggcuuugcuguguucauuguccupaagaauu\n", + "gauuugaagacaagcuugaaggauaaaaagccuuggugcuucccaggagccgagccgaggagcagaagaggaagagccpcugccguagccuuuggag\n", + "aaagaacagcaggagacaaguggugagagcagcucccacaaugcugugacagucccuuuaucuuaggacuuuuaccaaagaauuaaccccapcaagcgauggcagcaag\n", + "aaugcauauuugcaaaaggauuaagccacagauuuaagcgccpagcccauuucugccuugcaaaggagaccggacugaaaaaccuaaagccagcucugauuucuuuucgccaagupaag\n", + "gagugucugauuucucagauaugaccauauccaguucupcuccagcccugaccuguuccuuggcuaucagaacuaucauaaggccagaucagcuuaacucaucuccaag\n", + "auaaaaagccuuggugcuucccaggagccgagccgaggagcagaagaggaagagccpcugccguagccuuuggag\n", + "agucuccuucccpacauccccpcggcagcuccaccugcugcaggaaagguaggaccugauggcuccaggcccucggaggcucagaggcgcapcugagcc\n", + "auguugguuaucuuucugaaguagacuguccauggccugaacauuuuccgaaaaucauuuugagcaaaauaucuguuuaauaacaagauaaccacaucaag\n", + "cccupaccacguccuagccccgcaguccccupaugagacccucgucucgccpaucggacauuugcccccacgucuaccccggcugcgcuucuugagcucaucgccccaucauccuacccguu\n", + "pccgcggcggccgcupugcagccgagcgguguggagcggagagaauacucgaapcucuccugauacuaacaguuuuacgauuuaaaacuucgccagaauuu\n", + "auucpccgcggcggccgcupugcagccgagcgguguggagcggagagaauacucgaapcucuccugauacuaacaguuuuacgauuuaaaacuucgccagaauuu\n", + "cggccgcupugcagccgagcgguguggagcggagagaauacucgaapcucuccugauacuaacaguuuuacgauuuaaaacuucgccagaauuu\n", + "agugguguuugcuuucuccaccagaapcacacuuucaucuaauuupuaucacugagcugaagacaaagagaapagaaaaccuagcagaccacc\n", + "uguggccaugaaaacuguggcaaacgaugugcgguagguccuccugcccugguggugaaaaugacuccuaagauguagcuguggcacucuguggcucacuuccugugugucugcuuuucccuag\n", + "paagcagcacaucagcgacagcuccuggcugcuggacuccgcapapaaggaagauuggucgca\n", + "ggugauacguuugugccacaugaaacauucucugccucugaaggcuccagaggcugupaagcagcacaucagcgacagcuccuggcugcuggacuccgcapapaaggaagauuggucgca\n", + "auucucugccucugaaggcuccagaggcugupaagcagcacaucagcgacagcuccuggcugcuggacuccgcapapaaggaagauuggucgca\n", + "guaggugccgcaaggagccggcgagcggagcgcccgcucpaccgcagccgccpcgacgucgccgccgcaccpcacuucugucuccccggagcag\n", + "cuccuccagcucagucuccagcuccaccuccggcucccgcupccucccgcucgcccuccgcgcccggcuccccgcgcgcccgucccgaguccgcugcucgccggcggccgcccggucaugucagg\n", + "uuucaccagaguaaacuugagaaaccaacuggaccuugaguauuguacauuuugccucguggacccaaag\n", + "auugaapuaaaauuuuucaccagaguaaacuugagaaaccaacuggaccuugaguauuguacauuuugccucguggacccaaag\n", + "ggagcucuucacccaguguapuaugguuugugaagguaucccuagagaaggugacucugcggcugagcuugaaggaagagaauugguaggugacaaagaagag\n", + "agaggugcuuucucucuggacaguuuuaugaauacauaaggagguucuguccccacucccuucgcaaccgcaucuuauug\n", + "ggcuguccucucaccguccucaccccgcgaggcccggcccgcuccuccgucguggauuucgcggcgauccccccggcagcucuuugcaaagcugcuugaaacuucucccaaacucggc\n", + "aaccuuucagcucuupcauuggugagucucaguaaugcacgucucaguuccaucaaaacucg\n", + "guuugapccugugucugcugucccugcugguapagagccccacagagcuauuccagcagcacugugugucuuggcuucggagcauucagcagguguuacag\n", + "uauccgugucuccacacccucuuuucugccagguaguggcuuggauggucagacugacauuaaccguggcauuccucagaag\n", + "auaauggaugaguucaguguccauucagcaagcauuuauggaugucuccuauuaggugcugcccagacauauagag\n", + "acaggcagccucauccgccaucacuccpaaccgagcaccccgcugccucggcgcccaggcugcucucuccgcgc\n", + "gcaucaacgaaaggagagaaggaaaauuuagaauuacaugauuugaagaaacagugugcacuuuguccucaugguguuuguaaauuaagauucauuuuauaua\n", + "guauaaagaaguaucugcagaaauccagagcacuuauuaaacuucuuugaguuuucucaggaagaucaauaccuguuggagaaauuuuacuaag\n", + "uuccugcagguauaaagaaguaucugcagaaauccagagcacuuauuaaacuucuuugaguuuucucaggaagaucaauaccuguuggagaaauuuuacuaag\n", + "aaaugguucucuuuacugcgaggcugcaaggucacccaaugagagapccaaauaagcuggaacaucaucuaauacacugaauguag\n", + "agcaagaaacugagagugagaaagaapacuggccagaguuacucagcuagacagugacagacaacaguggaacuucug\n", + "gcccggauugcauuucuacaaggcgaaagaaaaggucaagagaaccugaagaaggacuuaguaagaagaauaaag\n", + "uuguauuucpcccuaggcgcgcgagcggucagcauccggaaucuggccccugcaggcgupuuccacgupag\n", + "gagacuugaaugaaaauucuguggagaaucuucagcagaaaacacuucaggaucuguuacaugagcuuuccuccuggcuaguuuuggaaggc\n", + "gaaccaguuacauucaaggaugccucuguggccuucaccgaggaggagugaggucaccuggacucugcucccaggaagcugugcggagcugugaugcupcaacuacagaaacuuggucuug\n", + "guauuucpcccuaggcgcgcgagcggucagcauccggaaucuggccccugcaggcgupuuccacgupag\n", + "pugugacguacauccggcgaguagcuggcggucccpugcugcugguuagugugcucugapapuccgagccagccgcuguuuugccggaggagccccucaggcc\n", + "ggcugcuuccaaccuucaauuuguaaaaaaaccagaaaaccucaggauccacaaaguaucaucaaaugag\n", + "guacauccggcgaguagcuggcggucccpugcugcugguuagugugcucugapapuccgagccagccgcuguuuugccggaggagccccucaggcc\n", + "acauccggcgaguagcuggcggucccpugcugcugguuagugugcucugapapuccgagccagccgcuguuuugccggaggagccccucaggcc\n", + "guucaagcguuucuccugccucagccuucugcauagcupauuacaagcaagcgcugccgcgcccagcuguucauuuuauucuucaucuggcauucuuugaau\n", + "agaugcaggucucucuauguuacccaggcuggucuugaacuccugaggucapaggaaucccccaccucagccuugcaaaaugcupauuacag\n", + "gaguuugugagaguccuugguggaggagguuggaaagcguucucccucccacaaaacccggugcagapapagagccagguccguagcgupuccaagaaacu\n", + "aacgaaauaaagaauuuugaaapaaaaugaguaugaauccacacuuugugaagaugcuuauggcacacuagacaauuuguuaaaug\n", + "auaacaacauugaaaauuacucaacgaaugcacuaauucagccaguugacaccaucagcauaucuuccuugagacaauuugaaaccguuugcaaauuucacupuagaagcauuugaugaugaa\n", + "agguaucccagaggugacagaacuugaucupccuggaapaagaauucpaaaagcaacgupcauuccag\n", + "cuggapaaauugapagacuuggaaaccgcgccaggcccaacpuaccuagaapagacaaagccaggccugcugcccaguuugagcucupaagaagaggagcaggccpacgcccaccg\n", + "gacguucauguauuugcuuuggaaugcaaaguaggagauggacaacguauuuaccuugugacaaccuaugcugaauuuugguuuuacuauaaauccag\n", + "aaaaaaucucuuacacugcuaugaaguuauuccugaaaaugcugugugcaagcuuuauuuugauuuggaauuuaacaaaccugccaacccaggagcugaupaaaaag\n", + "agcugcggcugagcccagcgcucgaggcgcgaggcagccaggapcccgugcggcgcpagccagcgagcgcgccuucggcauuggccgccgcg\n", + "ucgccgaggcugaucuucguucaagugugagcugcggcugagcccagcgcucgaggcgcgaggcagccaggapcccgugcggcgcpagccagcgagcgcgccuucggcauuggccgccgcg\n", + "cuagguuagacgguucaagaccuggagacuggcuuugagcaacccuaggauuaccuuggcuugaauuccauccaauacgucucuuucuucauauauug\n", + "gauacaguccccucgugcccaaggagacapugguuacagacauggaaaaucugagaauaaucaccucugauaaagaucacagaagcugcccpagguguuug\n", + "auuaaauucauguauugaaaauauuguucagaccccaugugacauaacuggagccagugcagugccaugaagaacuacgagauuagccuggauauuaacuugucuucuagagaauagauuuc\n", + "agucggapagaacaccaggcgcggcgcpcggcuccggcuccggccccggcccaggcccpagaggcg\n", + "pcagugupapagaaguccapcggacaggcupcgcacccgugcucgcgcaccccaag\n", + "pcagugupapagaaguccapcggacaggcupcgcacccgugcucgcgcaccccaag\n", + "gugcgcuugguaauugcugaaaaggcauugaagugcgaggaacaugauguaagucugcccuugagugagcacaaugagccuugguuu\n", + "ccccgcuuccccgcagccpcagagcccaccgcaccagcucgcggagcagccgagccgcccguuacgccgcucaccuccgucccc\n", + "auucacaccucagaagccuuauccuucuuuucaaucaaacccauaaauaccacagacucuaauagcc\n", + "agagcucucggacuuucggaagcucucggugupugcgacccgagagaaggagcpcuggupcugcugcagccg\n", + "agacuuugaccaaagaaguacacuggaggcacaggaggaauuuaacauccuagaaacuuuagucugaagaggauccc\n", + "gcagagcucucggacuuucggaagcucucggugupugcgacccgagagaaggagcpcuggupcugcugcagccg\n", + "gcgcgcpcgugucggacccgcagagcucucggacuuucggaagcucucggugupugcgacccgagagaaggagcpcuggupcugcugcagccg\n", + "agccggccccgcccccuggcgcgcpcgugucggacccgcagagcucucggacuuucggaagcucucggugupugcgacccgagagaaggagcpcuggupcugcugcagccg\n", + "gacagcuguccaauggaggcccuccgugcuaguacggcuugcggcuuaagcgccgccgcggucugcggaaugucaacuauucaac\n", + "gucaacuauucaacauggaggcggaggucgauaagcuggaacugauggugagugcaaagugaaggagaucuacupuaguuuauuuuuccccc\n", + "gccgcggucugcggaaugucaacuauucaacauggaggcggaggucgauaagcuggaacugauggugagugcaaagugaaggagaucuacupuaguuuauuuuuccccc\n", + "gcggaaugucaacuauucaacauggaggcggaggucgauaagcuggaacugauggugagugcaaagugaaggagaucuacupuaguuuauuuuuccccc\n", + "gacucaacuauuguuacuccaauuauuuugaggacugacccucapauuuuucuuuuacuggacagaucaaaacaag\n", + "gagacagagcuacuggaucucagccuugucaaagaugccagaugupagacacgccaaagcucccaag\n", + "gcpagcagagucgagcgccuccggagcagagaaaggagcccgcgccccgcgccccgcgccccgcgcacgguccccagucccugccgcgcucgcccpccgcccggagcccagaugagcccag\n", + "aaucaagccupcaauggcpcgccccucccccagccucgcugccgccuugcaguuugaucucagacugcugugcuagcaaccagcgagacuccgupcguaggacccuccgagccag\n", + "aguuugaucucagacugcugugcuagcaaccagcgagacuccgupcguaggacccuccgagccag\n", + "gcuugucccauggccucucauagaaaucauggaccauggaagaacaagaauaugguagacaugaaggaaauguagagg\n", + "gcucagacgugcagcuucuggaauacgaggcgucagcugcuggccucauccgauccuucucugagcguuucccagagg\n", + "auuccgaguccgaaaggucccugaguagauuggaagcagugacagcacgcuccuuugaagaggaaggagagcauuupcaguagaaaacacaga\n", + "aucauuaaugaauggagaagucuucugaagugacaccagugccuuaucccuagaggaauaucagcauag\n", + "guaugaucucgugaaaccuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugag\n", + "gaaccacagagcpuaugccuaguacapcacggcagaggccuugaaugcugugcacagcuuuauugccgagaagguccgagaaaucccacaagcg\n", + "gcaauccguacccucagupuucccuuucagupuuccuuuguccccaggcccauuauuccguccuccccucuucccugauguauuuuggcgcggucuccuggcucugcpcccapcuccgg\n", + "cucccccgaagccgcgcgcccgcgcccgcgccccucagucgguggagcccgcagccccccuuguggcccgcggcagcuccccgcccgcucggcccgcgcccgcc\n", + "ggaggcugcuugagcaagcuagucauuguucaugcaacacaaaacauucccgccccuaacgccagaauggagcuuccagaucccuuuuuuuuuuuuuccuugauugcuaaaugagcuuccaag\n", + "gaaacuuggcuguaacuucaaaagaagauuugauucuuuauuucuggacugcauauauauauauaacaaggccauuaaa\n", + "cccggccccccgcgcccccgcgcgccgcggcuccuguugacccgguccgcccgucggucugcagcgcggcugag\n", + "cgucggugcccggccccccgcgcccccgcgcgccgcggcuccuguugacccgguccgcccgucggucugcagcgcggcugag\n", + "apaggcacaggcgcuugcuuugcaggagucagcucugccuuccucggcuggagugupuggcuuggugagccgguggucaggaauucucucuccuccuugcaauuuuccuuucugucugg\n", + "gcaggagucagcucugccuuccucggcuggagugupuggcuuggugagccgguggucaggaauucucucuccuccuugcaauuuuccuuucugucugg\n", + "uccguggupagcggcagcuggcagagagucaacgcccagacggcugugagauccccgagauaugccguguuugaccuc\n", + "ucauugcggcuggcguucccaauacagacgcaucguuucuuuuuuaauacucccuaagaaapaauaaccuucaagcuggcpagca\n", + "ggcagccugcggagccacuggccaagcupaaguccggcgcaacuccgcaccgcagagccggcgccuccucggcag\n", + "uucuuuuugaggaagacgcggucguaapcugaggauuuuugguccgcacgcuccugcuccugacucaccgcuguucgcucucgccgaggaacaagucggucaggaagcccgcgcgcaacagcc\n", + "cuuucuuuuugaggaagacgcggucguaapcugaggauuuuugguccgcacgcuccugcuccugacucaccgcuguucgcucucgccgaggaacaagucggucaggaagcccgcgcgcaacagcc\n", + "ggcgcaacgcapcucpcgccppaccccgguuucgaguucgugcuccugapcagaugccpcguguapcggaaaggcgcuccugaa\n", + "uuucuuuuugaggaagacgcggucguaapcugaggauuuuugguccgcacgcuccugcuccugacucaccgcuguucgcucucgccgaggaacaagucggucaggaagcccgcgcgcaacagcc\n", + "ggaagacgcggucguaapcugaggauuuuugguccgcacgcuccugcuccugacucaccgcuguucgcucucgccgaggaacaagucggucaggaagcccgcgcgcaacagcc\n", + "cuuuuugaggaagacgcggucguaapcugaggauuuuugguccgcacgcuccugcuccugacucaccgcuguucgcucucgccgaggaacaagucggucaggaagcccgcgcgcaacagcc\n", + "acaggcaugaaccacgaugcucagccccuuagcugaacuuuuaaacagagauuucuucuauuucagacagacacugagacugaggcacccauucc\n", + "cucuccugcagccgccaccgccuccgcgaucgcaaacccggaagacguguucpcagcuggaguguacpcccgcpccacggcc\n", + "acaaagcucaaaggacuguuuaaugaaaggcucagaggaucauauacuggaaaauuuuuccacacacgcu\n", + "uggaagccgcugaacaucccgaggaacuggcacgcupcucupcuuguggccgguagaggauucccgcucauuugcaguggcucagaggag\n", + "auagugagcggcagacagapuggccaguuuguuguuuuaccuaaaagguguuuuccacguggagupacugagaggcacagguggcugapacccgccupaugugaggcgcag\n", + "cccaagcuucacuacuucaauggacpcagaauggagcccauccgguggcucuuggcugcagcuggaguggag\n", + "uaacugapcaaacccaucagacaaccagagccauaauuuguggucaccgcugaaauuuaccuuggaaacucg\n", + "pupcagccccgagcagcagugcuaaaggagcccggcggaggcagcggupuuupacugaggcgcuggaucuguggucgcggcupacgugcgcccgcgccaccaucuucggcugaag\n", + "guuupacugaggcgcuggaucuguggucgcggcupacgugcgcccgcgccaccaucuucggcugaag\n", + "ggucccccgcagcaccagapuucaccaupcuuggaaggcpcggcgcgcgcccgacccgupuggapacaggapcauuggcucugcgcggccpaagcgcgcggcgg\n", + "agcagugcuaaaggagcccggcggaggcagcggupuuupacugaggcgcuggaucuguggucgcggcupacgugcgcccgcgccaccaucuucggcugaag\n", + "pacugaggcgcuggaucuguggucgcggcupacgugcgcccgcgccaccaucuucggcugaag\n", + "acucccucgcguucgcugacgaggaagguccccauaccgcgaaguacauuggccuupupcuggapaupcgccugugagaaugugacggacugugacacaaggaagg\n", + "uuccauggugacpcgccaggcuapcggccuggccacugagccpugcaguggcagcpagaguaccuggcgauggcgau\n", + "caaacgccuggcgcccuccgucgcccgguuuccauggugacpcgccaggcuapcggccuggccacugagccpugcaguggcagcpagaguaccuggcgauggcgau\n", + "uggugacpcgccaggcuapcggccuggccacugagccpugcaguggcagcpagaguaccuggcgauggcgau\n", + "gugacpcgccaggcuapcggccuggccacugagccpugcaguggcagcpagaguaccuggcgauggcgau\n", + "agupaagguucgcpuupagacccggaggccgaggaapcgagcagagcacugccaggauauccugcccagauuucccaguuucugccucgccgcggcacag\n", + "ucuuccucuccupccguccucugagcagcagacpcuaagcguuccccagcucgccuucacacacagcccgugccaccacaccgacgguacc\n", + "cuuccucuccupccguccucugagcagcagacpcuaagcguuccccagcucgccuucacacacagcccgugccaccacaccgacgguacc\n", + "uccupccguccucugagcagcagacpcuaagcguuccccagcucgccuucacacacagcccgugccaccacaccgacgguacc\n", + "ggcccucacuucauccggcgacuagcaccgcguccggcagcgccagcccuacacucgcccgcgcc\n", + "ggacgaguggccgacucuggagcccaggcuguugcuucccagacugguggugaauccuccauagucug\n", + "acuauuuaaucagcaggcagaucaacaggccaaaauuuccaccauaacugcaaacuugaaugcggaugaauggauuacaacauggucaaaccuugcaaugagaggcauuauaau\n", + "ccagacugcgccgaagcuucaugagaccucuccucgucugugcacggacgaguggccgacucuggagcccaggcuguugcuucccagacugguggugaauccuccauagucug\n", + "gaagcuucaugagaccucuccucgucugugcacggacgaguggccgacucuggagcccaggcuguugcuucccagacugguggugaauccuccauagucug\n", + "cgcgaguccpucgccgcagcccpaggagugucuggucuccggccugccugugcuguccccgcgcccuguccacuggacucccgagacccuuggaacccag\n", + "guguuccaugagcaaggcauccuguucggcuaccgccauccacagaguucugccacugccugcauccucagccuuuuccaa\n", + "ggaagcggcacagcaccagcuaggcagagacgccccaggccauguuagagcuuugagugaggccugguaacapaggcgcugucaccuacuggccuugccaauccagcuccaag\n", + "ucucucucggcguuuccgcugucapcccugcggugugacucgcpcucagcugguugguauuuuuupccucgugcuucguggupagacccaggucgag\n", + "auugagacuuucuccuugcuguuggccucucauacuuupaaauguugcuaagaucuaguuuag\n", + "gccauuguugcugagcgaggaugaagaagauaccaagagaguuguccgcagugccaaggacaagag\n", + "ugauccguaugugaaacuuucauuguacguagcggaugagaauagagaacuugcuuugguccagacaaaaacaauuaaaaag\n", + "cgcapuapugcpaccppaccuggaggcagapagaaccggccguccgcgccgcagcacagccgcupagcgccucagaccccgcgcpcgccggcucc\n", + "cuucugcuccauugcuguugaacuuuuuuuuggucgugacaucagaaaaauaaccaagugugagucugauaauagcaa\n", + "apaaacagaccaucugcaucuagaccugccucucucuccgcuccccacuucagacgagcucuuccugccuggaaucug\n", + "aggcugccuuagacaaaggcugagacpagcuccugaugauuuuuaugapaagaggagauggugaggaggapcaccgagcaugugcagcaacuugaagc\n", + "aucuggcpugcgcgcucaggucuggcuccccuuucgagaggugaauuuuacaacccaagaagcauuacucagcapag\n", + "agucccguauucucagaguaaaaguuguuucuggaauugaucucgccaaaaaggacaucuuuggagccag\n", + "pugcgcgcucaggucuggcuccccuuucgagaggugaauuuuacaacccaagaagcauuacucagcapag\n", + "ggagagucccguauucucagaguaaaaguuguuucuggaauugaucucgccaaaaaggacaucuuuggagccag\n", + "cuggugaguuuucgaggugacugugcugugcucggugapacgcccagagagcccugacccpucacuccgucgccguucuccucuugucuacgugcuggacccg\n", + "acgcacgccaagucuucagapccuggaupugugacuccaaggagcuaaucgucccgugcag\n", + "ppuuuguupcuggugaguuuucgaggugacugugcugugcucggugapacgcccagagagcccugacccpucacuccgucgccguucuccucuugucuacgugcuggacccg\n", + "ugaccugcuaucguguuggaggcuuugcuuggagucaucuucagucuuuucuguugacuuuaccuuugaccagugauuaaauccuccag\n", + "cugugcugugcucggugapacgcccagagagcccugacccpucacuccgucgccguucuccucuugucuacgugcuggacccg\n", + "uguuguacauuauaaaccpcugcugaugaggagupaacuggcucucuggaacgugugacagcaggcagaap\n", + "ggcaauuugcauauuucuccaaagaaccauccagaaccugagcagccugucuucagacagagagaggcccacggcuguuucuugaaaucugg\n", + "agaacucuguggaugaaccuugaaggagccuccaagccugaaccaaagcacuacagaucaccugcuaucuucauagcacc\n", + "aguuacaccaggcauccuggcccaaaguuucccaaauccaggcggcuagaggcccacugcuucccaacuaccagcugapuccgucccgagaapagaagaggccgaagaggaaac\n", + "auacgauguacuuuuuuuaaugccguugaaacagaguuaauuuccuuuagcacacaagucuuagagacaaaagaaaaaaag\n", + "ggcgccgcgaccagapcccagagaagcggccggagcccgccuaccucggcccccucagcuucccpcuggcaggcggcuagaggcgucugaggaag\n", + "cccccaacgucguuuuucugaaaauaaaauacucugagccgaacguuucgaagaaggaaaguccgcccuuaagagagagacagagucuug\n", + "ggcagugcuucagaauuacacaucacaupagcagcaugcucccacugugccccagaagaguuucccggacaguguccagagaaucuguucg\n", + "gucacccugguggauaaagaccuccugaaauuucuaaagcuggaggaguugguacugagcgccaaucgaaucaaggagguggaugccaccaaucugccccccacacucaag\n", + "auugugcgcagcgcugcgcggcgccggcggccgccgaggccupuggaaguuggcgcugcugccgccgcccugcagcccacucgcugccucggcagcgcgcugcucuucuaag\n", + "gccgccgcugcuuccaaucucaguccuccuccucuuccapccgucugccpaucuccuccccuucuaaaccugguccuccagcggcucuggcgccuug\n", + "gugcggugcagcaggucgguaggcpaaauggcgacuggcugaaggagcugguucuguugcugcugcp\n", + "gguggcggcggcggcagcpuucgguugcgcguggcgcacpupagcggagcccaggccpagcaggcgccgccgcca\n", + "pcgacggugguggcggcggcggcagcpuucgguugcgcguggcgcacpupagcggagcccaggccpagcaggcgccgccgcca\n", + "ggcggcggcagcpuucgguugcgcguggcgcacpupagcggagcccaggccpagcaggcgccgccgcca\n", + "gupuaacgaggagcagcgcapuucgcagaacagauuagaauucucccgaggcacucupaapccagcacuuccgguuuuag\n", + "uucuuuugaaacagauggucaccauguuuagauauuagcagucccauauaugcaugucugcauuugaaa\n", + "gcggcapccggaaggagugcagcggcugccacggagcucgcagcugcggcuucugaggaguaagcggcgcgguagcgaaggccgccgaaccugccuggcuagccggcgacuugagugacga\n", + "agcugcggcuucugaggaguaagcggcgcgguagcgaaggccgccgaaccugccuggcuagccggcgacuugagugacga\n", + "agugcagcggcugccacggagcucgcagcugcggcuucugaggaguaagcggcgcgguagcgaaggccgccgaaccugccuggcuagccggcgacuugagugacga\n", + "ggccuauucccugguggauuccagucaagugucuacauuucugauuuccauucuucuuauagucuaugguaguuucag\n", + "gcauccaaacaauugacucuacccaggcucuguuccuuccaauuggagcaucugucucucuuuuagua\n", + "aggcccuggaugguugaaagaauagaaaacucaguggucaagaaaupaaaaugaaaauguuuuacuag\n", + "aggcggucapaaggcucaggaggapagaucaacaucaaccugccccgcccccuccccagccugauaaagguccugcpcaggacaggaccucccaaccaagcccuccagcaaggauucag\n", + "uuagagauguuuaugauuacuuccgagcuguccugcagcgugaugaaagaagugaacgagcuuuuaagcuaacccpaugcuauugaguuaaaugcagccaauuauacagugug\n", + "gaauccaaccaugauuacauuaugagcccuguaaguuauuaauaucaauguaacuguaauuauugucauuuuaaaaacacuagagucccuuuucuucuguauuugaauguaaccacugguupa\n", + "ggacagagcagaaupcugauauagauccggugccgcagaaugauggccccaaucccgugguccagaucauuuauagugacaaau\n", + "gauacuuuguggapuuaugagagaauugcaggcapccccagcaccuagagcccaupccagcugacccacaggaacaaacagagaauggcguugaguggcagaugcugaggcacuug\n", + "acagacaccuucaccaucuaugccauugaccupcccugaccaagauucggauucgccacgacaacacaggcaacagagcaggcugguuccuggacagaauagacauuacugac\n", + "cagcaguagaguggugauaggaaagauggcaucupauacugugaaucucugagucucacggugcagccaaugguguccacacaauacccuccuuaacugaaaaagccuggapcaagag\n", + "pcupugacguuggaggaugagagupcuggcugugacacuggaggaugapcgagcuggcugugacauccgagg\n", + "auaaaucuaccacauucucagugaccauaaagacupuuaagaagaaugcpcacagaugcuaaugucuucaucacacucuuuggcacacaggaugacacug\n", + "ggacaaggccccagccgucgcpuugccpcagagucggacgccgccagcucuucacuccacgcccaccucucuccuggagcgcupccuucgcuggccgcaccggcagcc\n", + "ggcagagucggacgccgccagcucuucacuccacgcccaccucucuccuggagcgcupccuucgcuggccgcaccggcagcc\n", + "acgcggugguacaugccuguaaucccaacacuuaggcaggaggaucacucgagcccagaagaucaagacuagugugagcaacaaa\n", + "aucuccugcaccgucgapcacccgccagcuuuggcaagagcuucgcgcagaaaucuggcuacuuccugugccuuaguucucupcagccuagag\n", + "aacccgcaggagaacgugguggccgauauccagaucgugguggacaagagcccccugccgcupcuucucccccgucugcgacccc\n", + "guaguucggucgcgagcgcugccgucpaggcgcuccgagguucgaggcugugccccgcgaccccgccuucggcgcucggcucgcagg\n", + "auagaaaucacugagaaugaugcuaagagcagcpagcggccgugagcccagagcuaaaauuapagaagagaggagucaugaucupucagcagaugacgcaugaagcaag\n", + "gccggucccpcccccupccacgccgaucacpagccccucgacugccucccagaacaaagupaaapaagcuuagcccgccgcugccgccuccgagcagcccgccag\n", + "cgcgagcupcugcagcucugucapccacpccacucppcpugcaucagccapccggagcuacgacacggaucaaggacgaguguucgugaaagugaaccccaaggcggag\n", + "gcagcucugucapccacpccacucppcpugcaucagccapccggagcuacgacacggaucaaggacgaguguucgugaaagugaaccccaaggcggag\n", + "ggagaggaggupcaggaggaacggcccuuuguggcccgguuuggauuugacguggugacgugcuguggauaccucccccag\n", + "gaauguaguaagaaaacaaaaacugaugaccaagagaaugugucagccgaugcaccgaguccagcccaggaaaauggagag\n", + "aapagaauuccacaaguuggcugaugccaagauauuuuugagcgacugccuggcaugugacagcugu\n", + "cgucpaggacaacaaapccgcpcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccag\n", + "pcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccag\n", + "gcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccag\n", + "aacaaapccgcpcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccag\n", + "aacaaapccgcpcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccagaugaagugugagcacugcacgcgcaag\n", + "uaagaaaacaaaaacugaugaccaagagaaugugucagccgaugcaccgaguccagcccaggaaaauggagag\n", + "paggacaacaaapccgcpcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccag\n", + "gucpaggacaacaaapccgcpcggcpcaguggugucccagucucccggugcuucccugaggcugaggcgcccggccucccgcccgccgcgcuccag\n", + "gucuaagaggcagacagauacauuguucuucacuggucagcugaaagucaauucaucaucagugauauucaaaaaucacaagucuuugcuggc\n", + "aaagauucuaaggucccagugcuuucgcuucauccuagaggcuaaaupcuccccuggacucgccuggcagaacuaaccaccuagaagaacguuauuguaapaaau\n", + "gcuuucgcuucauccuagaggcuaaaupcuccccuggacucgccuggcagaacuaaccaccuagaagaacguuauuguaapaaau\n", + "agugcuuucgcuucauccuagaggcuaaaupcuccccuggacucgccuggcagaacuaaccaccuagaagaacguuauuguaapaaau\n", + "ggcaccgcggcugcpcuucugaguucccggcucuccgcapaagccuccucuucguaccucguuuuuuggcucguppuccucccaccgcuggccgacgcagccagc\n", + "gcccpcpcugucaccgugaggcpcggcaggcugcpagucaagccccuccaggagcggacugaaggccccgcaggugaauggagaguagcagccpcccag\n", + "guguugagcgccggcggcucgcgcccacgcupccpagucgaaaugcuucccggugccpagugagcg\n", + "gguguugagcgccggcggcucgcgcccacgcupccpagucgaaaugcuucccggugccpagugagcg\n", + "cucgcgcuguuuccgccucuugccuucggacgccggauuuugacgugcucucgcgagauuupucucuuccuaagccggcgcucggcaag\n", + "ggcggccugcucuccgacagaacuuuucuucuupuugaggaaaacgccuuuuggagucaggcccuggapcgagccuugcucacagg\n", + "cucuuccuaagccggcgcucggcaagguagguuggcggccugcucuccgacagaacuuuucuucuupuugaggaaaacgccuuuuggagucaggcccuggapcgagccuugcucacagg\n", + "agacaggacucguggagacauccaggugcugaagccuucagcuacugucucaguuuuuugguaagaaaaccuagaccuaccugaugacuugugcuuagccuguuuugcucauuauag\n", + "acuguggcuaagugupaccagacaggacucguggagacauccaggugcugaagccuucagcuacugucucaguuuuuug\n", + "aaguuggugcugugcuggcccapcapupacugagagupucguupaugaggagaccauggaggccuaapccucucugugccccaggacagcc\n", + "cucggugacucggcccggcaaccaugccapcugaacuagcugacacapaggagccccgaaguggaagagagagagccuccuuucacuuucccuaccccucaggacacacag\n", + "ccggccgcggcggacacuucccupcpacugucucguggcacccgguggaaccgaggagaacguggagcgccpagcggcgaau\n", + "acuucccupcpacugucucguggcacccgguggaaccgaggagaacguggagcgccpagcggcgaau\n", + "ggaguaggagacagcgccuggagguggapcgcccapccgagcugccapccggacaccuaggcugagcccucag\n", + "aggcucggaccggcccgcggagcugcugcaguccuucgcgcccuccucgcccuccccaccgacauc\n", + "ccccgcgcaupagguaggcucggaccggcccgcggagcugcugcaguccuucgcgcccuccucgcccuccccaccgacauc\n", + "ggagucgcggcgcgcucgcuccauuccupcucggcuacccccugcccuucggcaccugccgcgccgcgguccccggcuccag\n", + "paggagapcggapcggapaacuugcaccgaagcaucacucgagaccccaaaccuccag\n", + "aaaugcaaaugaacucccuccagcuuagcuuucacccggugguguucccpaggagapcggapcggapaacuugcaccgaagcaucacucgagaccccaaaccuccag\n", + "gugguguucccpaggagapcggapcggapaacuugcaccgaagcaucacucgagaccccaaaccuccag\n", + "agcucagaguggacccuggcccgcugugaccacgccuuuugcupccugcuggaggaguuggucaccguggcccacuaugacagccccgaggcccugagccaccucugcugccgccug\n", + "guucagcgauacccaggccacgugcccaacuuccugagccagacccapcuaccugcggaguccacaggacccccugcgccpcagccgccgugcuuauag\n", + "gcuuccuuguccaccacgccagccccggcugugucaaccaggaccugcuggacucccuguuccagg\n", + "accuapcgacugcagagcgaccccaagccggcuguggccgcggcagcgcacguguccgcucagcagguggcg\n", + "gauguucguagccaauccgcaggcgcgguggcagcugcpucgcpucgcpucgcgagucgccggucgccggucgcggcggagccupcgcugag\n", + "aapacuuggapaagcpccuggagcugcugccgccgccccugagcucggacgcgaaggcuggccccguccccpcugccgccgugguccugcag\n", + "guugcagauaucaagaaagucaacaacuucaucagagaacaagacuuauaugcuuugaaaucuguuaagauuccagugagaaaccaupauccug\n", + "cgcgguggcagcugcpucgcpucgcpucgcgagucgccggucgccggucgcggcggagccupcgcugag\n", + "ugaagaaaaugaggcacgaggaauuguuaaccaagaccuuccaaggcccagcuguugugugupacuccgaccagccacguauacauguuuaaga\n", + "guagccaauccgcaggcgcgguggcagcugcpucgcpucgcpucgcgagucgccggucgccggucgcggcggagccupcgcugag\n", + "ccggaagugcggaucccagcggcggucguguagcugagcagcccupcuugguucuaugucccugugg\n", + "acucpccccgcguccugcucccauggccgcccccggcuccccgcgcugcccccuuuaccccpccgcgccccpccccgcacugacggccc\n", + "pucgcgccuggccupccgaggcggcgcgcggcgcugacagcugagucggcucgcggccucccggcccccucggcgcccggcccgacccuggccuggccugcccugccccggagcc\n", + "cacagccgcagcagcugcupcgcccaccgcgcacagcupccccacaaacgugauggcagccacagcccuuucag\n", + "uuuccuucuaggacaccuccccugcuuuuggaaaaaggaugagguugguggccgugugcuccaagauguguuuuuggauug\n", + "ggcuaagaaguauggaccuguugugcpucaacgucuuccacaaaaccucagucaucgucacgaguccugagucgguuaag\n", + "cgccuggccupccgaggcggcgcgcggcgcugacagcugagucggcucgcggccucccggcccccucggcgcccggcccgacccuggccuggccugcccugccccggagcc\n", + "agugcgcggccagguacpccgacpcccgcpccggcgccgccauggcggccguguuugauuuggauuuggagacggaggaaggcagcgapcgapcgagccagagcucagccccgcg\n", + "gccugupacacuaugaagagguggagcugacugagaccagcgugaacguuggcccagagcgcaucpccccacugcuuugagcugcugcgugugcupcaappcuauggcaag\n", + "guguuccaggugcgaaaggugcaaggcaccaacuupcaaaauauaugccaugaaaguccuaaggaag\n", + "cuucuaccuggcugagaucacgcuggcccupccaucuccacucccapcaucaucuaccpaccucaagcccgagaacauc\n", + "ugcggcggcggcpcpcggcggcgcgugaggcgcgcgauccccggugucuupagcagugccccggcccccgccgcucccgccgccgcc\n", + "gcgacggccgcugugacgcugcggcggcggcpcpcggcggcgcgugaggcgcgcgauccccggugucuupagcagugccccggcccccgccgcucccgccgccgcc\n", + "ggcggcggcgcgugaggcgcgcgauccccggugucuupagcagugccccggcccccgccgcucccgccgccgcc\n", + "acucgcccggcccupcggupaggcggcggcggcggcggcgcucgcgcaccucggaggagccaggagccggaaccapccgagcccgcpccpcuagccagccg\n", + "cpaaaaacpugcggccgccuccuguguccuacapcgccagacgcauuuccacucggcuuggag\n", + "augccaagauucgcauuuuugaccupcggaaaaaggcaaaaguggaugaguuuccgcuuuguggccac\n", + "ggagccgaguccgcggcggccgcgcaggapaaaguucagcgacggcggcagcggccggagccpccpcagcuagcapcgcuucgg\n", + "cugccuuccuauuucaaggaaagacgccaagguaauuuugacccagaggagcaaugauguagccaccuccuaaccuucccuucuugaacccccag\n", + "pcuuguucupauccgcagccuugcucaggcugugcauugguguggccccgaauugcacggag\n", + "ggccucccaguggccgucapucccugcagacaucgcuuacccacaguggugcggugugagaguuacapuuccugaccuucgcu\n", + "aggcuccgcggcugccggagcpagguggagccgaguccgcggcggccgcgcaggapaaaguucagcgacggcggcagcggccggagccpccpcagcuagcapcgcuucgg\n", + "acauaaapagcaguaggcauaaaaugupagcugaccaucugccgguccgguccugaccuuccacuaguagugagaccaauccagcucuugcugcugcuguggcuuugugaggag\n", + "pagguggagccgaguccgcggcggccgcgcaggapaaaguucagcgacggcggcagcggccggagccpccpcagcuagcapcgcuucgg\n", + "auggagucaaguucuguugccupcuagagugcaauggcacuaucucugcucccugcaaucuccgccucccaggcucauacgauucuccugcuucagccucccaaguagcupauuacag\n", + "apucccugcagacaucgcuuacccacaguggugcggugugagaguuacapuuccugaccuucgcu\n", + "guuguuucacuuagcauaauguccuccagguucauccuuguuaucacaaauggcaggauuuucuacuuuuuuaag\n", + "gagcuaccuucuggaguuaccugacuuggauugucuuggugaauagaucagaaaggcaguaaccuccuacuagaugaaucccupugcug\n", + "acugcaguuuaaugccuauuggaggaagaaacagcgugaugugugucacagaccaccccacgucccuccuggucacupaagacuauacuuuacagucccucuccaucuag\n", + "agaugcgcucgguccucaccagcggcguugugcggcgaacccugcggugcuucpaaggcggucguuccucccugcucccaccguuuuccagc\n", + "cuccuuagguggaaacccupaguagaguacugacagcaaagaccpaaagaccauacguccccpcapugacaacaggugucaucuuuuugaucucgugugugg\n", + "aauuuacccugugcagaauuuugaguuucaugauuuuauauccuaggcuucuauaauapuaucagaggcgaauggaaucauuagaggagauacagaguagaug\n", + "aaacaauuaugagaaaagugaaugaaauaacauuauaguaacuuuauaacaauuagcuaaagcaucccugcacaacuggagaaaacug\n", + "auggcaucucgcugugcugccuaggcagaccuugaacuucuggacuuaagcgauagauccuccaccucagccucuugaguauuupacuacag\n", + "ucccugagcgguggcagaccpaggupaggcggacucccuccgucapccgcaugugcuguggucuuggcgaag\n", + "cccccagcupacggcccaggcgccuauaaapuccccgcuuggccccggcgccacccaccacc\n", + "acucccuccaaccgccacaagcagcaaapcauagaugaccacaggagagcccuapaggccggcuccaccagcagccccauac\n", + "aaguuuguuccccgaguucggagccuaggagccccccgcggcugcggcgcaggugcccucggccugagucp\n", + "pcpcpccpcaaguuuguuccccgaguucggagccuaggagccccccgcggcugcggcgcaggugcccucggccugagucp\n", + "gcpccpcaaguuuguuccccgaguucggagccuaggagccccccgcggcugcggcgcaggugcccucggccugagucp\n", + "gcugcgcupuuggaguggccgcaacpcpcpcpccpcaaguuuguuccccgaguucggagccuaggagccccccgcggcugcggcgcaggugcccucggccugagucp\n", + "gccccggucucacgcaugcgcagapccgauccaguucuuuucggcuggaaupaauuugugag\n", + "agaggcgcagcucugcuggagagaccugaggcuugcagcgcupcccggccpucgcugcggcupcuggag\n", + "uuuccucuuugguccugagcugguuaaaaggaacacugguugccugaacagucacacuugcaacc\n", + "gagugaccacagguguccccgucgugcucaccugcaccggcugcgaggagcapagcuccucaaagagcucaggaacggacaggac\n", + "acupcuccgcggagccagcgagaggucugcgcggagucugagcggcgcucgucccgucccaaggccgacgccagcacgccguc\n", + "cgcuccgagcgccgaggagccgagcggaggaggcgucccapacacgcapaggccggccggccugcacpcgcucccgccucpcccugucuggcgccucagcgcgcgccccg\n", + "gcucuugcgguggcguaaucucucagccuuucugugucuccuuuccuccgccucaguuupcpucpa\n", + "ugaagacagccacacagauauugcacagacuauuuacagaucguuugguuuacauugagagucauugcucuacuuuugugcgguaggaaa\n", + "uuccuccaacucuuccccgccuccucccgcuucuccuccuccuccuccacaguugccugcccupcpcgagcgcguccgguuugcuggaagcguucggaa\n", + "guuccgaagguggcuaggcugacugccccgccgcuuccgcgcugcguagagcgcpcguccaggaccgagaucccagccucugaagc\n", + "guauauagaagguacacagaaucagaaaagauuauaaaagaaagcaagauuuuuguuagugacguccuguuuccucugaagaguaauaguuggaaucaaaagagucaacgca\n", + "uccgccuccuguccuccggaaaggugcccgccucuugccuuccggcccggcgcccgauuuccgccuuccgacccagcugupcugcgccccacgccagcccgcgccccgc\n", + "cuuccggcccggcgcccgauuuccgccuuccgacccagcugupcugcgccccacgccagcccgcgccccgc\n", + "acagacugcaacccugcucagugcuccpcgcuucaggcuggcuupuccugcugcuccaaccccaapcccuggagcgcucccugauaccuccaucacucacc\n", + "cuuuuuuucaaagauuuugauuccaguggaaucuuugcuuuagauuuguguguguguuuguguucgugaauuguaacuccagaagca\n", + "caaagauuuugauuccaguggaaucuuugcuuuagauuuguguguguguuuguguucgugaauuguaacuccagaagca\n", + "gagaccgcugcaagucccpcccugccucuaucguccuapuuccgcpcaggagcaacccagaagcaccggugaggccagcgcguccucgcagcc\n", + "aucuggcuuuguuuuuucuuuacgucacuuagcgccaguuuguucuggccgugucucccacuagaau\n", + "agacggcucuggugcggapagcugagaccgcugcaagucccpcccugccucuaucguccuapuuccgcpcaggagcaacccagaagcaccggugaggccagcgcguccucgcagcc\n", + "aaagguuaaagaaagapaccaauuaacuucaccuuuuccuaaacuugaaaagacaaaccaaauucugcccuucaucuccaauguuugaaagaucagagguuccugucaa\n", + "cuugcccagccgguguggugcuugugugucacagccuuguagccpagucgcugccgagupcgcucaguuuucpucguc\n", + "gccauccuugcccagccgguguggugcuugugugucacagccuuguagccpagucgcugccgagupcgcucaguuuucpucguc\n", + "guccugugcugcuccagccguupcucuccaccccpccacagccuccuggcgccccccpccgaggcagccpccgaggagugucggugugguccggcuacpcpccg\n", + "gcuccuccucuucgcugccggupcaccgccgcucgcucgcacuucugcgcccauuggagcuucggagaucccugcggucccgcpacggcgcggcagcagcugaccucgcag\n", + "acaggaucuugcucucuugcccagacuggaauacaguggugugaacacggcucacugcagccucaaccuccuggacucag\n", + "agcccagugcuuccaccacaaccgaugucaacucuccuagcgccccuccgcucaccgguaaaccaggacaguggapcgcccugaugcg\n", + "agugcuuccaccacaaccgaugucaacucuccuagcgccccuccgcucaccgguaaaccaggacaguggapcgcccugaugcg\n", + "gcuuccaccacaaccgaugucaacucuccuagcgccccuccgcucaccgguaaaccaggacaguggapcgcccugaugcg\n", + "cacaaaggcaccaaaccacaaaacgucacacguaaacaucauacguggcaaccacaagccaaucaguuggauauuucauucauugguauacauauggacuguaag\n", + "cuucgaguggugagaaggagaaggagcggcupaggcgguuupaguggcpugguaacagcacacgagagcggcugcugucugcgcuugaggacuuggagguccugucuag\n", + "ggccpugugguggcucacgccuauaauccgagcacuuupaggccaaggcpcggaucauuggaacuucuucacaga\n", + "gcaccugcgucagcucgcucugcgcgugcgccgguggcpacucupaaaauggcugcgucuucgagug\n", + "aucpugguauccauugagcacuguccuggugaggacagguugauagaucaccugaagccuuuuagaugagaccag\n", + "gaugucagcugcaacgagaucacagcguugccccagcagauaggucaguugaaaucucuacgagaacugaaugucagaagaaauuaccuuaaaguuuuaccacaag\n", + "aacuaguagaucuuuccuugguaaaguuugacuuuuccugcaacaaagugcucgugauuccaauuuguuuuagagag\n", + "ugauuguauuagapcaacaaccugagacaauauuucagagcaucauuccaaggacacaccaggaggaaaa\n", + "auggagucuugcucugucacccaggcuggaaugcaguggcgcaaccucggcucgcugcaaccuccaccucccagguucaagcgauucuccugccucagccucccgaguagcuggaauuacag\n", + "ggcuucgcgcgauggcuggucuupcagugcugacugccuapucucuggaaaagccagugauacucaauggagaauupcauuuguccguucugcacuuuuaa\n", + "uauacuauucagaaagaagaaugcgcaacccaguuuggagaaagauaggaagauucuuaaauaugaacccaucaacapagucagacagagaggagcaggacauuccauacagauagaaggaaca\n", + "ggaacugcgccuaggaggccgapaggaggcgcuccgcagacccuggcgcgccgcggagaagcucaaacuuuggcagg\n", + "cagagccaagcacagupaacuuucagaaagcacugguugaaggaacgcuggaaucccupacuuacugcguagcauguaguaguugcuccucuacaaaaguuucaccuuaugaaguauagcag\n", + "ggauuauugacgcgcagcaccacgcccggcuaauuuuugugguuuuuguaucuucugucuucugcucuuuaguaccgcauagagccacagaagacua\n", + "agagguggupagcagupcucugccuguccccacccccaccupccucauaccaucccacuauc\n", + "gcaguccgacgccgacugaggcacgagcpugacgcupccugcagcgcggagcagaaagcagaacccgcag\n", + "aguccucccugcugcuguguggacgacacgupcacaggcagaagupcccugugaccagcugcacugguuucguggaag\n", + "agupcuuccaucaaauaacuacucaaaugcaugaaaaauugcaguuguupuacuaggaacagauaggcucuucggaaagcagaugaggcucuuggccugguc\n", + "gagugacugagccccpcugugcaguccgacgccgacugaggcacgagcpugacgcupccugcagcgcggagcagaaagcagaacccgcag\n", + "ggaagaaaaaaucccaggaaaauaaaaacaaaggaaacaaaauccaagacauacaacugaagacaagugagccagauuucaccucugcaaau\n", + "gguucauguaaucaaagaaguuucuuuguuguguguaucuuuacagaacacaacaggaauugaaa\n", + "gaagacaacccugagauagcagcugcgauugaggaagagcgagccagcgcccggagcaagcggagcucccccaagagccggaaag\n", + "acuuccgacuggagucaagauggcggcggcgcggccgcpcgccpccggcgaaacagcggcggcggcggcggcccucggugcucugaggcgcuggcgcggcpcgcgg\n", + "ggagucaagauggcggcggcgcggccgcpcgccpccggcgaaacagcggcggcggcggcggcccucggugcucugaggcgcuggcgcggcpcgcgg\n", + "gagauagcagcugcgauugaggaagagcgagccagcgcccggagcaagcggagcucccccaagagccggaaag\n", + "ggcggcggcuucucgaguccuccccgacgcguccucuaggccagcgagccccgcgcucuccggugacggacc\n", + "ccgcggcgcuagucucguuccuuugugcugcggcggcggcuucucgaguccuccccgacgcguccucuaggccagcgagccccgcgcucuccggugacggacc\n", + "aacccauuucaacugccuauucagagcaugcaguaagaggaaauccaccaagucucaauauaauaauauucuuuauuccuggacagcucgguuaaugaaaaa\n", + "apcguguucgcuguucagugccgguguugcapagugapcagcuggagugcguucugccgaagcuugugguugcacgcccaucgucuuapcuaccuuccgug\n", + "aaggccacucuauucuuuaaauaacuguauauuauugaagaauuuacugaugccagacaguucaccuaagag\n", + "gugcacagucaaagaauuuuaaaaacapaacuuuguaacugugaaauacucuccaggauuuaaaaggcuguggagcuccagauaaagaaucguuuaucuuucuucugaag\n", + "aaauuccuuugguuacaaguuuaccccauaaacggcaacacacucaccuccauccaagacagacucaagguggaggaagcguggaa\n", + "acagucaaagaauuuuaaaaacapaacuuuguaacugugaaauacucuccaggauuuaaaaggcuguggagcuccagauaaagaaucguuuaucuuucuucugaag\n", + "caccaaaaccaagaugguaacgagagugaccugugaucguccucacugcugcacucccaccagcgccaugaguguuuacaugucauagcaacaucaggaaguuacccuauauggucuaaaauggagag\n", + "gcuuuacguaaggcgcaggccapccgcccggcgcucggcagccgcccgcagccccucggagccagaggagaggcgcccccgccggccgccgcgccgcccggcagccucggcag\n", + "guaguguacacugauaaagguapcgcgguggacucugccccuguaaccguuccggagaaugcguugagaaugaagacaacca\n", + "acguaaggcgcaggccapccgcccggcgcucggcagccgcccgcagccccucggagccagaggagaggcgcccccgccggccgccgcgccgcccggcagccucggcag\n", + "cgcaccgccuaggcaagccagcugacgccpcacagaccacccuccacugagugcggagcagccaag\n", + "aaucaagccupcaauggcpcgccccucccccagccucgcugcugccuugcaguuugaucugacugcugugcuagcaaucagcgagacuccgupcguaggacccuccgagccag\n", + "agauguguuggugacagguugcuacucagaggugcggacaggagcugagcgcugcugcugucggagcagacgcggcguucccpuugugcucagccccugcagcugccaucggcuggagaaguccag\n", + "pcgucucggagugccggaggcccccpaagagcpugccgguguccgcuccpcucggaupaaguggupaggagcgacccp\n", + "guuggcaaauaaacaagauaaagaaggagcuuuaggagaagcugaugucauugaaugucuaucucuggaaaaauuggucaaugagcacaagugccugugucagaua\n", + "aaaacaaaaugaacaggagcaggcugaacucgauggaaccaguggucuggcugaguuggacccagaaccaacgaauccuuuccagccaauagcaucuguaaucauugag\n", + "aggcguagaucccccaccaugugacgcupacagaccaggacuccagguggagguugcaguaugaugucuaucaguauuuucugccugagaaugaccucacugaggag\n", + "agaggaaaccucucgcupcuaggaguucggcpcgcgcgccggcggcugcggagcuggcag\n", + "gcacugccaguggacugguuuucauccuuagaccagagcagaguacaugcacuugguacuupacuucaggcauacagccuguccagaau\n", + "gugacgcagcgagagcccpaggaggcgcpaacgcgcguupucaggugccggaagaggaaaccucucgcupcuaggaguucggcpcgcgcgccggcggcugcggagcuggcag\n", + "acucuccuuuccaauuccucggaaacaggcacugccaguggacugguuuucauccuuagaccagagcagaguacaugcacuugguacuupacuucaggcauacagccuguccagaau\n", + "cauuaacaaagauggugcuuaupcagguucccuaacagucaggauuccgguugcaguuuuucucccccgccccaaagauacgugguugcagac\n", + "gccauuaacaaagauggugcuuaupcagguucccuaacagucaggauuccgguugcaguuuuucucccccgccccaaagauacgugguugcagac\n", + "pcagguucccuaacagucaggauuccgguugcaguuuuucucccccgccccaaagauacgugguugcagac\n", + "caggugccgaacccacggccaggcuuccguggccagcagcccuagaggaauggccauccugucccugcgagccccupcccuggcaggcgaugcag\n", + "aaggaggagugauguupauggccugauuucuccuguguccupugcucccupagacupaggugcuggcaucpuggccgccucugacucugugacccacccacagucaucag\n", + "guupaaapugguccguggugagccugguaccupacucauccuggcccugccuggcccucaggupaugcu\n", + "gcgugccaugaaccuccgcgccggaggcggcagcagcgagcgcpcuggauccagcguagcpcggccpcggauccagcgcagccpagacagaugcgaggcggcggucag\n", + "agcgagcgcpcuggauccagcguagcpcggccpcggauccagcgcagccpagacagaugcgaggcggcggucag\n", + "gaagaaggaggagugauguupauggccugauuucuccuguguccupugcucccupagacupaggugcuggcaucpuggccgccucugacucugugacccacccacagucaucag\n", + "uucuucacacuacuggagcauugacguuacuuguuaagcagccuuccacauccuagcucuuuuccaa\n", + "agaaguccaucgugagaucagauugugcaucupucaagccuaaacaagaccagaaguccuaag\n", + "uucccauacuacuucapaaaaccagcauacacaugaaacuacuguucuuugagaucaacuuaucucagacaga\n", + "guuaagugcugccucugcauaacaugcagguggaagucccauggucuuuccucagguucacuucaauucucuucuuggaauucucag\n", + "gaauuccguguauuauuuugauuugucugaaucacaugauugcucagaagcagacagcaccagcaagccagcacucaacccuaagagcagccuucagugagcagucugcugaaauucuaaaacaga\n", + "agccagcapcgccapcugagccggccguggapagcpucccgcpuuauacaggcgccpcuccgcggcag\n", + "agaccgguucuggagacaaaapccgcggcggccggagcpacpcccggcgcpapagcgaagcagcgcpcagcgagcga\n", + "aggcugagaccggugcgccgcgcgcuaguggccgcucuuccgcpcuagcpcggupcgccagcagcgcggaaggcpcacgcpcc\n", + "gccccgcgccgcgucaccgacgucccgcuaggcugagaccggugcgccgcgcgcuaguggccgcucuuccgcpcuagcpcggupcgccagcagcgcggaaggcpcacgcpcc\n", + "gccgccuucuccugccggucgguagaacggaccccuuccuuuauuccugucuccucuuucuuuuucccuguggcucagcccguucgcuggacugcaaaccgagcucccgucugccuugcag\n", + "auuuccaugaggacaacuuacaaggaccuguauggccucauuuuagcugcuucaguguguuggagcuguuacuugcuccuucauuuccupccuggugugacaguggcuacugagcgcc\n", + "cugcuucaguguguuggagcuguuacuugcuccuucauuuccupccuggugugacaguggcuacugagcgcc\n", + "aggcpaucpcggcgccgagcugagguggugapacuagcucccggauguggagaagcupagaaggcgupaggaag\n", + "gaucpcggcgccgagcugagguggugapacuagcucccggauguggagaagcupagaaggcgupaggaag\n", + "agguugacauuguaggaaauauucaagcuacuucuccauguuuacauccuacugaucuucaaaaaguugcagaa\n", + "cuacgaaucagugguuucugccagcuguuagaggagauaucccuccaggcugugcugcccauggauuugucugugaugguaccagaauauuaguauuupa\n", + "ccacaauaacuuuguagccauccuggaucugccggaaggagagcaucaguacaaguucuuuguggauggucaguggacgcacgacccuuccgag\n", + "cccauaguaaccagccagcuuggcacaguuaacaacaucauucaagugaagaaaacugacuuugaaguauuugaugcuuua\n", + "ccuupacccgcgguuccpagucccuugcucapucccuuuccugcagugaggcgccguccgccuucccuguguccccgcagacccccauc\n", + "gacuccuuccgcaggcuccuupacccgcgguuccpagucccuugcucapucccuuuccugcagugaggcgccguccgccuucccuguguccccgcagacccccauc\n", + "guuccpagucccuugcucapucccuuuccugcagugaggcgccguccgccuucccuguguccccgcagacccccauc\n", + "acaagccpcacccacggacugagcggcgcgcpccgagaugcgcgcccgccugcugcccccgcucccpccuggagcggcgcgacccc\n", + "ucccacccccagccupccucupagccuugguccugagcagccaacacaccagcccagacagcugcaagucacc\n", + "ucuagapcaagacagccauucaaagaaauaacuacaaaaaauaaauauaaaauccugacugugauaupuggaaggagag\n", + "gccaaacuuccagaucugcaaccauuuccuucuccagauggugauacagugacccaacaugaggaacuggucugg\n", + "ugaagcccaggcuuacugucuaccuuucacggaggccuagccgugagaggacagaagaaggcacguggcgaauc\n", + "gagccggagcccagugacaggcgacggccucuugccgccccggaccccpcgcuuaccuguggcugcupucggccgcccpaccaggcupagccccgag\n", + "aaacgcuucguuaapacucaggcaguacpaagaacuucuucagaauuagaaaggagcugcuucccaauaaggaaaca\n", + "uggaccuaaguucagccagugaagaugacuucgacagugaggacagugagcaggagcugaapuacgccugccgccacugcuucaccacca\n", + "ccuccaaagauuggcaccacggaggccpagaacauccugcuuugcaccgacugucgcauccacuucaagaaauacggugagcucccgcccauugagaagcccguggacccgccaccguuu\n", + "ugcgccccgcggccccgcagccuccgcgcggccucccgccccauccccgccacuuuccccggagcupccgcgaacaccucacuauugaugguguagcgcuuuapaag\n", + "apagguguagccggucuuupuaggcgguaguggcggaagagguucggcggcugauggcggaucaggaucggaagccugcguaacuuucucccuugauccpagucuuuccacugg\n", + "cupapagguguagccggucuuupuaggcgguaguggcggaagagguucggcggcugauggcggaucaggaucggaagccugcguaacuuucucccuugauccpagucuuuccacugg\n", + "guuggauggaguacugcucgugauuauuacacguuuuuaugguccccuaugccugaacauuauguggaaggaucaacagucaauuguguacuagcauuccaag\n", + "ggucuuupuaggcgguaguggcggaagagguucggcggcugauggcggaucaggaucggaagccugcguaacuuucucccuugauccpagucuuuccacugg\n", + "guugccgcupuacguuugcugccagugcugauccagccggaggcgaagagaagcacuuupcaaaag\n", + "aaucuucugauggcaugcuaacaauuguagauggcaacuguguuggaaacuapaucccaucugaguuggucaaagucu\n", + "ucucacugucaacaacaucccauccugaagacuugcuuaccacaacugagagupagucaguuugaggccuagcaucacuuaaacuuccuccaaaggcacaaaagccag\n", + "cucucacugucaacaacaucccauccugaagacuugcuuaccacaacugagagupagucaguuugaggccuagcaucacuuaaacuuccuccaaaggcacaaaagccag\n", + "cucacugucaacaacaucccauccugaagacuugcuuaccacaacugagagupagucaguuugaggccuagcaucacuuaaacuuccuccaaaggcacaaaagccag\n", + "agugaggagguuauacccggaggucucgacgcucgcucgugcugcucguguugccgcupuacguuugcugccagugcugauccagccggaggcgaagagaagcacuuupcaaaag\n", + "ucgcgcucuggaggcucaggcgccgcgupccggcaccucccggcagcagcggcagcugagacucacggucaagcuacggcgaggagugg\n", + "gguugaccagaagacupcacaucauuaauucagcacaacucaccauucccacuggaaacauacuggcaauucacaucuuccaaacaaggaccaaccucuuacuccaaaagaaaaaug\n", + "cagaugaaugcaugauaucucuugguaaaauggcccagaagaaacacaggaaggaguuaugaaaagauaacacccguaagugugacuacacauuuugugauccagucaucauuucu\n", + "aggcgccgcgupccggcaccucccggcagcagcggcagcugagacucacggucaagcuacggcgaggagugg\n", + "caguacuccagccaaccaaucuaagacugaccggcgugagcagagaacagagucuccaggaggucuguggccapccaggcgauuu\n", + "gagaguagccaccuuucccucaggccauacacauggaaccauucuuucucccuacaagucagcccauaauagagccucugguugaaaaucaagauuuugguguucacuuggcaauauuuacuaagag\n", + "cuuucuaaaaccaauuuuuccaacaacaacgauuuccgugcucuucugcagucuuuguaugcuacuuucaaggaguucaaa\n", + "gccccgcggcgapugucuauggagaggcggcggccgcggcugcugaggcggaggcugaggcaguggcg\n", + "augcgcaapcgcgccgccucugccccgcggcgapugucuauggagaggcggcggccgcggcugcugaggcggaggcugaggcaguggcg\n", + "ggaacucgacacgcaccgaccgcccucccgccccagccgaagcggaagcuguagcccgcucupccpccaupcgccccgcgccgcccpuc\n", + "ccuuuccccaguguugagcgcggucucgccuccgcuuccuccucacuccgccugccggcupaaacuapcaccaguacgauaguuccggcaccggaaaagapcug\n", + "gcgcgcggccgcguuugaauggcccugagupacucggcccagaagccgapacucucuaggcugccpcgcuggucgucagcgccgaggcupcugaggcgccgcgguaccaugaggcgccg\n", + "aaacuaupaugauggugagaauuucacagcaggaaagauupaaguuuaaggaucugaacaggaguuag\n", + "gcgcgaggcuagcgcaccggcggcpcpcgcuccggcaggccccgcccccgccuuggccauugaaaggucgcupacguccggcp\n", + "gcuagcgcaccggcggcpcpcgcuccggcaggccccgcccccgccuuggccauugaaaggucgcupacguccggcpugcggcacuga\n", + "gcgcgaggcuagcgcaccggcggcpcpcgcuccggcaggccccgcccccgccuuggccauugaaag\n", + "aaguauauccugaguucacuuaccucuupuggcagcacacaucgguccacccugcuuguccagaaacuguuaagaguuggaaguucagaagaaaaaaaaaag\n", + "gcuggagugcaguggugcaaucuuggcuuacugcaaccuccgccucccugguucaapauucuccugccucagccuccugaguagcugguaugacag\n", + "gccccuuccccgucccuuccccgcccccguccccgccccpccgccgccacccgccucccacc\n", + "aggcagcuuguggcggcgaagccaucgguguucgcugauguccagucuauggagucaguugguaccgguggcggcgcggaggcagaaggcgguguccgaguapccucugccccaccagg\n", + "aaagagcgacupcggcggcpcgcggagcugccaggcpagcggcguaggcgcpucgccggccagcgugaaccpac\n", + "agaugcagaggacuuagacaucaggaagacuuagccacuggaggcaguacuucaggaaagugcacucuuugaucaguggucuuuccucggcccugcucugaaaccuaaccag\n", + "cuacauuaacucuuuguauuccagccaggcugcuccucuuagaugcagaggacuuagacaucaggaagacuuagccacuggaggcaguacuucag\n", + "uaaagagcgacupcggcggcpcgcggagcugccaggcpagcggcguaggcgcpucgccggccagcgugaaccpac\n", + "agcgcggcggcggcggcggcggcggcagcagcaggagcagccccggcugcpucgcgacggcggcpcgcccccucccccgugccpcgcggcggap\n", + "agucacaacuuccgguuagcguggcggaggcucucggagucuuupaccucagcaccpauaccpagacucccucgugucccc\n", + "ggaaaacugcuuacauggaaggcacuucapuaagguccapugugugucugugcuuggcucuagguugcuccauuupag\n", + "acagaguccuuccuguuuccagucuagaggcuccapaggugagacgaccacucccaccagcagcaggcccugugcuggcugugucgcaggugcagagugag\n", + "gcggcggcggcggcggcagcagcaggagcagccccggcugcpucgcgacggcggcpcgcccccucccccgugccpcgcggcggap\n", + "ugugaacgaucccpaacauguccuuugugaaggagacgguggacaagcuguugaaaggcuacgacauucgccuaagacccgacuucp\n", + "gucccccggucugcgupaugaacaucgacaucgccagcaucgacaugguuuccgaagucaacaug\n", + "gcuaugcaggaacugcacagcuaggauucagccacuguggaacuaacguggcuuauagauucauuuuuuccuuuccaggaguuuggaauugaaaau\n", + "gaggccaugugaugcupcgagagagagccgccgcgccggagccuccuucuuuccugccucugauuccpcuguc\n", + "gcapagccugacacugapcuggcggcuuuucuggcgcpccapaggaggagaaaggagcucccpauccccucgcccccucccccaacugcccg\n", + "gugcggcuggugaucgccgagaapccuggugugcgaggagcpacgugagccugccacagagcgagcacaaggagcccugguuc\n", + "ucuccuccacuagcucugagupccacaggaccacuacgcuugccggacacaaggccccacagguggaag\n", + "apagucuugcuuugucacccaggcuggaguacagugaugugaucuuggcucacugcaaccucugcucaccag\n", + "gauaaggaaaggaaccuccucccuggcupauggcugcccpcgcpaggapccpacccggugapaggaccguapcccgupcuucacgccuggcaggcggccggccag\n", + "cucccucucugcacccugcaauucccaccccuccguauuuauuucccuggucccgccgacagucccuccuugucugucuccpauucaggccucccucccugac\n", + "ggagauaaggaaaggaaccuccucccuggcupauggcugcccpcgcpaggapccpacccggugapaggaccguapcccgupcuucacgccuggcaggcggccggccag\n", + "aguuuucuucagagaccgapacpaauccguugccgcccccggccpcggcacgaccccgauuugg\n", + "acucggcucaaacucupaucuggaacaugcucupcugugaggacaagauguuacguagucaaggcacagcupccaacgguggcccuggaaggcagag\n", + "caccccpcuccpcccuaguugcuupcaacpaacugucagcgaccuggcccaaucaccucucggaacgucacucgg\n", + "acapucagauguguuacupcuggagugugguggcacaaucacgcucacugcauccuugaccuccupcucaagugaucuucccaccucagccucccaaguagcupacuacag\n", + "gcgcacgcgcggcgcaggcgcacupcgccggugcuguugccuucaggugaccacggauucgccaucgugaguuccag\n", + "agccagcgccgccgcgauggcggaggacagcgagucugcggccagccagcagagccuggaacuggacgaccaggacacgugcpauagacpaca\n", + "aguacggcpaggcacuagapagcugcggccgcuccggcccggccccgagcaccgccuccccagccagcgccgccgcg\n", + "guacgcgccuccgccgcccccgagaggacgcgccgugcagcggcugaguggcggcggcggcgacggcaaacccggagcugccggccggcgcgcpaggaggacgcpugcggucuaggaa\n", + "acggagcugcpcggaggcuccauguupaagcggcgccguucgugcuuguuagcpaauccpagccgcpugagcuggcpccpcccuaagugaag\n", + "acucgcggugugaacauacupucucgccucuccuuuccccuccccucggccuggugcugaaucaugagcccaaugucuccaaaag\n", + "aucaucucaggccaccucaguguauacucuuccauuugacaacggaauucugcugcccauguucaacuuacgauccaguaaauuag\n", + "aaacuuuucagcauuaccuaagaagcaaaggcucaauuuuggcugcuucauucuuaucucuucugccacaguucuaacgugccugaucuacugagaccaagg\n", + "cuuuggucccguauucucggcuauuuauccccagcugcpaggcccuggugacucugcugcugcagugucugguuucccugugaccugcagguacupaguuacauagcuaag\n", + "agacgcauucucacuauguugcccaggcuggucuugaacuccuucccucaagugauucuucugccuaauccucccaaaguucuuagauuacag\n", + "ggacuacuggcauucagugauguggucauagaauucucuccagaggagupcaugccuggacccugcccagcgaaauuuguauapaugugauguucgagaacuacagaaaccuggucucccugg\n", + "ggcacucacagcacaggcuuguuaupucuagcagccucuguggcaucuccugucacauupaaa\n", + "acuuugcagagcuauuugcucuupacagaagcugacaguggcacucacagcacaggcuuguuaupucuagcagccucuguggcaucuccugucacauupaaa\n", + "agcuauuugcucuupacagaagcugacaguggcacucacagcacaggcuuguuaupucuagcagccucuguggcaucuccugucacauupaaa\n", + "cggcucpcugugagcggcucpccpupcggcggugcggcpcggccgacgcuccucuucggcggcggcggcggcggcc\n", + "auauccaugacgacauugaaaaugaauuuuuuguauucaccagauauucuuauaugagaagaucuauuuuaaacagucuaaauauuuuuucuucuguuggaccagc\n", + "augauuagcgcupugcpuuucggcggccpapaguugucggcgccgcggccgcugcggacggacgcucgccugccggcugag\n", + "gccccuggccaccaagcgccuccguggacacgcacuuccugcgapcuccgugcgcaccuuggccgagccgaaccgagccgaguccuguccuuccaggccguucgca\n", + "puccaugcccgcgcucacugccaagaucuuucuggccccuacggacacgaguuugcgaccucugagucacupupcgcgucggaaagaccapcgccucagucuggagcucgcaguc\n", + "paacggagcagccccpcccccuugaggcggcgaggccgcgaapcgcpcuggagg\n", + "gagaaggcgcpcpcuguccggcccgcapcggucgaggupaacggagcagccccpcccccuugaggcggcgaggccgcgaapcgcpcuggagg\n", + "cuccucgccgccgcuuccucucgagaaggcgcpcpcuguccggcccgcapcggucgag\n", + "uccgccccgcagcucggccguggacggccgcaccggcgcuaagguggccaucaagaagcuguaucggccuuuccaguccgagcuguucgccaagcgcgccuaccgcgagcugcgccugcucaagcac\n", + "auugcucuacaaucuguggccucagcccuugccaacucugccucuucccccgcugacupuaucaguuuauggugcccugcaggaagacccucuuguuccu\n", + "cuucuuccgacagcuugcugcccuagaccagaguugguggcuggaccuccugcgacuuccgaguugcg\n", + "agaguugguggcuggaccuccugcgacuuccgaguugcgaugcuguacuucucuuuguuuupcggcucgg\n", + "agaugaugcaaccgagcuucacugcuugcaucaggcapucccggcggcagugapcuggaaggag\n", + "acggacugcuaaaggucuccccucccaccugcauugcucuacaaucuguggccucagcccuugccaacucugccucuucccccgcugacup\n", + "acucugccucuucccccgcugacupuaucaguuuauggugcccugcaggaagacccucuuguuccu\n", + "uuuucggccuggucucacaagcugagccuuuccggccagcucugagcccugcagaugaugcaaccgagcuucacugcuugcaucag\n", + "gcuugcugcccuagaccagaguugguggcuggaccuccugcgacuuccgaguugcgaugcuguacuucucuuuguuuupcggcucgg\n", + "agaugaugcaaccgagcuucacugcuugcaucaggcapucccggcggcagugapcuggaaggagguggaacpuapcuaa\n", + "accugcauugcucuacaaucuguggccucagcccuugccaacucugccucuucccccgcugacupuaucaguuuauggugcccugcaggaagacccucuuguuccugupupaag\n", + "aagugcgcgcggccccgcccccgccgguucgcgucucucugcugcggcgcpaccgcugugcucucg\n", + "uaaugaggucucguuauguugcccaggcuggucucaaacuccugagcucaagcgcucuuccuuccucggccucccag\n", + "auagccupcuggaagcucuucuacgucacaggcugccuguuuguggcugugcagaacuuggaggacupag\n", + "gaagccaucuucgacaagagcacapaagguuguuuugaagacguucagccucuacaagaagcugcugacucuuuucagagcuggccacgaccagg\n", + "uggugguccugcuccaugauguccgugaugugagcguggaggaggagaagguccgguacuucpaaaggcuac\n", + "ggaagugcgcgcggccccgcccccgccgguucgcgucucucugcugcggcgcpaccgcugugcucucg\n", + "aucccggaagugcgcgcggccccgcccccgccgguucgcgucucucugcugcggcgcpaccgcugugcucucg\n", + "ccupcuggaagcucuucuacgucacaggcugccuguuuguggcugugcagaacuuggaggacupag\n", + "gcuccaaucccggaagugcgcgcggccccgcccccgccgguucgcgucucucugcugcggcgcpaccgcugugcucucg\n", + "gcccccgaaagucggcucggcuccgcuccaaucccggaagugcgcgcggccccgcccccgccgguucgcgucucucugcugcggcgcpaccgcugugcucucg\n", + "aaucccggaagugcgcgcggccccgcccccgccgguucgcgucucucugcugcggcgcpaccgcugugcucucg\n", + "ggugccccccpcgcaggccapaggcccgagcgccuuccccacgccccgcucgcccgcgcgugugapapcggcccagccguuucgcgccpag\n", + "ccugagaggugcuugaguugaauggaggacaupaggaaaagagagugcuuguuccagaaauguguagcupccuuguuuucccaguaauccacccaccgccacuucaagaagaaaugau\n", + "ccaccgcuuuccgagcccgcuugcaccucggcgauccccgacucccuucuuuauggcgucgcuccugugcugupccgaagcuggccgccugcggcaucguccucagcgccupagugaucau\n", + "ccgcuugcaccucggcgauccccgacucccuucuuuauggcgucgcuccugugcugupccgaagcuggccgccugcggcaucguccucagcgccupagugaucauguug\n", + "acagaggucaaggaagguuuccccaggagcaguuuugguuucagacggcgccgucucccgcgaaaguccugagaggagcccagccuuuuccgccugccgcccccgg\n", + "guuacacuuccapcuccccacucaguccccagucaucuaucgacagugagcugaguacuucagaauuggaggaugauucuaucucc\n", + "agucaaguugaccuacauagaagagaaggaacuggaagugcaugucuguguucuggcuccgauupaaaagcugcuuaaccacu\n", + "guuauacauuggcucuucaaagacguucaccucaucagagaaaucccugacuccuuugcagugguguagacauguccuagauaacccaacuccugag\n", + "gacgccgccapcagcugcagcgccgcccucgccgccccccacgcugcuggacgagguggaauugcuggaucuggagagcguagccgccuggcpacgaggacgacuacaccug\n", + "auugcgaaugugguuuccuugccuaguucuuccacauacuuaaggaaaagauauuuuuaauguaauuguuagaauguguug\n", + "gcgcuggcapcgaacuccacucacucagacccgcugcucuccaccccucgcuggapagaacgcaggugaacagcugcpagcup\n", + "ggccacuuccgcgcuggcapcgaacuccacucacucagacccgcugcucuccaccccucgcuggapagaacgcaggugaacagcugcpagcup\n", + "uguuucguaguuccuccuguguucauucuccuuccugcugccuugugaagaaggcaccuuccuuucccuucaccuuccaccaugcuuguaaguuuccugaggccuccccagccaugcugaacu\n", + "gucguugcagagauugcpcggcugagacgccgccugccuggcaccuaggagcgcagcggagccccgacaccgccgccgccgcc\n", + "gccccagagacgugaacugucguugcagagauugcpcggcugagacgccgccugccuggcaccuaggagcgcagcggagccccgacaccgccgccgccgcc\n", + "cacacaggagapcauccpcaggaaaagauagugaagucgugaguuccagcuugugguagcgccugugucuguuuuuguuucau\n", + "agagacgugaacugucguugcagagauugcpcggcugagacgccgccugccuggcaccuaggagcgcagcggagccccgacaccgccgccgccgcc\n", + "cugcccacgagcauaauucuucaucacacaggagapcauccpcaggaaaagauagugaagucgugaguuccagcuugugguagcgccugugucuguuuuuguuucau\n", + "paaaaaaaugaaaggaaaaauauuucaacccggcugucggucuaaaagaggagagaaugcuuucuuuaaaaaagg\n", + "auuguugauguuauuguupaaagacgaaaaaggcagaaagaucccagaauaucugauccauuuuaaugguuggaacagaag\n", + "cupauagaupcagcagaagaucaugugcuucgugauaccgaugaaaaucguagauuacagcguaaauuggcaagaaaagcuguagcucgccu\n", + "gaggagcacaggaagaaagaagaagcgcugcagguugccugguguggacucugucuuaaaaggccuccccacugaagaaaaag\n", + "gcacgcgcgguupagccucgcccaugcuuugucgcguuaccpcuaccguuugcgcccccgacugcaacgguggccgcugapaggaggcuucucgaauacg\n", + "gaggagcacaggaagaaagaagaagcgcugcagguugccugguguggacucugucuuaaaaggccuccccacugaagaaaaagaugaaaaugaugaaaacu\n", + "cauuaagcaguuccucugacuguagugaaaacaaggaugaagaaauaagugaagaaagugauauugaagaaaagacugaagug\n", + "ggaaauauuucuucguuucagauuguugauguuauuguupaaagacgaaaaaggcagaaagaucccagaauaucugauccauuuuaaugguuggaacagaag\n", + "ggauguuuccuauuuugaaggcguccacuupaaaaaaaugaaaggaaaaauauuucaacccggcugucggucuaaaagaggagagaaugcuuucuuuaaaaaagg\n", + "cccgcccgcccucccccaccgcgcgcgcuccgcccgccccggagccucgcccuccgccacgaugagcaa\n", + "accguuugcgcccccgacugcaacgguggccgcugapaggaggcuucucgaauacgguuucugucuucgcguuaa\n", + "aaaggaaaaauauuucaacccggcugucggucuaaaagaggagagaaugcuuucuuuaaaaaagg\n", + "cucuuccapcpcgguguggugcacgcauugcugugcuccaacucccucapccuguguugccgcacucugcugcu\n", + "pcgguguggugcacgcauugcugugcuccaacucccucapccuguguugccgcacucugcugcu\n", + "ggcacaaagcaugugcacagccagguaucauccugcgugacucagaacagccuugagauguaaggagugucaucccagccucgaaccupagcuuucuaagacucccaagg\n", + "ggaggccaggaaugapaguaagugagccauugacucaaugaaugaaugaaugagcgagugagugaaggaaggaap\n", + "auaagaaauuugaagcccccgcaaapaggugacuuguccacaaucucacaggcucaguggcuucagccagacuuggaacgcaaccagaaguucuaaggcaucaugucacuuuugupaaau\n", + "aaacaagaguugaaauaaaagaaucuguucguggccaagauauuuucauuauacagacaauacccag\n", + "cupuaacacggagcacucaggaauacacgaucuuggcpcgugauggcugaggccuguaaugucggcauuuugaaugacugag\n", + "agagcuagaucguauaccuccucggaggcggacauguupuccuggccaaaaaguuggaaacaccupccacuaccgag\n", + "acagucccugagaagaggagcucuupccaaucaccuaguuucugccuguguuacagugaagagaagcugcuuaagagaag\n", + "ucccugagaagaggagcucuupccaaucaccuaguuucugccuguguuacagugaagagaagcugcuuaagagaag\n", + "cucugaaggcacuuauccucacggacaacacgcucguuuuapcuccccuagaguuccagguuucaaaagucacgcugcggcagcgaaggaaggaaaccuagacaapuaaacacccgaug\n", + "agucccugagaagaggagcucuupccaaucaccuaguuucugccuguguuacagugaagagaagcugcuuaagagaag\n", + "gupaguccaggcugcccgaaugcupupcagcgccguggucauaapccuuuugcaucucupcagcgcgugcuuaa\n", + "auucuucagaggaggccccuccagccacucagaacuucaucauuccaaaaaaggagauccacacaguuccagac\n", + "gcuauuuaucugaacccaagugaaucccugugcuggagaggcgcucugaggcuccupagucggupaacgacaccagaagcucagguggagaucuuaucuuccugaggcugcuggauuug\n", + "gcauacgcugacuacaucggauucauccuuacccucaacgaaggugugaapaagaagcugaccuucgaguacagagucuccgag\n", + "gugupaggcucaggapcgagagucaugacacggaggaacuggapcaaaagcugapccccgaggapacugaguugaauggccuuapagag\n", + "cgucuccaccuaucpuggaaugcgagcacgcpacgagcgcugagaagcggcggugacpaapp\n", + "gccacacuaccaucaccccuuucuccaacccugaaaaacaguuccugagaccugaacuauugaccaucauuuuaaucggaccaacugcagcuguaacaagcuucucuuupucaca\n", + "uuuuuuccauagguccuuugccugcuauguaucucccaggauguaagugugguauguggaagupaaggaguguuaggagugaaguuguuaacacuuccucuguaaauuuga\n", + "guuauuaaaugcaaagcagcugugcuuupagcagaagcaacccuucuccauugaggaaauagaaguugccccaccaaagacuaaagaaguucgcauuaag\n", + "agacuaucuaugugaaggcacaagcugcuguuauauacaacagagugaacugagcaucagucagaaaaagucuauguuugcagaaauacagauccaagacaaagacagg\n", + "aagcuuuaaccugccuaucaagcccuaccaggugcaagaacupcuaggugcaaaupaugcagagaugcagacacaaauucaaucauccaggaacucacagucauaaucu\n", + "aggcuupaucccggcugcpuuuggcggcgcugcgccggcaggcagcgaggccpcpcccupcccucgcgccccucccgcgaggccuguc\n", + "upaucccggcugcpuuuggcggcgcugcgccggcaggcagcgaggccpcpcccupcccucgcgccccucccgcgaggccuguc\n", + "gcaaucaggagccagugaggaguuauaagccaagcaguaaccugaugauucaaucaaaaaauauguauggagugucuccuacuuuucag\n", + "ccgaagacucgccucucagccgcccgccgcacagacgcacgaguaaaaagugcagcuccaucggcugauccucgcuaagcuccgacucupcggcaccpcgucccacg\n", + "puccuupccugagagugugucpacapcugaccpagcupcpaaaggaaccauugucagaguuccuuucucggcggcgaucucgcccgaucucuccccgaccacgg\n", + "gugccaacauuaugcgaagaacuuuacguggacaucccauuuaauucucagaagccgaucacaag\n", + "gaagaguacccpuuugguagagugacuucuauucacuaaaaccaugugucugaacugaagaagcuupcucacuuccacaaau\n", + "guagccuugucagaugauaugcaaaugauucacaucaguguuugaaguucaaaccaaggaaaacu\n", + "auacggagcaaggcauguuugaagaguacccpuuugguagagugacuucuauucacuaaaaccaugugucugaacugaagaagcuupcucacuuccacaaau\n", + "gagauugaaaaguaauggcguguguucuacccucacgauuaaaaaggaaaaguucucugugaaucauaaucaaagaaucuuugaccugaa\n", + "gcuugaguuacugugcucucuuccaaggcuguaggaguucuggagcugcuggcuggagaggapuggacgaagcucucucuagaaagacauccugagaggacuuggcag\n", + "gugcucucuuccaaggcuguaggaguucuggagcugcuggcuggagaggapuggacgaagcucucucuagaaagacauccugagaggacuuggcag\n", + "acuccagguucuucaguuuuggaacucaaacuggcucuccuugcaccucagccugcagauggccuauugupaccuugugaucau\n", + "cuggagcugcuggcuggagaggapuggacgaagcucucucuagaaagacauccugagaggacuuggcag\n", + "aucuuucuuccguacuggaugcuuccugcacuugaacaucagacuccagguucuucaguuuuggaacucaaacuggcucuccuugcaccucagccugcagauggccuauugupaccuugugaucau\n", + "aguucuggagcugcuggcuggagaggapuggacgaagcucucucuagaaagacauccugagaggacuuggcag\n", + "guaggaguucuggagcugcuggcuggagaggapuggacgaagcucucucuagaaagacauccugagaggacuuggcag\n", + "guucuucaguuuuggaacucaaacuggcucuccuugcaccucagccugcagauggccuauugupaccuugugaucau\n", + "auguccucaauggaaccauaacguuuuugccuuuggaagaagaugaugapaaccuaaagguuaagaugagca\n", + "aaacagcugcucucagacgccuuuccauuugcucucugcuggcuaggcupcugugccucugcucccucuuccucuagcugagagupcaccupuaccpcccccccaccucauucccc\n", + "ugaagcgugacauucaggaaaacgaugaagaggcagugcaagucaaagagcagagcauccuggaacupaucucuccuggcaaagacuggacaagcugcag\n", + "agcuuggaggacuccugaaguauguacgacccuucuugaauuccaucagcaaggcuaaagcagcucgccugguccgaucucuucuugaucuguuucuugau\n", + "guugaaguauuguauuuugcaaaaagugcugaaauaacaggaguucguucagagaccauuucugugccucaagaaauaaaagcguugcagcuguggaaggagauagaaacucgacauccugg\n", + "cgcaggcggcaaguguccaggagucuggcgucugcucgccugcaccacgaccucccuccupagaaggacaugc\n", + "agagaagcccucuggacagcuucuagagugugcagguucucguaucccucggccaapuauccucugcaaaccucugcaaacccagcgcaacuacggucccccggucagacccagg\n", + "aucucuguugguugcucggccaggcuccacgucaaauccaguuugaaacacagacccuaggaccacgcaggagguggupcucgcaggaagguuccucucccaguggcc\n", + "gaapuggcgcugcgaucccgcapcagcgacgcgacucuggugcpccgucuucuuccccccgagcupcgugcgcggccgca\n", + "augcacucuaacupucccucugaggcuugugaauggaaaacccucuugcuuucaaaugcuugaaaacaagaaagaugcuacuauugaugccucaaauacau\n", + "uuugauagcaaacuggcaagagcuacuguacuuuuaguuuuuuacagugauuuaauacaggucaccauuugaacaugacaauacucugcaaaaaacuaca\n", + "gacugupcccucucuuggauuagcggcpcauaccauugcugguggccacagcccugcugguggcuuuacuauuuacuuugauucaccgaagaagaagcagcauugaggcc\n", + "gucaguuaacuguuccuacaaaugaaagacacaagccaauaaagccagugagaaaggagcuuaccaaaggcaguguacgaagaagguuccupagacugucagaa\n", + "gcagcaaaaaaguuugagucgccgcugccpuugccagcggagucgcgcgucpagcuacguapcagagaaguc\n", + "cguuuugauugguuuccaguguggcgcpucuccupauccgaaagaaccugccuuuccgcccggaagucggcgucuugagucauaggagugagccacgcccpcugupaauaag\n", + "gaaaguuggagcgguaaccuaagcuggcaguggcgugauccggcaccaaaucggcccgcggugcggugcggagacuccaugaggcccug\n", + "cccaguugagupaggcaggcaggcaggcgcupucugaguaccccucuuuccccapaggccaucagucuggugugugaggcugugccpugcuaapcgacaaggaggagaaag\n", + "ggcaggcaggcgcupucugaguaccccucuuuccccapaggccaucagucuggugugugaggcugugccpugcuaapcgacaaggaggagaaag\n", + "aggugcaccugupauugccgccaggugugcaggccgcuccaagcccagccugccccgcugccgccacc\n", + "gccaauguuuggagucugguuuccagguugccguuuuupcucupuguggcgguugccguagcugaaauuggcugcacc\n", + "gcgguugccguagcugaaauuggcugcaccaugucggccuucgagaagccucagaucaucgcccauauccagaapcuucaacuacacgguguuugacu\n", + "auugaaaaggccaaaccuauuaaauguggaacauuuggugcaacaucuuuacagcagagauauuuagcuacuggagauuuugguggaaaccuucauauaug\n", + "ggaucaguguccuucagugauguggcugupcuucacccaggaggaguggcagcaucuggacucugcucagaggaccccguacagagacaug\n", + "aaguuccucagcuacgacuaccagguaccucpuuccucccuccuccgagagaccgccgaggugcpcugugagapagcguggagccuccgaggccgag\n", + "aaugaaaacaaauguacuguucuapaucaguguccuucagugauguggcugupcuucacccaggaggaguggcagcaucuggacucugcucagaggaccccguacagagacaug\n", + "cgcggccccgcccccggacgcccagccgcggucccagcgaccuucgcuuucgupaagccggacugcgccgugucuuccugaagaaggcup\n", + "ccagaggcaggcgcccaagcucgcuggcuguugcugapccuguagguguguccaggacugaguggugugguggagacag\n", + "guguuucuuucuupauuguugucupacugcaagcapuauguuuuuaucuacugugagguuccupcggagaugugcaguggagcgagaacuuccugugaccgugacauugucuag\n", + "agaaguaggapcgucuuccccucgupcccugagcpacugcagccagcccccupcgccagcuuuggag\n", + "gcuuuuguguacuugucugguupacuucguguuucuuucuupauuguugucupacugcaagcagg\n", + "ggacaaagccaggcagcguuggcagccccagacccgaccccaaaggccugagacupugacupaccuaagagaauccugagcuggag\n", + "agcuacgucaucucaaucuccuccuucgcucccuggccucaguuuccaguuuauucaguggcaucag\n", + "gaaccgaucccagaaguaggapcgucuuccccucgupcccugagcpacugcagccagcccccupcgccagcuuuggag\n", + "aguuagacauggaacuuaauaguuuucacagguauucacgaguccucaggaguccagagaccucaguuugagaacacuauccuagcacugaccuugacuuccapugaccuugag\n", + "cucagccguuggaacguccuupcuucugaacuagugcccaugugugccucggccuuucccaapccagcuucuuccug\n", + "gcgucucgucuagaagcugcagcuuggccugucucaccucuacacagapcugcuggcgccugacggaaaaag\n", + "aguguucagccugcuuccggacpcgaggagacucguggucugguucupacuucccuaacagc\n", + "aagaagcacugaggaggaguccuaccucapcucaguguggaccuguuggcacuuuuacupucucagucccuuuuccuccac\n", + "guguucagccugcuuccggacpcgaggagacucguggucugguucupacuucccuaacagc\n", + "gcapcggcuccagugcagauuuaagccgcuggcaccupcagucucaguguucagccugcuuccggacpcgaggagacucguggucugguucupacuucccuaacagc\n", + "aagacaaaaauacuaaugcauuugagaaagcgguaguuuuppapaaaaagcaacugcuuuccugaucugcaacuuggcuggaugcuaag\n", + "gcuggagugcaguggugcagucucgguucacugcagccuccaucucccagaucaagcaauucuccugccguagccucccgaguagcupauuacag\n", + "auugagucucgcucuguugcccaggcuggagugcaguggugcaaucucugcucacugcaaccuccgucucccgaguucaagcaguucuccugccucagccuccugaguagcupauuacag\n", + "gcucaagugcaguggcgcgaucucaccucacugcaaccucugccucccugguuggagugauucuccugccucagccuuccgaguagcupauuacaggugcucgaacuccugaccucag\n", + "caaaugaugugcgagaugucauaaaacaagcucaaaaugaaaagagcuuuuucaaaaggaaaaccauccuuuuuauugaugagauucaucgguucaauaaaucucagcag\n", + "acagagucugcaggucpcgguagcgacaggucagagcugcggccugagcagccagcguccggcaugaaggucupucuggcugcugccugcuucuugcuccagcacc\n", + "gcgguagcgacaggucagagcugcggccugagcagccagcguccggcaugaaggucupucuggcugcugccugcuucuugcuccagcacc\n", + "ggccgcggccucugagcupaugagccgugcucccgguggaagcaapagcccagccggagccaug\n", + "gguupuugcgucgcucucugguaaaggcgugcagguguuggccgcggccucugagcupaugagccgugcucccgguggaagcaapagcccagccggagccaug\n", + "uugagguupuugcgucgcucucugguaaaggcgugcagguguuggccgcggccucugagcupaugagccgugcucccgguggaagcaapagcccagccggagccaug\n", + "gguugcgucgcucucugguaaaggcgugcagguguuggccgcggccucugagcupaugagccgugcucccgguggaagcaapagcccagccggagcc\n", + "gucgugccccgccucgucugccccgccagcgcgucgapapccagcgacacauggccuaguaacuguccggccgcggcgcuggcuuaagcc\n", + "aaucggcgcaggcccuucgucgugccccgccucgucugccccgccagcgcgucgapapccagcgacacauggccuaguaacuguccggccgcggcgcuggcuuaagcc\n", + "cuuuuccggauupcaucccggcaucugcacgugguuaugcugccggaguuupccgccacuguaggaaaaguaacuucagcugcagccccaaagcgagugagccgagccggagcc\n", + "cuucagccacauacuuuccuuccacuggccagcauucuccucuauuagacuagaacuguggauaaaccucag\n", + "acgacgaaccccpuauugaccccagacaacaaugccacuucauauupacuucgucupauuccaaggugcauucauugcaaag\n", + "uuccuuaaauauuuucucacugcuuccuacuaaaggacggacagagcauuuguucuucagccacauacuuuccuuccacuggccagcauucuccucuauuagacuagaacuguggauaaaccucag\n", + "ggaauggcauaccauuugaccuuucaaagguucuccagcaguauuuaacugaugcaaaaggaacacacuugcaauuuucuacuuuugacaugacagacccuccucuuaguucacaca\n", + "accuuucaaagguucuccagcaguauuuaacugaugcaaaaggaacacacuugcaauuuucuacuuuugacaugacagacccuccucuuaguucacaca\n", + "uaguucuccacugcuuucuucuaccuuggacuacuugucccaagaugcaguuccaccucccagauucccuaguuacuaucucuaagcacugaagucgguguuuggagaaaaggacucag\n", + "gcuuaucaaaguuuuggcuuuguugcaagagcaggucaagauuuagcuguucuucagugaacaagugugcagauugucaaau\n", + "agauucccuaguuacuaucucuaagcacugaagucgguguuuggagaaaaggacucaggugaggacuggag\n", + "cgugaacuucguuucuccucucccuagccupcuuauuucucacuuuagccuucggaaugcuuucgaaacu\n", + "acgaggaauucgcccacgcaggaggcgcggcguccggaggccccapuuaugagacuaucacugcucaggaccuacuaacaacaaag\n", + "gacacgaggaauucgcccacgcaggaggcgcggcguccggaggccccapuuaugagacuaucacugcucaggaccuacuaacaacaaag\n", + "uaucccgucgauguaaucuucuuaaaaaucgcugccaguauuaguaaauuacgcaauggcuguucaacuuaaaucgcuaaguaucuggaagccaggacagaaauggaaguagaau\n", + "acuugcagcpaggcggagacggcggagcpccuuuuggcguccacugcgcggcugcacccugccccauccugccpauc\n", + "agugaaaccaugaacugaauuccuucccuaaguuaauucagccuauacccaggaaugaacaaggacagcugaaagguuggaagcaagacggagucaguaag\n", + "capcacugugaccuuugaagauguggcugugaacuuuucccaggaggaguggugucuucuuagugaggcucagaggugcuuguaccgugaugug\n", + "ggcacugugaccuuugaagauguggcugugaacuuuucccaggaggaguggugucuucuuagugaggcucagaggugcuuguaccgugaugug\n", + "auucccaccuuguccupcugagaucccagguuuguaacagaaaacaccacuaaagccccagcacaggagagaaccacccagcccagaaguuccapaaggaacucuccgguccacc\n", + "paggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "ccgucauuguguggcacuggacpaaucaagagacccgguuucuaaucccugcucugucacuaacaagcugcgugaucuucg\n", + "gcuuaauuuuuacuaucuuguacaaaugugauauuggcagccgucauuguguggcacuggacpaaucaagagacccgguuucuaaucccugcucugucacuaacaagcugcgugaucuucg\n", + "ugaccacuauacucauuuugaaagaguugugaaggcucuucugaucaacgcuuuagaugaaucuuuucupaacauuauaug\n", + "gaggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "auucuuuuagugaccacuauacucauuuugaaagaguugugaaggcucuucugaucaacgcuuuagaugaaucuuuucupaacauuauaug\n", + "gguccccggaappaggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "auuuuuuauagugugugguuuauagaaagacuccaggaauauucugugcugugguggaaauauuggaauaaucagccucauaag\n", + "pacuucccuugguccccggaappaggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "ggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "paggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "ggaappaggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "ccagaggcpacuucccuugguccccggaappaggagcaucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "aucgcuuguccugagcugguugccpcapcggaggcggaggcagagguggaggcgcuuugaaag\n", + "gucguupcgugcgcagcugcagcggcgguugaggucaaguaguagcguupcugcggcagcggaggagcucaac\n", + "auuuuccucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "uuuuccucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "gccaaapcaugaucauuuuccucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "cucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "aucauuuuccucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "ggucaucgupagcuccapapaacagcacaggaagccucuaucagugccagucpcacaggacacugccugccagucacccugagag\n", + "acuguaagaggccaaapcaugaucauuuuccucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "aaaguaccacuguaagaggccaaapcaugaucauuuuccucuuucacccugucuagguugccagcaaaucccacpccuccugacgcugccccupccacaggucccucgagugcuggaagg\n", + "acuccucucucucuuccucucucacacguucuccaacccaaggaggccagacagapacguggucacucucugaaaaguucaacuugag\n", + "gagcauuaaguggaaguggaugaugcuagugcauaagcagugaucagcaaaugcuggagucccugccuuuccuuuuguuccagugguggag\n", + "cccgagcuccauugcggaagcugaggcucgccauauugugcggcggcgccggcguccgcggcagcugauaccagagucuugcuccggccgcggccagcggagcccupcupcaggagccg\n", + "auauugugcggcggcgccggcguccgcggcagcugauaccagagucuugcuccggccgcggccagcggagcccupcupcaggagccg\n", + "ccauuuuguuuucgaucguuaagupcacgugguggagcguuggugugucapugucgacuucuuccacaaacuauu\n", + "uaagagacagcagcaggapacuggacuggauuguagaaaacuucaagaguuaaggagugcggagugcugcucaggugccuuuguuucag\n", + "agucucacucuguuacccaagcuggaguguagugaugcaaucacagcucacugcagccuugaccuccugaacucaagugauccucccaccucagccuccuaacupcuacag\n", + "auucccuguuucugcuuuaaccupcugcuugcuaagugcuugccucucaggauccuuguggag\n", + "cugaacuugcaaaacagauuggaacuucaagauuaucaauaaucggagauacguauauuuuauuuguaaagaaaac\n", + "gcgcuguccacgccccgaggccupcucaggccgaaguugcuccacagcacccccagcugacagccagcgacuggcagagcccccaggcacpcccucucucuuccag\n", + "guccuggucccggcuucucgcacccucaugucagccccggccccgcccggcggccugcggaggacaaggucagg\n", + "ccpcgcccgcgucgcugccaccgccggaagacagacgucccccaaaaccccucgccuggcucggacccacggagccggcagcccagcacuccg\n", + "cagccpcgcccgcgucgcugccaccgccggaagacagacgucccccaaaaccccucgccuggcucggacccacggagccggcagcccagcacuccg\n", + "gucgcugccaccgccggaagacagacgucccccaaaaccccucgccuggcucggacccacggagccggcagcccagcacuccg\n", + "ccccugacuuguggcaaugccaaucugugccucaguuuucucuuuggaaaaccucugccuucuuucccgacuuuuuggaaagaugagaauuugaapucugugccucuaccuaccuagaaacaa\n", + "agccagcccccaagcuggaaaaggagcuccuagaaggaacuucccuucccagccuucccagcuggagucucauccuucugaggapucagccuggagc\n", + "gupuucguucccpucccgcgcgagcuuucccpauaaguagcuuuagcgaucpagacagccpcgcugcaag\n", + "gupaacuuugaggcucagagacagagcagaagacagaaccuggucuucugauucccuguguucugcuuuuuucauuguuccacuggacgcucaucagapaagaucuuuuuccucaauug\n", + "ggacauggaugaaccuggaaaccaucauucucagcaaacuaucgcaaggacagaaaaccaaagaccgcauguucuuacucacag\n", + "acuuuuugucugupuucguucccpucccgcgcgagcuuucccpauaaguagcuuuagcgaucpagacagccpcgcugcaag\n", + "gucacuuuuauuupuguggacagcugcuuucccapaguacuucuuacagupauuucaagacaagaucggccugaagaaaaauuauauuuguauauuuuuuaaaaa\n", + "auuccaacaaugucucacccaucuuggcugccacccaaaagcacuggugagccccucggccaugugccugcacgg\n", + "aaugucucaguucuguucccuucaggcuucgagaccaccgccuugcugugucccguaguggacugapccugcaagapagugapcuaguggapccagcugccugupcuggacaucgu\n", + "aggaauugaagagaauccugacaaguggcauguupaaaggccugaaggaagccagaccagcuugcucucagagcuccuupuccccugcggcccccaggugaucuucagcaagaccug\n", + "auuucucuuccgagagcuucaguuuccucacgugccaagcggacpuuggaaguuggucuuugccagcucugacaccuu\n", + "accuccuccucugccucugccuccgccuccagccgccgccgccgccgccgccgccgccaccaccaccgccgcugccccggcugccuccucccugag\n", + "gauuauccugcugcugccgccaccgcugcugcugcucugcaaaauucagcugcugccucugucuugaggaccccagcgccuuucccccpcc\n", + "guagupccugcggupagupaaggaaggcggapaaccaugcgagguucugagaauugcggcgapucgccucgagagacgguuucugag\n", + "ggupagupaaggaaggcggapaaccaugcgagguucugagaauugcggcgapucgccucgagagacgguuucugag\n", + "pcucauucugaggccccauccccuuccagcaggaauucugaaauccccaccacuuccucccuccpauuugauccccu\n", + "aggaaaacugcagacagaaaaauguggccggaugcucugupcpcggcagcgauguucggccagguggcuccaaggagaggaagcagugaugcauugag\n", + "gcuguuagugcgucgcagcugcuggcgauccggcgacccucggccggcaggacccgcpccacgcagccpccuucucaacgccucaguaccucggcpaccgcc\n", + "agaggcugugagcuccacugugagcugccaaggcccauacugcupaucuuuaaugcauggcgcaaggcuccugugccccaaucccggaggagcggugacaguccapaagagapaccac\n", + "acuaucauuuucaucagcuucacaaccccucaguucugagaacccuccuugccauacaagccacuggagugucugcguuuccuuucuguggacauugucaccuuucccuucauuuug\n", + "gaggaggaagacgcccagcuucggaaugcuugaggcauaaaacugauccuugguuaagaucagcagaggcuugcugugugcaacauaaauugucag\n", + "aacaaccaaaugccagauuugauucuguagaguuuuuccuguggaauauccucaccgaaagagcuuuucuccuaauaacuucaca\n", + "agauggaguuuugcuguguugcccaggcuggucuuaaacuuugagcucaggcaguccacccuccucggccuccuaaagugcupauuacacgu\n", + "cgcgcccgcccaccccgcuccpcgcgcucucpaaggcuuggaccgacgcggcccagaggccaggaacauuccgcgcguggaccagccpccapcg\n", + "accggaccuuggugcgcugcaccaagcuucccgcucggagcaapuupacgacggaggcuccucuuaguaaaagg\n", + "gccaacacauaugaaaaguacuggccauuuuaccagaagcaaggapcauuauuuucccaaagaucauuugaaaaaggcuguugcugaaauugaagaa\n", + "accccgcuccpcgcgcucucpaaggcuuggaccgacgcggcccagaggccaggaacauuccgcgcguggaccagccpccapcg\n", + "aaggcuuggaccgacgcggcccagaggccaggaacauuccgcgcguggaccagccpccapcg\n", + "cccaccccgcuccpcgcgcucucpaaggcuuggaccgacgcggcccagaggccaggaacauuccgcgcguggaccagccpccapcg\n", + "aggcgacugguuguuaccgaggaagauggcggcgccagacccgaggcgcuapaagaucgcaccgcggacgcccgcugagcuuggcgcacpccgaccag\n", + "cgccucaggcgacugguuguuaccgaggaagauggcggcgccagacccgaggcgcuapaagaucgcaccgcggacgcccgcugagcuuggcgcacpccgaccag\n", + "cggcgccagacccgaggcgcuapaagaucgcaccgcggacgcccgcugagcuuggcgcacpccgaccag\n", + "caccucggcugcugcccggcagcggcagcagcugcgucggcggcccacacagcagcgagaggcgagaggaggcugccucgagg\n", + "auguuuugauacccccauauaaaauaaucugucugucaupagcccccacguccucugaaauaguucagcucugucugcaugacuuguccupacugaggaaaauuuaccag\n", + "puuaguaucauucaaggauguggcuguggauuucacccaggaggaguggcagcaacuugacccuucucagaggacccuguacapaugug\n", + "gacagcgguucccauuaagcggugauggugguuuupaccugauaaucgagcupagucagaggcpaugugugcggugaagg\n", + "agaagcacagugagccgaggagccuucauapacagccgccccuggugcacacacccucguauucuccugcccuuccccag\n", + "agugagccgaggagccuucauapacagccgccccuggugcacacacccucguauucuccugcccuuccccag\n", + "augcaccaaggaaggagupccccuucuucacuauggauggagaagccucagagaguaaguggcaacag\n", + "gugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "uuauauagaccggcggcggagcacgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "apugaguggcaguuauauagaccggcggcggagcacgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "ugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "aauuuaaauaggcauuguauguuuguuuaauuauauugugcuuuggcuuccuuggacgaaacuauuacugacuuuacaaagaagaauggauaauuguggaaguag\n", + "cgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgc\n", + "agaccggcggcggagcacgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguagguac\n", + "gcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "gcggagcacgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgc\n", + "ggcggagcacgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgc\n", + "gugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "gucgcccgaccuggccgcaacaaguuapugaguggcaguuauauagaccggcggcggagcacgcgugugugcggacgcaguugcgugap\n", + "auagaccggcggcggagcacgcgugugugcggacgcaguugcgugapuuuguacuauccucggugcuguggugcagagcuaguuccucuccagcucagccgcguag\n", + "acauuuucuupcaucugugaccaguaagaaucuuccacccaguggagcuguuccaguuacupauaccaccucauguuguuaaaguaccagcuucacag\n", + "ccccguccagagucuaagccugaaucucagauuccaccacaaagaccucagcpaucaaagagugcgagaacaacgaauaaauauuccuccccaaapacccagaccaa\n", + "cuucucaaaagacugaggcagcagagaggauuacuugagcccagauguuugaggcugcagugaccuauggucaugcuacugcacuccagccupcgacacaggagacucuuaaaagaag\n", + "gucgcccgaccuggccgcaacaaguuapugaguggcaguuauauagaccggcggcggagcacgcgugugugcggacgca\n", + "aggcaugaucaaggacapuugccugccaagaacaggapagaggapcuggagguuucaggagaaagaagc\n", + "caauaccugaacaccuucuauggcugccccaaggagagcugcaaccuguuugugcugaaggacacacuaaagaag\n", + "agauguugucuugugagcgugcgcgcgccuggcuggapcacugagccuggccgcaguguugc\n", + "agacapuuucaacguguuagccaggauggucucagucuccagacccugugauccgcccgccucggccucccaaaguguupauuacaggugugagccaccgugccuggccgaggcuccuucuuuu\n", + "cucccuuucaucagucuucccgcguccgccgauuccuccuccuuggucgccgcguccuuggcuggcgu\n", + "agaucugguucgacaaguucaaauaugacgacgcagaaaggagauucuacgagcagaugaacpccuguggcag\n", + "gaggcggcacagcugcpaggagcggcuacggcaguacgcggagaagaaggccaagaagccugcacugguggccaaguccuccauccugcuggaugucaagccu\n", + "ccpcggcccucccuuucaucagucuucccgcguccgccgauuccuccuccuuggucgccgcguccuuggcuggcgu\n", + "cccuuucaucagucuucccgcguccgccgauuccuccuccuuggucgccgcguccuuggcuggcgu\n", + "cauuucccgugcgcggcccpcggcccucccuuucaucagucuucccgcguccgccgauuccuccuccuuggucgccgcguccuuggcuggcgu\n", + "auguguggagaccuccaggccgugcagcaccuugguggccacagcucuccaggauguccucaccuuccucapcccugcccuccugaccuggaguguucugg\n", + "gguuucaacguguuagccaggauggucucagucuccagacccugugauccgcccgccucggccucccaaaguguupauuacaggugugagccaccgugccuggccgaggcuccuucuuuu\n", + "ggcccpcggcccucccuuucaucagucuucccgcguccgccgauuccuccuccuuggucgccgcguccuuggcuggcgu\n", + "agacapuuucaacguguuagccaggauggucucagucuccagacccugugauccgcccgccucggccucccaaaguguupauuacag\n", + "acaaugcccugucuccupcucuugcucccaccccacccccaacccacaaccccugccucugcccaucagccuggccuug\n", + "ucccuuucaucagucuucccgcguccgccgauuccuccuccuuggucgccgcguccuuggcuggcgu\n", + "uagagacapuuucaacguguuagccaggauggucucagucuccagacccugugauccgcccgccucggccucccaaaguguupauuacag\n", + "gcacacccggaagcggcggaguagagcggagccuggcpcgupaacccaggccccgccgaggcggccag\n", + "pcagcgccugacaugccugauccucucuuuucugcaguucaapaaagacgagaucuugcacaaggcacucugcuucugcccuuggcupaapuggc\n", + "uaggauauaucugcaucuugaaaggaagauaaaacaaaagccuucuuuggaauagauggauuuuugucacuuucugugugaacuaaagugauuca\n", + "uccagugaguugcaagcuuaaugcucaccugcagagacagaauuccugagugaacgaacagagcagcuccucuuccaucuccag\n", + "ggucucauucuguugcccaggcuggagugcaguggugcgaucucggcucacagcaaccucucugccuccag\n", + "auggagaacuuaauguucuggaugauauuuuaacugaaguaccagaacaagaugaugaacuguauaauccagagagugaacaagauaaaaaugagaaaaagg\n", + "acugcccuccggccgccgcgccgcccgcccgccpccccgcuguccgccgcccgccgccgcuggagcuagag\n", + "gaaaaaaacagaccacaucugauccuuggcccugaguccagagupaggcaccgugacaacaaugcgcagagcapaaugcapagccauggauagugcup\n", + "cagcguugcuguaaccgacaaagacaccuucgaauuaagcacauuccucgauuccagcaaagcaccgcaac\n", + "gcuucucacggcauucagcagcagcguugcuguaaccgacaaagacaccuucgaauuaagcacauuccucgauuccagcaaagcaccgcaac\n", + "auuucuacuuugcccgcccacagauguaguuuucucugcgcgugugcguuuucccuccuccccgcccucapuccacggccaccauggc\n", + "agguggacaggcccggcgcgcccucucgaggccccuucaaccucccpcagcagcgccgugucggcuaugaaupccucuggaaaacucaggcuuggaacag\n", + "cagcagcguugcuguaaccgacaaagacaccuucgaauuaagcacauuccucgauuccagcaaagcaccgcaac\n", + "ccccgccuuuauucagcuuccgguagacgcugguapuaapagcuaaguagaucacuuccpcgacuguuguuuuauuuccgguuu\n", + "gaggcggcagcuggaaccgcgcagcgcacpaacgcgucccgcugcuupucagguucgccggucgcpagccccgccgugcagucggag\n", + "apugucacucugaguggugcuuccucagccccugucaaaaagcaguuuccaccauccuggagugugguag\n", + "pcgagapcggagcguggaggcggcagcuggaaccgcgcagcgcacpaacgcgucccgcugcuupucagguucgccggucgcpagccccgccgugcagucggag\n", + "apugucacucugaguggugcuuccucagccccugucaaaaagcaguuuccaccauccuggagugug\n", + "cuugcuacgucuccuuccucuuccupcugcgacacuggcccuguggcupuuacuguucccu\n", + "agcagcgcgcaggcgcacgucaguccccgcgcuuuucggaggcugccagcgucccacaccagccgcag\n", + "gauagcagcaucaaggagcauuguguacaugcagaagugcacaguaccuggagugaaacugcuuguguucgauuucugauaccauucauaacuggcugugugaucucaa\n", + "auaagaaaacugaagaaccagcupcgcgguagcucacgccuguaaucccagcacuuupaggcugaggcpuggauuaccugag\n", + "acggcgcgaguccgapcgacagcagcgcgcaggcgcacgucaguccccgcgcuuuucggaggcugccagcgucccacaccagccgcag\n", + "auuuaaaguauuuucuuuguuuuccuucauacugauuuucauuuuuauuguuuguuauagaaccucuaaa\n", + "auuuuccugcagucacugcuggcagaugauagagccaggauuugaaagcaggcagccuggcuccagacccugugcucuuaacucccguuuugcaucaagaacagaauccuaugaaag\n", + "ggcgcgaguccgapcgacagcagcgcgcaggcgcacgucaguccccgcgcuuuucggaggcugccagcgucccacaccagccgcag\n", + "ggcagaaacccggauuccgguuccggupccuccaucagcaagcuccagugcuacgugucccuggcauuuuaggugucgguugg\n", + "ggucucacccugucacucaggcuggagcacaguggugugaucacagcucacugcagccucgaccuccuggacucag\n", + "agaupuggapacupaaaggcuguuuacucccuccugucuagucggcuuggucccuuuapcuccggauaucuuuggugacuuguccacuccaguguggcauc\n", + "aaacugccugcagcpaccggaccugcacaggccgccuauggcpcggcpupaccgcgaguuacagccggccaacupccagccaggagccugapucggaagcccccaacacaag\n", + "aggaagguaccggcucuacugccaccucuuccagcuccaccgccggcgcagcapaaaggcaaaggcaaaggcggcucpagauucagccgugaagcaagugcagauag\n", + "ggcaagaaguugcaggaaaaauggcuucuagcaguggaacuuccucauacacgugaucuguuucugauuagagaacugcaggaggugaaaauupuucaag\n", + "cuguucpucuugucuggauuuugguugccuccuccaauguuccucuaccucuacuacaaggaupuc\n", + "gcgcccggagcccgcggagcugagcggcggcggcggcggcggcaggagcccpaggcggaggcpaggcggcggcggcgcgcggagacgcagcagcggcagcggcagc\n", + "uuuccpugaaacuggcauugapuacupcgugcgugaggcguuuacugaugcuuccugguccgguggccucggucccgguaagccaggc\n", + "ggcauugapuacupcgugcgugaggcguuuacugaugcuuccugguccgguggccucggucccgguaagccaggc\n", + "uucauuuccpugaaacuggcauugapuacupcgugcgugaggcguuuacugaugcuuccugguccgguggccucggucccgguaagccaggc\n", + "auuuccpugaaacuggcauugapuacupcgugcgugaggcguuuacugaugcuuccugguccgguggccucggucccgguaagccaggc\n", + "aucccgcgucgcuguugucgcuguugcagccgaguucagccpagcagagcgaaccgcaccggcccgagcggagcgccgcacguucccaaccgcgaggccag\n", + "guuccuguugacagcugucgccuugcucuccagcuacuccauccaccugcuacucaaguccucapucgugg\n", + "gcauccgugccuaugagcagcupcuaccgugccuuupaccccaggaaagcuggcagcagcccuggccaucacgcuccagaacaucggag\n", + "gcagccgaguucagccpagcagagcgaaccgcaccggcccgagcggagcgccgcacguucccaaccgcgaggccag\n", + "guugcagccgaguucagccpagcagagcgaaccgcaccggcccgagcggagcgccgcacguucccaaccgcgaggccag\n", + "ggacuupcggccccuccgcaggcggaccpcaaaggagguggcaugucggucaggcacagcapuccuguguccgcgcugagccgcgcucucccugcuccagcaaggacc\n", + "cccagcucuccucccccuuucucucuaaggauggcccagaaggagaacuccuaccccuggcccuacggccgacagacg\n", + "uacpucccaaguuugacgacagaacccgcucuggucauuuguagccacauccugucaggugcugccaacgugaaucugaccagccagugacucccagcug\n", + "gcuccaucuggccugagcacccugccccagcgaguccuccggaaagagccugucaccccaucugcacuuguccuc\n", + "agaaggaaaaacggugcccuacugucuucagacgucgcaaggaucaagaagauuucuuucuucaugacccugcccuugccagaauuuccugcgcuguuccaccucauucaacuucag\n", + "uuuuuuuuuuuaauucucucucuuuggcucccuccuuccgcgcgagucucuggagaagccgcagcgcgaguugccgccgcugcugcccpccgg\n", + "gaaaaacggugcccuacugucuucagacgucgcaaggaucaagaagauuucuuucuucaugacccugcccuugccagaauuuccugcgcuguuccaccucauucaacuucag\n", + "uaugacccugugugacucagugacccggapcaagcaggacugupugacaccuugugucauccucuga\n", + "ggagccucagccuucgccgccgcugccgcugccgucgcaguugapcgagcacccgcccgcccgcugcapacgccccgccaacgccacugccgcuucag\n", + "gcgaguaagugcaggugccgguggcgcacpcucpuaguucupaaccucupcgguccupacugag\n", + "gagucggcgccuuccucaagaaugccupacaaggagccagugcuggucguguccuucgucgucpccucg\n", + "aaauaacuggaauuugaaaggaggacagaggagccuccgcuggagcuapcuccguuacagauccuuuuggcagaaguugacaauupuaucaaaacaguggaagguguuucpag\n", + "gaguaugcugcugcuguuccgcuuugcguccucgcuacaaacgccugguggacaacauauucccugaagauccaaaa\n", + "guuaaucuuucuagcuguuuaaguucuuugaagucaauuuauccugcucagaagauagguaagua\n", + "gacauuuuauuuccuuacaucgaagaaaauguuaaagaguaucugcagacacauupaagaagaggagugccagcaggaugucagucuuuugaggaaacag\n", + "gcugaagaggacgcccaccuggaupcuguuccuaucccugcagcaucupaauggaguggaugaucugcaacag\n", + "aaucugcupccuuagucuugaauuuccagccuccauaacugugcaaaauccauuucuguugcuuauaagcuacccagcuuaupauuuuguuuagcagcccaaauggacuaagaca\n", + "cucaauguuagaagacuucuuucuccuuccugcuggagaaauucaacugcauugcauggagagcuaauuauauggagagaca\n", + "accccucucccgcgcccgguucucccucgcagcaccucgaagugcgccccucgcccuccugcucgcgccccgccgcc\n", + "gucuugacaagagcaucuucagcpcgaguccccggcuccuccagcuccuuccuccucuuccuccuccuccuccaccuccggcuuuupaucacuguccucucucggcagcag\n", + "auacaggcugcuccucaagacupcucuucacauacgcuccucaccgcucuuupcaggccgaccuagcagccucuucpaguccupuggccpugcuggagccccca\n", + "gagcaucuucagcpcgaguccccggcuccuccagcuccuuccuccucuuccuccuccuccuccaccuccggcuuuupaucacuguccucucucggcagcag\n", + "gcaucuucagcpcgaguccccggcuccuccagcuccuuccuccucuuccuccuccuccuccaccuccggcuuuupaucacuguccucucucggcagcag\n", + "auucauugucuugacaagagcaucuucagcpcgaguccccggcuccuccagcuccuuccuccucuuccuccuccuccuccaccuccggcuuuupaucacuguccucucucggcagcag\n", + "ggcucaggcaggccuggcccagagucacgcuggcaaccacgaguuupaagcagucguauucucucucucucucucucucucucucucaguauccaugacag\n", + "aagcaagccucuuauaggcagcauaaguugaguguuuuuaaaaauccauuuaacuacuuugccuuuuuauuggagaacuuaauccacuuacguucapuuaucauucauag\n", + "gcugcugauacuuuggcugugaggcaaaaaaggagaauuuaugauaucaccaaugucuuagapaauugacuugauugaaaaaaagucaaaaaacaguauccaguggaa\n", + "gugguacccaguccucaggugcaacccccugcgugguccucuguggcagccuucucucauucagagcu\n", + "puugcagcagcucagacaauccuuaccaugugaaaggaggaaugacugucauggcaugaaaaaagcaucacuaug\n", + "aucccucucuucuuucapuugcagcagcucagacaauccuuaccaugugaaaggaggaaugacugucauggcaugaaaaaagcaucacuaug\n", + "aucuccugcaugcacaguugcaguuaguuauuccagguauuauuuuuguuuucagaaaaagaaaacucaguagaagaua\n", + "aaauagaapaggaggaccuauuuuguuccauccuguaggcugauccuuuacaccuaggacuggaagaaauaag\n", + "aaacagaguaucacuauguggcccaagcuggucuggaccuccuaggugcaagagauccucccaccucagccuaaaacacagauuuuaaugcccaauuuuguuauaauaagaauuaaauaaguuaau\n", + "aauuuuuuacaacaccuuuuuuuuagauauguguacuuccugauaagcagagaugaugaaauaauggccuauuaaaagcaa\n", + "cuccucccuauucuagaaauagaapaggaggaccuauuuuguuccauccuguaggcugauccuuuacaccuaggacuggaagaaauaag\n", + "guaaaaggccgcggcaggcgaagagagaagaggugapcggucgucagcuaapccccpcucgcppugcgcapcag\n", + "agcaaggaccpcggcggupcapuguagagcucpuucccagcggaaagcauguccaaggagcggcugccggcgaggugaugcuucugccupccuacuupaccggaa\n", + "aggcgcpcccagupccguapcgacauuguugccguugucuuucccccccagucccp\n", + "aagaaaggcacuuccggugucuguugccaggcgcpcccagupccguapcgacauuguugccguugucuuucccccccagucccp\n", + "ggcagupagcagcggcagcagcuucggcugcugcuuucaggcugccgcugcauuapcuuccugaggaagcgcpcggacgacagaggaugccgaaccacucca\n", + "ggaaauacugaccccauaaaccuaaaucucacacacgguuuuggacguuuaaacgaauggauuuaacagccuuuuggaauucagccuguuu\n", + "gucaacauaccuggccuaaggaggcaggauugagugacucucacucaccacugguguugcucuuugaaaguggcgcuuggcaccagcaugaacuccccauccucagcaaucccaucagguguuuugg\n", + "gcaucuuugguccuucuguuacccagcuccuggaggcaguggcuguagcagcccuugcugcuccacacc\n", + "pccuaucgcuccuaccugaucguguucuucgugcccauucuccugcugccucugcccauccucguccccaguaag\n", + "ggacuguagccgguaccggcaccggagcgcgccpuccucgccpucccagccccgcgcgucggcccagcccagccpaccccccgcgacaugcgcgucccagcccugcgcugagcaggcggca\n", + "paggccgcupagccccgcgaggcgccaggcgcgaggcccggcgcgcgagcccccpcgg\n", + "gaauuaguugccaucaapcucucuccucccugucuccuuacaugguuuugcuuaucuggagaguagcuuuuggccaagaccuggcaguggagagcc\n", + "gugagagaacgccgagccgucgccgcagccuccgccgccgagaagcccuuguucccgcugcupaaggagagucugugccgacaag\n", + "cacauuguucuuaaugaggcuguuuugacauccuacuagaugcgagauaagcaggccagaccuuaaagg\n", + "gacuuguaggugagagaacgccgagccgucgccgcagccuccgccgccgagaagcccuuguucccgcugcupaaggagagucugugccgacaag\n", + "gcgcggagagcugcgugacgcggcggcgcgcaapacgugcggagugaguggcgcugcpupccgucggcggcgcug\n", + "agugcgguugcgcggcggcccaggcgucgapagccucggcpagcgcaccgcgcgccugcgcggagagcugcgugacgcggcggcgcgcaapacgugcgga\n", + "ggcgcuggugagcuuugcggagcupcggugccgaggaggaggagguggcggccupucugacgcggcccuguucgapccucucuuguuuauuuauuuauuuucc\n", + "gagcugcgugacgcggcggcgcgcaapacgugcggagugaguggcgcugcpupccgucggcggcgcug\n", + "pcaggagagcauuccagucgagaagaccggcugcaguaaaagcgugapuggaaacgcucgag\n", + "aacgaggaugccacucagagagaccagapacaaacaccacagccaguccugccacagcccugccacaaaaaa\n", + "ggagaccaugcgcaggcgcggugcacugugcgcpcaccacggcgguuuuucgacgcuggcgguggacgcaggcagcauggaccacgguugcupcggaupagcgucuauggucag\n", + "acugugcgcpcaccacggcgguuuuucgacgcuggcgguggacgcaggcagcauggaccacgguugcupcggaupagcgucuauggucag\n", + "gcuguguuuccgugcuguggaguugccugguccgcuuccuccccgcggugagucuaaggaccuuuacggaugcggagaag\n", + "aauaagaauaaaagauucuggaggaguuggagaagaguguauucagcccccaaaccacgagaucaacaaa\n", + "uuagguccacaaagaugugagccccaguuupugguggcaccacuugaauuuucccauacuuaaagcugacucacuagaagucuupacaagucaucgaauucuauaau\n", + "agcauccgccuggagcucguggcgcuguguuuccgugcuguggaguugccugguccgcuuccuccccgcg\n", + "guguuuccgugcuguggaguugccugguccgcuuccuccccgcggugagucuaaggaccuuuacgg\n", + "aguauggaggcagcgguagcccagugucugagugguugccpucuccauggagaagcggcucgccagugucccaggcugcugagcucucgccgcccgagaccccgcggcgcggccgcapcc\n", + "gugucgcguggcccagcgucggcgugacgguuggacgcpcgcggcacugcpucccgauugcugcagccgcuugucagugugaugaagauuggcacccag\n", + "acaccauucgcuuuucacccaagaugauuugaugucuuauaaaacucugaugaaccaugauggcuacacagacauuaaguauagacagcuaucaagaupcaacag\n", + "augcaaguaguaacagaguuaaagacagaacaagauccaaacugcucugaacccgaugcagaaggagugagcccucccccuguggagucucagaccccgauggauguggacaagcaggccauuuauag\n", + "agagaagacuggcgaaagugaugagucuaaaaaaguagucccuccgguuccucuguuuccccccauguggcgucaggaagcgag\n", + "ccccagcccucagagcaaccucagcccagcccagcccagcuccagcuccagcuccagcccpccccauc\n", + "gacucucgcgagaucccuacuggcuauaaaggcagcgccccggagagcucuugcgcgucuuguucuugccuggugucggug\n", + "gucccaggaagguggcgucagcaucugcagccgcgucgacguugucggagccuccgcggaggacccaggagagccggacuaggaccapcccupccuccccacacucccc\n", + "acccugcuguguugagaugagcaccagagccaagaagcugaggaggaucuggagaauucuggaggaagaggagaguguugcuggagcuguacagacccugcuucucag\n", + "gguupuguguguaggcuuggugugccucuagcuuggupaugcaagcugupcaucucugagcugcugupcugucaucccugcga\n", + "acguaaccuacggugucccgcuaggaaagagaggugcgucaaacagcgacaaguuccgcccacguaaaagaugacgcuug\n", + "aaaguguauupaaaccucucaugaacccugugagcaagccaccgucucacucaauuugaaucuuggcuucccucaaaagacuggcuaauguuugguaacucucuggaguagacagcacuacau\n", + "accaggacaacpcgucgccggcgccgugugacuucpcugupcucgcucgcggcucuucggcc\n", + "gucaccaggacaacpcgucgccggcgccgugugacuucpcugupcucgcucgcggcucuucggcc\n", + "gagcuapcguagcugugauuucapcaccucuggcggcugccgugauuugagaaucucpucucuuggcugacugauccupagacugugg\n", + "agagacccgcucggucccgaccgagagcuggcgucaggagccgcapucacagcgugucuuugaagcugccuccgccgccacc\n", + "gcccugagccugugcaauuauuucgagagucaaaauguggauuuccgaggcaagaaggugaucgaacupugcpacaggcaucgupaucuuggcagcgcugcagg\n", + "gcucguuccacapacaccacgacggcucgcggcccccagccucuaccccgcuccggauccpaucugagcgccggccgcggugcccaggcacucccuuggcpccgg\n", + "acuucuggcgguugaugugacccuggccpuaacugcccuuucupcacaaguuccccuucucccgagacuggcugccua\n", + "gacguccccucccgcccgcgaccugccgaccugcpaucguuagcggucccagcccccgucuagauucaaauccgacupugaaggaggacccgaggaggacccacgcac\n", + "ggcccaucugauuaaacagaccaggccacucacuguggaguggaccaaggauacuccugucccugagccc\n", + "ggagccccacccaggccupcccuccagccagccacaucccucugucccccaccacccacgapaaucupuccccapcacagccggcucagccuccaagcugcagacgagu\n", + "uggccgccaaggccuacgugcccuggaaccagcpcugcugcugguggugcugcpaggaggcccgup\n", + "uugucagaugcuuguccucgucacccugagcuuguuggcugcuaucuaauucuuauucuuucauuuucuugcccgcacguucuugauagcagaucacugacaacagccauuggaagcuuaggaaaagg\n", + "acccaaauuuuccagccgaucacuggagcugacuuccgcaaucccgauggaauaaaucuagcaccccugauggugugcccacacuuugcugccgaaacgaagccagacaacagauuuccaucagcag\n", + "ccgaucacuggagcugacuuccgcaaucccgauggaauaaaucuagcaccccugauggugugcccacacuuugcugccgaaacgaagccagacaacagauuuccaucagcag\n", + "acuucucacuuccgcuuccuuccaguaaggagucpucuuccccaguuuucucagccaggcggcggcggcgacuggca\n", + "cagaggaggaggaggacgaguuguaccggcagucgcuggagauuaucucucgguaccuucpagcaggccaccggcgccaaggacacaaagcca\n", + "apccccaguggccgccgcggagcgagguugccuggagagagcgccupcgcagaapuuaacpccaccpcucgcagagcag\n", + "gapugcucucggacggugugucccccacugcacuccugaacuuggaggacapucgccgcgapacgcag\n", + "agagcacccuccacgcccagaugccugcguaguuuuugugaccaguccgcuccugccucccccupcaguagapagcg\n", + "acugacguggccgcpaucagagagaagcgapccugguucugapucggcuugagaucggcugapaagcpcucapucugugaggaggcaag\n", + "agacggcuccggacpaccgcgagcacaggccgcuccgcpcgcuucggauccucgcpaccccacccucucccagccugcccagcccgcugcagccgccagcgcgccccgucg\n", + "aauccacugccuagcagguggcccauuccaguuggagaacguagugagucuuucaguggagccapucug\n", + "gguggcccuupuapugaagauccccugucuuuauccuaguuccacaccuuggugupuuacupugcagg\n", + "agguggucuggagccugccpagagugguggcaucugagaggcuggucguggacugugguupag\n", + "aguccagcgagcagcacggcpaaccggcagccggagcagucccggagcagaagcagcagcagcagcagcagcccucgccguucgcggagcgcagccgagccggcc\n", + "agagauuuagaugacagagaaacccuuguuucugaacaugaguauaaagagaaaaccugucagucugcugcucuuuuuaauguugucaacucgauuauaggaucugguauaauag\n", + "uagccccauuuugacuccagagucugucuuucuuaauauuccauaacccuucugugcuccuuauuauccucucugcuuucuuggcuagcag\n", + "ggaucuucugcauuuaaaauagaagaggcaucaugcugaagapapaagguccaaccuuacacuaaaacccuggauggagg\n", + "cgguucaagcucuacguucgugacaucaaaccuccuguupccauuuccgagaacucccaucaguuucuguauaguguaaaag\n", + "gccggaagcugaapaugcuuugaacguppcugcgucacaguuggacucccacuugcagaggaccugauu\n", + "agaggagauugccggaagcugaapaugcuuugaacguppcugcgucacaguuggacucccacuugcagaggaccugauu\n", + "ggaaggagcaaaagccccuugccaucccugugugacagcaaugaggugaacccapccgaagcccacccapaguugaug\n", + "cagcapccgguggccgcggagccgcacugcpcaguccccgccuccgcuccppcggcccag\n", + "aagapugcugcccaccggaaacgauggcgcgaggccgcagagcuaaaupccucuccapagugcucuguucacggcuccaucgcuguua\n", + "pugcugcccaccggaaacgauggcgcgaggccgcagagcuaaaupccucuccapagugcucuguucacggcuccaucgcuguua\n", + "ggaggcpacaccuccccggcggccgcagcgccgcguccccucucuccccgcgcugaggcugcggaccpcccggcpauuagcag\n", + "gagauugccggaagcugaapaugcuuugaacguppcugcgucacaguuggacucccacuugcagaggaccugauu\n", + "cugucugucucagccugcccupacccgaggucapaggaagugccgcaucuggucuuccccagagcgagagu\n", + "aggcgccagcccagagcagccccpcaccagcacggacucucucuuccagcccaggugccccccacucucgcuccauucggcpagcacccaguccuguacgccaaggaacug\n", + "cacuugugcugagcuacuggcugauccccaaggacauccuucuggccucuccuucacaccupuccccuagcccugc\n", + "agugccuuuggcgcacugaggugcacapucccuuagccpcgcapcgcgcagcccaggcugagauccgcggcuuccguagaagugagc\n", + "ccagugccuuuggcgcacugaggugcacapucccuuagccpcgcapcgcgcagcccaggcugagauccgcggcuuccguagaagugagc\n", + "guagccucagccccuguccpaccugugcaaaugacccuggaguugguuucgcuuucuccccuugcggcggugugaacguguguccgcagcgug\n", + "gauccaaccuggagaaugaagucugugaggauuuuagugcaagucaaaaugucuuagaggacucgcugaagaac\n", + "augaagauccaguuucagacaugagacucguupugaucauuucauugagaucaaccugaaugaccagguguaaagugcaagaguaauaugcu\n", + "augaagauccaguuucagacaugagacucguupugaucauuucauugagaucaaccugaaugaccagguguaaagugcaagaguaauaugcuaugacugag\n", + "auaagccuccauguaagugacapcacccaaggagugcguuggaagcgccagcgugcccgagaccagcacaucgcaccgacgccuucguuugcg\n", + "cpcucgauuggccgcccucccccggcggugguaacggucgcggaggcpccugacguagcugaucccagccuaaccuggcccggcuggcugcuggupaggccggcgacugaguaag\n", + "ucguuupugauuucccucggcgguggaggucgcuccuaauagaggcggcggcggaucacccgaacagccuucaggugcuucccugcugaccucuuuuuaacgug\n", + "ggaagccucuggugauucaguuaccucugacuggcuuguugaauuuaauuuuagugcucgguuaugaagauuauuuggcucucaca\n", + "gcgacguacuguaagacgauauuacuuuaaucaucuucacaucaguauuuauggaauagccacaggugccucauccuuuaguaggaguuaauuauacauuuacuggccgaguaaacaucuccgaaug\n", + "gcuggagugcaguggcaugaucguaguuuacuguaaccuugaacuccupcucaagcaaucuucccccaucagccuccugaguagcuaggacuacag\n", + "agaaugcacpcccgcgapcuccgcgcacagauccugcuccuuaggccggcaacccgaccccacggcacagauauggcuccuggaaacgcgcgucagcuggucaggugcccag\n", + "uauuuuuuuagauaaggaaauaaaacauuuccaauaaagcugaagucucaucccacccauccguuaucag\n", + "acuggcugccggapccpagucggcgcpcucgcpcgguggccggaacpugccpacggaucaccguacggccgaacgcgacccgaggaggcggaagagcggcgccg\n", + "guccccgcagugcucccggacccggcgagccuucpcgcgcgucgcugguggugguugaggcucuagcgauaauaa\n", + "augcagguggaagapuaggapaugcuggugccauuagcagagapcuagaccagaacaugccugcuuuuucaaca\n", + "cauguaagaagugccuuucaucuccugccaugauucugaggccuccccagccauguggaacuggaaauccaauuaaaccucuuuuucuucccagucucag\n", + "cagcagcagaguuaaguaguauugcuuuaauugcaacaagcugagcuaaugupaagaaugcaguagaguggcacagaagaaug\n", + "gugaggaacugaaguuuggacagauugagucacuuucucapacacauggcuggccggugauggagaag\n", + "gcgugagccccucgcuccagugccgcgugugcggagacagcagcagcpaagcacuauggcaucuaugccugcaacggcugcagcggcuucuucaagaggagcguacggcggaggcucaucuacag\n", + "agcaaaauggcgccagaacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "gcaaaauggcgccagaacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "gcauuuuccupcpaacagcaaaauggcgccagaacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "cagcaaaauggcgccagaacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "caaaauggcgccagaacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "aacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "gaacuaguggcpcugaggacgccguaccccucggaaggcagcccugcggucccuuugccgcccguucccucccggac\n", + "acucggcucugacuggcaggcagaaagugcaacugacgapaaaggucucugcagugaguggagagccuacauaaaagagaguaaagapcaaaaacccagaucaga\n", + "cuuugccaguccaucuucaaauuggaauuauagaaaguagapapauagucuaccgucucucacuggauuggugccaccuaaaacauuguu\n", + "ucuuugccaguccaucuucaaauuggaauuauagaaaguagapapauagucuaccgucucucacuggauuggugccaccuaaaacauuguu\n", + "agagcucggcacugcgccpcgcacggcucpacccaggcccagcuaccuucccuccgcccccpcucuguucucacuuuccagcaguggaaggacpaagcpagcc\n", + "aucucccuacagcagaagauugaauccucaucucuccaugagucugagcaucuaaagauguuagag\n", + "aaagucagauggcuuuguguuguuugacgugguuccuuuuccaaauagaugacuguaaagaugaccugaugauccu\n", + "agugccagaacuaacuuugacuuucacucuucgccaapcuugcagaacaccuuaaaggaaaaaag\n", + "uuuuccuuguuccuggucaacaaagaaauguggagugucuuggcugaauccucauacagacaagaucauuauggugcuguuagguaggacuuguauccagauguaag\n", + "ccucugcaggugugcgagcaggauugcuucugcaacaaaagccuccacccagccacaucuupaaaaga\n", + "uuccuuguuccuggucaacaaagaaauguggagugucuuggcugaauccucauacagacaagaucauuauggugcuguuagguaggacuuguauccagauguaag\n", + "gucucacucugucaccgaggcuggaguacaguggugcaaucacagcucacggcagcuucaaacuccupcucaagcgauccuccugccucacccucccgaguagcugagacuacag\n", + "gagaggcacucugcaaacacuuccucaaacuuuaggaaagcaaaaacauuccuucugcucaacacggcagaaaacapucucugccccuuggcgcupugaggaguucccaaagaccagccag\n", + "auucaggucccugcaccgcacuccgcucggaccccaggccgccggugcugucgcuacucaagugagucccgcggugccccucccgccgcgccgcccgucpc\n", + "aguuucuucuaggaauucggagccuccccugcagcgacucggaagauucgaggcggcpacaagucggcgccccagagcggacgag\n", + "gaaagguuuugguucuuggaucuggcuacauaucugagccuguauuagaauauuuaucaagagauggcaauauagaaauaaca\n", + "ccucagauuucucaggagaccagaacugaucugccagccuugcugccuuuuguugcucugcucuuuacauugucuuuacagucaccaggugucaag\n", + "aucccaguuucuucuaggaauucggagccuccccugcagcgacucggaagauucgaggcggcpacaagucggcgccccagagcggacgag\n", + "caucccaguuucuucuaggaauucggagccuccccugcagcgacucggaagauucgaggcggcpacaagucggcgccccagagcggacgag\n", + "gcagugauuacauccaacgguacauuaccugauaaauauaaauauauccagacacuccpagagcag\n", + "aggaauucggagccuccccugcagcgacucggaagauucgaggcggcpacaagucggcgccccagagcggacgag\n", + "aaagapcugcucaacugcaaggacgcuguaagcaggaagagaagccacagcgcuucagaaaagagupacapacaagcauaucuaagaggcugaac\n", + "acuuuaaagapcugcucaacugcaaggacgcuguaagcaggaagagaagccacagcgcuucagaaaagagupacapacaagcauaucuaagaggcugaac\n", + "aaauuugcucugucaccaggcuggagugcaguggcacgaucucagcucacugaaaccuccgccuccuggauucaagcgauucucaugccucagccucccgaguagcupauuacag\n", + "accaguaccagcccccaccuuccgucugugcauguuuucuucaguccuggaaggaaaucauaagugauuugccccaaaaggauugcuguuga\n", + "agucaucuuagupauuupaagcaacapcugugupuaaccugccaccuuuaaguggaaaucag\n", + "pacucgaacggaaguuccggcpcggccgapaagagugugucugcpagaaagaggagaaucgcccaagcggccucggaagucccapaguggag\n", + "ggccuccucauuccuccugagcaugaupcccucuggcucucuuuccccaggccuaggaucccugugacccucaac\n", + "gcucagguuuccuaccuuccggcugcuupaacuucuuucuugcccgccaagcccgcagccacccpcgcggcpacuccuagacccggcgcugcg\n", + "cagucuuacugcaaagcaggagcacaacccgucucuuugucuccguggucaaaucaauuacuucuuagaaagucuaauuuuuuucaaa\n", + "agugagcaacagucuuacugcaaagcaggagcacaacccgucucuuugucuccguggucaaaucaauuacuucuuagaaagucuaauuuuuuucaaa\n", + "ggcagagaccgcauauuccggapcuggcuccaggccacgcgagccggagcuggagacauuuccagagccuugaggauggcaccggcccucgcacgcucaacuccugcuccuccucuucgca\n", + "uggaagguuuuucuggaaaaaaaaaaaugaagugcgguuugguuuccuugucaacggaggaugaagugaacagcugagcagcucgcagagagcag\n", + "accccacugugaugcuuccugacugauaauguuauaacagugccuggaagccugaggcugcauuuccagcuggacguaccucaguuguccccaucauc\n", + "ggcpagcgupccgccagacucpagaggcuccgucuugugcaapuccugupcuggcugcacuggccucugcgguggugccugccaga\n", + "puccgguuuccggcpagcgupccgccagacucpagaggcuccgucuugugcaapuccugupcuggcugcacuggccucugcgguggugccugccaga\n", + "aagaagaguuacuggagcacucucuccacccuugcacagagagaaaaggccaugugagaacagagaagguguugucuggaagccapagaggacccuuacuagaagccaacuuugcug\n", + "gauccuuguguuuacauugaggccacccagauaauccaggauauucuacucaucucaagauccuuaacuucacagcuacaaaguuccuuucaccag\n", + "uugcacagagagaaaaggccaugugagaacagagaagguguugucuggaagccapagaggacccuuacuagaagccaacuuugcug\n", + "gaggaagccgaggaaggcuguguuucugacucacacpagucpagucguaaacaacccugaagagaacagccaggccug\n", + "accacacagacacacaccuccuugcuggagcauucacuaggcgaggcgcuccaucggacucacuagccgcacuc\n", + "cccgccccgccccgguggcpcaccuccggcucuccagucucuaugguaccaacuuccggcgcgcgcuaccccucgcgagacuucggcggcgcagcaauggccagagc\n", + "gucagaacggcggccaggacgccggacgugcggcaguugcaggcgagcaggcgaggaaucgccguggcgucuugguguucuccacgcugguucgcag\n", + "aaaaaaaagcuaaagcagaaaacaaaaguggcccauggucucagcuuccagauaauaacuauugauuucaaaaaauaaaauggccugg\n", + "gcacgccgcggagcapcucggaggucccpauuacggugcucgagcacgcuggupaaaggacccpacuugaacaguguugugcggcgcc\n", + "aagugcgucaucagucggcgccagcggccgcacgccgcggagcapcucggaggucccpauuacggugcucgagcacgcuggupaaaggacccpacuugaacaguguugugcggcgcc\n", + "cggcgccagcggccgcacgccgcggagcapcucggaggucccpauuacggugcucgagcacgcuggupaaaggacccpacuugaacaguguugugcggcgcc\n", + "agucggcgccagcggccgcacgccgcggagcapcucggaggucccpauuacggugcucgagcacgcuggupaaaggacccpacuugaacaguguugugcggcgcc\n", + "ggccgcacgccgcggagcapcucggaggucccpauuacggugcucgagcacgcuggupaaaggacccpacuugaacaguguugugcggcgcc\n", + "gucggcgccagcggccgcacgccgcggagcapcucggaggucccpauuacggugcucgagcacgcuggupaaaggacccpacuugaacaguguugugcggcgcc\n", + "paapucuugcgcaugcgcpccgcugcgugugcgcgagcgccgcagucugcucuccccgcccgcggcccgugcag\n", + "guagapaaaagagcuccpccapcugccgucgccgccgucpagucagcccgccagcccgccagcucgucagcccgccagccagcgcuucgcpcccugucggucccg\n", + "aucagaccaaacauugucuggcuugcacuguaaaacuaguuagcugaagacgacuucucagguuucuucagg\n", + "accaaacauugucuggcuugcacuguaaaacuaguuagcugaagacgacuucucagguuucuucagg\n", + "auauaagaaagaaaaagucaacaauaauacauguguugcuugagcuaaaagacauaggagaacagacaacacauacccauuacauuucuaggaaauacgag\n", + "gccgccgucpagucagcccgccagcccgccagcucgucagcccgccagccagcgcuucgcpcccugucggucccgguaagcpccugcgcuuaccggaaagaggagcguaagaugaaagagu\n", + "gaacacuaguucucuucaaucucagcaccuccaapucagcaccuccccuccggcucccuccgcuaccgcpccggaacuuuugucgauaggaacpuuugcaca\n", + "uuugcaauggauuuuggauaaacaagaucuguugaaggagcgccaaaaggauuuaaaguuucucucagaggaagaauauuggaaguuacaaauauuuuuuacaaaug\n", + "uuauccaagcauuaggugaacaucuuaaauuaagacaacaaguuauugccacugcuacgguauauuucaagagauucuaugccag\n", + "gauuugaucgaggagcgcgguuaccggacpcupucuauggucgcuccgcpccgcuccgccggcuggugcuuuuuuaucapcaagcuguguucc\n", + "gcggagucgagccgagcugauuugaucgaggagcgcgguuaccggacpcupucuauggucgcuccgcpccgcuccgccggcuggugcuuuuuuaucapcaagcuguguucc\n", + "gcugauuugaucgaggagcgcgguuaccggacpcupucuauggucgcuccgcpccgcuccgccggcuggugcuuuuuuaucapcaagcuguguucc\n", + "gaucgaggagcgcgguuaccggacpcupucuauggucgcuccgcpccgcuccgccggcuggugcuuuuuuaucapcaagcuguguucc\n", + "cgcggagcggagucgagccgagcugauuugaucgaggagcgcgguuaccggacpcupucuauggucgcuccgcpccgcuccgccggcuggugcuuuuuuaucapcaagcuguguucc\n", + "acaucuuggaaauucaaauacucaauagcucucgaauucuaggaaucuugagaagaggccuggauuaaggauucagacgupcccucagaugg\n", + "cuauggcauugcugguucuaccaacgugacaggugaucaaguuaagaagcuggacguccucuccaacgaccugguuaugaac\n", + "uguguaaagguugccauaaaggacaaacaagugaaauacuucauacauuacagugguuggaauaaaaa\n", + "uupaugaaupuuccggagagcagaguacucaaauacguggacaccaauuugcagaaacagcgagaacuucaaaaagccaauca\n", + "aaauccggcccaggauguagagcuggcagugccugacggcgcgucugacgcggaguupupuagagaguapcgguagucpuggupagaaggaggaggcggcgaaucacuuauaa\n", + "gccgagauccuaugguaaugugagugagcucucgcuuugcaguugcucguaaaaaguaaauaaaaaugaucugaaugcaguguugacgccguuugcauuu\n", + "ucpuggupagaaggaggaggcggcgaaucacuuauaaauggcgccgaagcaggacccgaagccuaaauuccaggagg\n", + "cagaguggupupacagaaaaaaaaaagugagaugagcguuuuccuccgcuuuguguugccuggaggcaucacucugcuauucuupcgcagugccgagauccuaugguaau\n", + "uauugcuagaccaccuugcuuggaauuaaaaguuacacaguuauuuuucccagaacauguauuuucagcuuaagga\n", + "acacggucuuugagcugagucgagguggacccuuugaacgcagucgcccuacagccgcugauuccccccgcaucgccucccguggaagcccaggcccgcuuc\n", + "gcgccggccggcugcacgagccacacggucuuugagcugagucgagguggacccuuugaacgcagucgcccuacagccgcugauuccccccgcaucgccucccguggaagcccaggcccgcuucgcag\n", + "acacggucuuugagcugagucgagguggacccuuugaacgcagucgcccuacagccgcugauuccccccgcaucgccucccguggaagcccaggcccgcuucgcag\n", + "ucccaaaucugccagccuguucucucuuccuaacuguggaaaaaugagacgguugcuugaacauuuguugg\n", + "cagcauuccugccugaaguauucagcuccucuaggcuguuacaagccaaauaaugguucccuugaaugcagccuuccuccaugaucaauacaccuuuga\n", + "ggaagugacgcucccggcggcuguggcggcggcugcpagaaggaggaggaggagccggaggaagag\n", + "aagccggcppcpagcugcugcggccagacccacpcagccpcpcggacgccuccaagaccagucucugccuccgcagcgucagcpagcg\n", + "gagcugcugcggccagacccacpcagccpcpcggacgccuccaagaccagucucugccuccgcagcgucagcpagcg\n", + "augcggaagagaupccugcuggagcggaagugacgcucccggcggcuguggcggcggcugcpagaaggaggaggaggagccggaggaagag\n", + "cugcgcugaaggagcacuuccpcaguaggaacgccgagucggcugccguggcugugcugapuggcggccggauaggugcggagcuuccugaacgaggcaggap\n", + "aguaggaacgccgagucggcugccguggcugugcugapuggcggccggauaggugcggagcuuccugaacgaggcaggap\n", + "acuuccpcaguaggaacgccgagucggcugccguggcugugcugapuggcggccggauag\n", + "gcugaaggagcacuuccpcaguaggaacgccgagucggcugccguggcugugcugapuggcggccggauag\n", + "gagaauucaccggagcucpaggcgaggcpagcccugagcugaggccpcagcgcggacccgcgcaggaggaggcggcpacaccggcgaguccccagcapccccupcucccggaag\n", + "gugagaauggcagacuggagcccuuugaaagacgcuuccagccccpcaucuaggaaaggugcuugaugaggucup\n", + "agaaggaccaugaagagagagaagapcagagccgugcaupcugcuccccaggaccugagcaggaaccuggaguuuucag\n", + "gccuccagucagaaggaccaugaagagagagaagapcagagccgugcaupcugcuccccaggaccugagcaggaaccuggaguuuucag\n", + "gguugcuugacaagucaggauugugccuccagucagaaggaccaugaagagagagaagapcagagccgugcaupcugcuccccaggaccugagcaggaaccuggaguuuucag\n", + "gacupaagguugcuugacaagucaggauugugccuccagucagaaggaccaugaagagagagaagapcagagccgugcaupcugcuccccaggaccugagcaggaaccuggaguuuucag\n", + "pagguggucucacucuupaaaacugcupcaccgucgucgcgcugaaggugguucuguaccugcuccgagugugcuuagcg\n", + "gcgguguuuacccguugcccgaggagacacccgcgccacccgccggcucccggcgccgccgcuuccucapccgguuccpuccgagcgcgcccccpcucpucguc\n", + "auuuucagugucacccucaauaucapccagucuupupccagaggcagcggccaupcauggupcuguuapaaagguguccucaugaagcccccuuccugau\n", + "auaagcgagucucapuccucccucucagugugccuccucaapupcuagaggccucacucagccuggccuacgagcugccuggcacuggag\n", + "acuuuggacacuuuuguucucggcauaagcgagucucapuccucccucucagugugccuccucaapupcuagaggccucacucagccuggccuacgagcugccuggcacuggag\n", + "cugagcggcuccgagaagacgcccggccapugaacaccgcggcaggagaaaacpagacugugaagagcaupagccuuugucgugcagcgugaaacccuu\n", + "gagccuuuggccuaggagcupagacucapcccuucccacacucagaauuggagcapccuucuagacagucccagcacc\n", + "gucaccagcacccucggaacccagaggcccgcgcucugaaggugaccccccupaggaaggcg\n", + "accugcgcagguaacccpcccccgcgcgcaaggccgaggcgcaggcggagcpcuggagcauguccggcccuuuguucugcgcucgugcguguguccgg\n", + "pcggcgcggcpccccggcggccgaagaggcuggcagguggcgccgupupugcuccuggugagaggaguccacuccgugcgugcpcggaggccggcccccgagagccgccgac\n", + "cccgccgcaccgcccccggcccggcccuccgcccuccgcacucccgccucccucccuccgcccgcucccgcgcccuccucccucccuccuccccagcugucccguucgcguc\n", + "uacggcuguaagaauuguggcapccuucuguucaggcugccuaagcuucagugcagcagugccucggacupaacacccaacagaaagucugcaagcaaugccaugagguccugaccag\n", + "gcguguggcagccuuggaagccaagcaaaagcccagcacuucccagagccapacugacacgacaagaccag\n", + "ccuacccaucugcuccccagapcugccugcugugcacuupuccuggagcccuucuccacccg\n", + "agaggcuaggccugaggccuggaccgcucugugagcgaggacccgguuccgcccgaaggaugaagacuugucuuuaaagaugacaacguacaggaaag\n", + "uccacagccuggcucccucucaaccuucccaguccuaucuuccccaacucugccgccuuccagccaaag\n", + "aguucuaguuuccaacaacagaggcugcagccacccagccccgaagcapcccagcgagacapcccag\n", + "gugaauauuaugcaucauuuauauuuuauuacuauuauuguuuacagaaucuupacuguuuuacuuaauuggucauugauagcuuaacaaac\n", + "aguguccugguuacugcagcggcagcaacagcagguccuacuaucgccucccucuagucucugcuucucuggaucccugaggapcagaag\n", + "gacuguaggacgaccucpucccacguguccccgguacucgccggccggagcccccggcuucccpccpaccuuagcggcacccacacacagccuacuuuccaagcggagcc\n", + "ucauuccagagcccuggacuaggaguaggaagaucugaauuguggccccaacucucuuucgguuauuagcucugugacccuag\n", + "gcucaguguccugguuacugcagcggcagcaacagcagguccuacuaucgccucccucuagucucugcuucucuggaucccugaggapcagaag\n", + "ccagugauucugguucuuggacaagguguugaggaacacuagaaacagapacugugaccupacuuuuucugcaggaagaaaacagcccaaag\n", + "cuugcucgcauacagacggacagugugguggcaacauugaaagccucguacccuggccugcaguuugaaauca\n", + "gguuacugcagcggcagcaacagcagguccuacuaucgccucccucuagucucugcuucucuggaucccugaggapcagaag\n", + "ugauucugguucuuggacaagguguugaggaacacuagaaacagapacugugaccupacuuuuucugcaggaagaaaacagcccaaag\n", + "ucpucccacguguccccgguacucgccggccggagcccccggcuucccpccpaccuuagcggcacccacacacagccuacuuuccaagcggagcc\n", + "aggagucagacuguaggacgaccucpucccacguguccccgguacucgccggccggagcccccggcuucccpccpaccuuagcggcacccacacacagccuacuuuccaagcggagcc\n", + "agacuguaggacgaccucpucccacguguccccgguacucgccggccggagcccccggcuucccpccpaccuuagcggcacccacacacagccuacuuuccaagcggagcc\n", + "ugacuuucagauuugacuuuuaaagaauuaauuauauugacugagagagaggcccaggagagaaagaagaaagaaaaggagccap\n", + "gcuggagagcaguggcaugaucucggcucacugcagcuucuacuuccuggccucaagcagucuuuccaccucagccucucaacgcacuggaauuacagaugugagccaccacacuaggccuacaag\n", + "ugguccuuacaccagauuaauuuaucuugaaauggcpcaacugaaucgcacaccucaaucuaug\n", + "auuugacuuuuaaagaauuaauuauauugacugagagagaggcccaggagagaaagaagaaagaaaaggagccap\n", + "auuugacuuuuaaagaauuaauuauauugacugagagagaggcccaggagagaaagaagaaagaaaaggagccapauggcucuuccucag\n", + "guaucucuccuaaaugugugaucaaggaauuaccaccaauacagaacaguaacacaggagaaaaauuccaagcagug\n", + "ggapcucugcguucuguaguggcgcugcuupcccuuggcggauuguaagcugcugguuuugcggcupaagagcggcgagapuucggcauuuuucgucpauccccgcaagg\n", + "gaguuguugcaacuuuuuucgaaagcupuuucccpagaucccaggcggugacagaguggagcc\n", + "ggaccuucaccgcuauuucugagaagagcaaaagugaugcagaucuguucuuccucuucuuaaucccagagaaguuccuaauaagccagua\n", + "pacgguauucagaauucgagcgcaggagcuccgcuucuccaccugcucccpagcuauugg\n", + "paggcugaaaggcagcgaggapapaaagacaccgcupuucuapuucuagapagaaguuucaagapagag\n", + "aaauagagugugugugucccuaugcccucaugugcugucuguguguccucupugcupugugacauuuucccuag\n", + "gcaaaaugcacaaauagagugugugugucccuaugcccucaugugcugucuguguguccucupugcupugugacauuuucccuag\n", + "uapacgguauucagaauucgagcgcaggagcuccgcuucuccaccugcucccpagcuauugg\n", + "cuccguupacacgugaccagaaguuapcugcagcggcgcuggcuuuaggugaacgacgug\n", + "auuuuagaagaacuaapaaagaacucuucucuguauacagaaaauuacuuuucccacugaaacacacccaaguauaugcccagccuuc\n", + "guggapagcgccucuuuauuuuuuucaccuacuuccucucuuacgccgaccuaguccaggaauug\n", + "ccauuuuucacguuauccagapacagcagugaugaagagaauuccaguaucguauaacucagcagguuuagguccauuccauuuggcaucagcagacaugguagcacuuuacug\n", + "ucuuupucuucuaggaggaagaaggcupupuagguupuggagacaauuaggaagag\n", + "aaggaagagaggaugcuccguupacacgugaccagaaguuapcugcagcggcgcuggcuuuag\n", + "ccuucgcggcgcuuccuaguucggcugguucuucugucgccggcuucagcagcccgcgcccpcag\n", + "cuucgcggcgcuuccuaguucggcugguucuucugucgccggcuucagcagcccgcgcccpcag\n", + "cccgccccuucgcggcgcuuccuaguucggcugguucuucugucgccggcuucagcagcccgcgcccpcag\n", + "augcuguucccaaaacugcuaauacacuaccuucuaaagaagcuauaacaguucagcaaaaacag\n", + "gcauuuuucagagcccuaggaauccgagcugacggaucccugacapcgacugacuccuaguuaucccccuaaccccuapccuucagccccaaccccauc\n", + "cacacccacacaugcacccuccgguugcccccuguaagaaacugaggugcccucccacccgcucguucacaccuacacgaggccggagcaaag\n", + "apugaccggaaggcuuuuuuugagagcucucaguggaacaucaagaagaaccaggagaccaucagucagcuccgcaaggagacuaaggcacuggaacuaaagcugcuggaccugcucaag\n", + "ggagaugagaaagugguccaggcagugauucgcgaauggaagupagaagccauaccugaagaacaggacaggacag\n", + "acgugcuuccgcuggagccucucpaggcpuaacguuauaguauuugucagaaguupucuccgupcauugugauccgucccaggcagug\n", + "cucpaggcpuaacguuauaguauuugucagaaguupucuccgupcauugugauccgucccaggcagug\n", + "ccccapuaggagagugaacggcggcggupugcugauggugaugucugcucccaggauuaggaggccagaaggagaucccuuccacggugcuaggcugag\n", + "gcgaguuugaaucaaagaagaggcpacuuuccucccggaaguaacccacgugcuuccgcuggagccucucpag\n", + "agcuuauuuagauggacuuuucaccaagcucugaacupauuucauuuuguugcauucauccugcucacgagacacagguaggcagcaaaugagauuaucccuccaguccccauggauuggaa\n", + "uguuuuuuuuugguuggugugucugcugucuuguagauuuugucaacacacucuuucuucuuucccuuuggccugauccccaagauuug\n", + "auacagaauucguuguupaaggacupaaacagcuguaacauuugccacccucagaagcugcugguccugugucacaccaccuuagccucuugaucgaggaag\n", + "gccgcggccccagcagugcgguguccguggaaggagacucagcccugcgauuucggaaaacccuuguuuggcpcpapcuguugcugcgupugagaagaaacuaggugcgugag\n", + "guuauucuuggacaguauaauuggcuuuccuaugaagaugucuuuguucgagccuuuaauuuuggaaauggauuacag\n", + "ugaaacaacpcaagauguucucagaggcaguguaacagcgauuaagagccuggacuccagacccagacuauaggucugaaucuuggcuuugccacuuaacuggcuuucugacccuggaaaa\n", + "ccccpcggcggcgcpcgugaacgcucupcucagccaggccugcgcpcccgaggccggaggaacccggacuccggcguagcg\n", + "guacucggaauuuggaaaugauupcgaguuccugcucuuaaggagcucacaguucaccacaggaaagagguguaugaacaaauuacagcaugguggaacagaagaag\n", + "accaucguuuccccgcgcgcagguccgcpapcggccugccgaccggcccaccccapcguuccugaapcguccucggccgcccccaccgccucccag\n", + "agccucpcuugacpauuguggcgguccucucucccaauucggaagcuacagcuaccuccggacgcucucaag\n", + "uguuuggcugupuuaguugugccguucugcuggaacaccgupaaggcaguagacgcpcagucagcuagcaggucugucgcccc\n", + "cgcagagugupcgaccaccgcuuucgcguugucccaggauuuuccgaccucupcgcuuguccugccgugaccg\n", + "guguguguguguguguguguguguguguguguguguguuuggcugupuuaguugugccguucugcuggaacaccgupaaggcaguagacgcpcagucagcuagcag\n", + "ucccuaagccgucgaucuccugcccuuuguguuucucucccugugccccggaaucagaapaupacaggugugaaugugugugugugcaggagaaacuuuuuag\n", + "gugcugagucggaagupaacccuucggccgcugagauucugucgugucgucgcugcuggcacuucaggcucug\n", + "gcpcuggacuaccucgugcugaaccacaucggcggcgccccggccggcacgcgagcccgcagcccccaggcaacucgcuggcuc\n", + "gcuggagugcaauggcaaaucucggcacacuacaacuucugccucccagguucaagcgauucuccugccucagccucccaaauaucuggauuacaggcau\n", + "ucpacccggcaggaggcggccgagaagagaggaccgupcguucgcguggcucccagcccpaccccacccccgcuggacagupaaacugaggccugagcgg\n", + "papugcggucpacccggcaggaggcggccgagaagagaggaccgupcguucgcguggcucccagcccpaccccacccccgcuggacagupaaacugaggccugagcgg\n", + "acuuccuguugccuuapaacguggcuuucccugcagagccggugucuccgccugcgucccugcugcagcaaccggagcuggagucggaucccgaacgcacccucgcc\n", + "apaacguggcuuucccugcagagccggugucuccgccugcgucccugcugcagcaaccggagcuggagucggaucccgaacgcacccucgcc\n", + "uuapaacguggcuuucccugcagagccggugucuccgccugcgucccugcugcagcaaccggagcuggagucggaucccgaacgcacccucgcc\n", + "ggapagcacgucacuuccuguugccuuapaacguggcuuucccugcagagccggugucuccgccugcgucccugcugcagcaaccggagcuggagucggaucccgaacgcacccucgcc\n", + "cucuaccaggccacaccggaggcagugcucacacaggcaagcuaccaggccacaacaacgacacccaccucaccucuggcaccucuga\n", + "gcauccacguacuugcaagaacucuugcucacaucagcuaagagauugcaccugcugaccuagagauuccggccugugcuccugugcugcugagcag\n", + "gagaaguacagagcaagucccacgcacaguccugaaaaaaauuuuaaucuucuuuucuuagaacuaucuugguuggcaucaucaggcccugagagcacagugc\n", + "agcaggcugccggcucggacggcggcgacgcggcaggacapcggauaagaaggagcggccggagacuggagcupuucguggcpccggcugauccggacggagacuca\n", + "acaacaaagauggcggcggcgacugugacggugacgaagacggcggcggcggcgacggcauuuaacaaggcggugugguuuacuccaugcaguugucaggag\n", + "gugguggugaggaggugauguucuggaaggaagguaccuagacuuuguggucccugccaggaaguggagaguggaaauguggaaugccucacacuccucaacuag\n", + "aauucccguacugauuagucaacaguggaaaaucugaagagaugcaagcaggaaaaagaaauuaaaccag\n", + "pcgcuaggcugccccpaggcgcugcggaccggcggcccaggcacggagaggcggcgagaccgcag\n", + "aagauauuuauauguuuuugccuuuuuaggaaacuacaaucucauugaaaauauacacuauucagaucaguacuaagag\n", + "aaaugauccaauaauaucuacuauagagaagcugaauauacuccauuuggagugaacagcccggauuguuacagaauuuucaag\n", + "ccuccaucuuccaagaagagcgaugguucupacauauacuaaguugcagaauacccaggugapuc\n", + "gcuucacaggcgcagcgacagcgacagcgacagcucgaaccugagucccaggauuccpacuggapcagcgccggcagccaag\n", + "cggaaaugauccaauaauaucuacuauagagaagcugaauauacuccauuuggagugaacagcccggauuguuacagaauuuucaag\n", + "caaacucauuauuacauupuaagaaacaaaaaagaaagaaugagucuucagaugaaauaucugaugcagaacagaugccacagcauacauuaaaagaucaagacucucaa\n", + "gagaauccgagugaagaagaugcugcaauuguagacaaaauucuaucuucuagaaccguaaaaaaggaa\n", + "cuccuaucuucacugugagupccacagaagagcagcuuuugaaagauaaaaggauccagcagaaaaucaaacgauucaaauugagacaagcacaaagagcacauuuuuuugcagac\n", + "auggaagaagaaccauuuaacccagacuacguugaaguagacagaguauuagaagucucuuuuugugaagauaaggauacuggugag\n", + "gaccguccuccuucuaauauuuggaagaaaauagaucaauccapacuauaaaaauggcaaucaacucapaauaucaacuggaaggacucaacuggcucuuguucaauugguacaauag\n", + "gcgaguuuuguggcaucuggaaaccggacagauauuucuuuagaugaucccaacuucuggcaaaaaupcuaaaaaggcagaaauagauauagaggccaucaguggcaga\n", + "agccagaggaagugaggcucagacagagcagcugcuguuccagcaacagcagcaacugccgcacccuugaaaggaggccccugccguguggacccguaaaauaaaaugg\n", + "gugauuaccacuccagcugcupaacpcgagaaagaggaggaggcgagaaacucccaccgacccacagag\n", + "acuggaaggaaagaaaaaggagauccucucaacauugcgauugauaagaugacuaagaaaacaagagaucuaaggagacag\n", + "agacpaucucagcauguuugccaggauggucucagucucuugaccucgugauccgccuaccuuggccucccaaaguguuggaauuacaggugugagccacugcgcccagccaucag\n", + "aacaaaauauacagcuggauguuugucacaauucuaaugucccugcaaagaugagaugcaugaaucacacagcaaucucaucaaaaag\n", + "uuuuuacauggcpacagccaugccucagaauguuuagcauauuuaucaucucagaapuccaacagu\n", + "auuuagugugaaugagacacuguucagauuggaaauacacugucuauacuguacuccagacacaccuauuuugcuuuuaaaauuauucucaauaucugucuuuuccauaguaac\n", + "auugaaugcggcaapucuggaggcugaggaccaggcagacagacauucagaguugcuggaacgcgacagagacapagucagacuggucaugcaag\n", + "augaaguuggagcccuuguuuuugacauuggauccuauacugugagagcugguuaugcuggugaggacugccccaag\n", + "aggccuggacccuagugauuggcugauaggaggagccagcaaguguggcugagcuccpuguguggacgccgcuuuguugccugag\n", + "cccccuuguugucucucggccgccguccucucaaccaccgccccccuuuucggcucccucucccccuucccguucccccagucagccuggcccugcuggugccuccggcgcuacpcupcaag\n", + "guggacuggcagaggaaguggacgacaaaguucuucaugcugcguucauuccuuuuggagacaucacagauauucagauuccucuggauuaugaaacag\n", + "acacaauuuuuccaagaucccacugguguuucuguguauucuuccuuuucagugaaucagagaauggapauauaaugaguggaacugag\n", + "cuggugugcagagaagccagguugaugccaucuaucaaaguugucucuuagaccucagagccaguugaapcugagagagg\n", + "acaaaugagugagugcagcaggagaggcagcagagcgccgupaguuggaauaggaaggagaaaaggcuuc\n", + "uucgccuacaaggacgaauaugagaaguucaagcucuaccugaccaucauccugcuccupugccguggcaugucgauuuguccuucacuacag\n", + "ggugacugacgaagucuucaacuuccugcuggugugguauuacugcacccugaccauucpagagcauucucaucagcaacggcucaag\n", + "gcugcguccaguuccugcaauauuauuaccagapcugccucuaccggcugcpcccupagaggaaccaccuggaucucacagugg\n", + "aapuuccaguccuggauguggcpccucaccuuucuccugcccuuccucuucuguggccau\n", + "gaaacuccuaggcagcagaggcccacgacuacuuccuccugagugccguucaguggccuguguccag\n", + "gugaaccuggugcupacggccggucccupccucacgauccgupagcugaguacggccuuggcauuuacaucacuggcguggacccaggcucugaagcagaaggcagcpcucaag\n", + "aacaaugaggaaaauucuagaaguuugaguuugugugcuuacuagcaaccacuuucagcguuucugcaaagcuagagaag\n", + "gguucccagugccgauuccgacacugugaagaggcccuuggcagugacacugugugcucauuauggagagagaggaaauguuuagauccacuuugcagauuuagacac\n", + "aguucacugcugauucagucacaggccuucapccaggcagccugugccagucuucuauccccugcugagcuccgagc\n", + "cccgcgcgcpcucaacuuuguagagcgapccaacuuggcagagcgcgcggccagcuuugcagagagcgcccuccapacu\n", + "gcaggaaguggcacuuggaaaagaacaccagcugcggugguagcagupauuugugcuucuuauguuacccag\n", + "augcuguaauggacuguguugguuggccuccaggcaggaaguggcacuuggaaaagaacaccagcugcggugguagcagupauuugugcuucuuauguuacccag\n", + "gaguuuuuauuauuacagagaagaaggaaacucacuuccugucgucgcagagcacagccuaguucug\n", + "agacccuugcugcggagcgacggagagagacugugccagucccagccgcccuaccgccgupaacg\n", + "gccauauuugccuagaaaaaaaaaaaacucugguguauuugacagauggucagaauugaauucuggcucccugcgcag\n", + "caguupauuacgauuapaugugguacuggaaagaugaaaccagaacucuugaauucagaag\n", + "uuuuacaccugcagcagaagucaaggaaaaaggaaagaaaggcaaagcaguucacuuugcagaaacugaugguccagcuucagacag\n", + "guugacagauaaaagacuugcugcaaaagaugauaagucagcuaaagcuguagagaaacgaggucaacapcaccauuacacuggaugauguuaaau\n", + "uccgcgccccpcagccgugugcaggcgccugcpcgguauccucggcgacgccguauggcuuccapcgaggcc\n", + "cacgagcggcpapaggcgguggcgcgcccggccccgcccgcccgaccaagcgucggacgcggcccggcgccgagcc\n", + "cugucccuuagccagacccggcgagacacgagcggcpapaggcgguggcgcgcccggccccgcccgcccgaccaagcgucggacgcggcccggcgccgagcc\n", + "agacccggcgagacacgagcggcpapaggcgguggcgcgcccggccccgcccgcccgaccaagcgucggacgcggcccggcgccgagcc\n", + "ccgccaccgcggccggagcugucccuuagccagacccggcgagacacgagcggcpapaggcgguggcgcgcccggccccgcccgcccgaccaagcgucggacgcggcccggcgccgagcc\n", + "aggaucuguaaaagcauaauugaauuuguuucacccccguggauuccagupcccgacagcgcaacag\n", + "ucccacccgcuguaccugugcaaugccagugaugacgacaaucuggagccuggauucaucagcaucgucaagcuggagaguccucgacpccccccgccccugccugucacuggcuagcaag\n", + "acagccucaucucupaccugaauagacaauuuaucauuugaagaaaauuaagacuauaacuuuaagaaauuaucuucugg\n", + "apcucggucgccagcaaccgagcpcccggcccgagcpccupugcgacgccgapcpagagcgcgccgcugcucccggaccpccgcgcacgccgccucag\n", + "gaaccaucacuguugcuggaggcaccugacaaauccuagcgaauuuuuggagcaucuccacccaggaaccucgccauccagaa\n", + "ccgagcpcccggcccgagcpccupugcgacgccgapcpagagcgcgccgcugcucccggaccpccgcgcacgccgccucag\n", + "pcucggucgccagcaaccgagcpcccggcccgagcpccupugcgacgccgapcpagagcgcgccgcugcucccggaccpccgcgcacgccgccucag\n", + "agcgcccucagcgcgcuacgguccgcpcaacuccgcagaagccccagcccccaggaccccaggacccaguggcgcagccggcagccccggaucccug\n", + "cccucccgauuuccuccpcuacaggcgacagagcugagccaagcguuuacupcagcuguuacg\n", + "gapucccpuccgcggaucucpupuuuuucccucucaguggcacuugguugaguucccccpacuucugaaguuccggcccgcgcuggacuucupauucccucuucc\n", + "pcucgcuggcgcgacccgcgcpccagupagugcpapacgccgapuccapuuuggapcgcgagcugccpuuggaggucgag\n", + "agucugaucuggcugaagacaggaugcaagucacugguuauacugagcagaaguuuucagcacaguaggcgccccaaagcuugccacuugacccuugagagcuucucgcuguccuuucc\n", + "gaagcaaugccugugugcccaggccaugcagccugcugugccugcccaaggccaacaacaguagaagcugcagguguccagaggauguguccagcagugugcuuccaucapaccug\n", + "aagaacgguuucuucauaagapccuucagcgacagccaagcucggaaaagaacpaauaaguugucuuuuauauuuccucaaauacugugaauggucugaggcgcag\n", + "gguaaaauauuuggaguaccuuuuaaugcacugccccauucugcuguaccagaauauggacacauuccaag\n", + "cuuucuugucgaugcuugcacaucuuuagaagaccauauucauaccgaapcuuuuucggaaaucaggaucugugauucgccuaaaagcacuaaag\n", + "agcgaaccagacpacaguaagguuuggaggaapaucguuggaaguagcaagaaguggagagaaucuggcaauagacgagaaaccgaaagaaucagaaagaagucuau\n", + "ggaggccgcugcgcugcapccucgcggagccgcccgcgaccgcgagccpcccuccgcgcgguccaucgcccacuggacgccgcccgcggccggaccg\n", + "gcuguuugcugugguuuagucaaaaagccauguagaaugccugccuuuugaagaccacuuuuaaggugucuaguaagacagcag\n", + "aggccgcugcgcugcapccucgcggagccgcccgcgaccgcgagccpcccuccgcgcgguccaucgcccacuggacgccgcccgcggccggaccg\n", + "guucaacuucucaucuuuguucuucuucauauacuauaggcuguuugcugugguuuagucaaaaagccauguagaaugccugccuuuugaagaccacuuuuaaggugucuaguaagacagcag\n", + "ccgcugcgcugcapccucgcggagccgcccgcgaccgcgagccpcccuccgcgcgguccaucgcccacuggacgccgcccgcggccggaccg\n", + "cuacugaucuacuucuugccuggaaucccauuuguuupuugguagaagguguuauupaaaauucaacuucauucag\n", + "aucuuccaugguggcuuauucuaauucggcagaaagcauuggupcaaacucccaggagaccaugaggucuguaaaguuaccaaaauugcugugcucucacuuucugaa\n", + "gcugcuucucggcgcgguuccuacccggccgcuccccgaggcgcpcucuggcggccucgaccgacuaggacgccccgugcgccgcccgcpccgccgccucccupcgcgcpccagc\n", + "acacuguaauuaguaguagaauuuauuucauauuaaaaugugucaugacguaauuuuuauggcuuggcucaagcaacaauuuucagagugcac\n", + "auuaagacuguuggacucaagcuacaacgaggugucucugauguaaaaaacugcaguuuaagauuaug\n", + "ccucauugaugcuacucacagagacguggaugugcuguuacugcuuucuaacucugccuacuacguggccua\n", + "uuaugaugaugaaguugauaaaguaaaccaguaucaacgacuaagucuagaaaaccuggaaaaaauugaaauag\n", + "cccggccgcuccccgaggcgcpcucuggcggccucgaccgacuaggacgccccgugcgccgcccgcpccgccgccucccupcgcgcpccagc\n", + "guccgaagccuuauuguaucccaagccuuauucaggccucacauuuaauacuuugucacaaauugcuuuaug\n", + "aguuccugccaggaguugucggugcgagguaapucccagaggaggacgugucccucuggapcgcccagccapcgcggaagcucpugccgcgupcaggcgcagccpaaaguugag\n", + "acaauaaucaagagacuacuuguucauaagaagaauaggcugcaaauguaacuucuauugucuuaucuuuucauuuuuucauaaugcaaauaugaccaauuaaaaau\n", + "agagacuccuuuucuccuaaccgucccggccaccgcugccucagccucugccucccagccucuuucugapaaaggacaag\n", + "uuuucuccuaaccgucccggccaccgcugccucagccucugccucccagccucuuucugapaaaggacaag\n", + "gagcucaaucuaggacgaagagaggaguacgauguuuuggacaagagacguggccpacccugag\n", + "aggcacagagcuuuggccugcuggaucccaaacucugcuaccugcuggauggaauccucuucaucuauggugucauucucacugccuuguuccugagagugaag\n", + "acaguccuccacuuccupagguagcugcagaauaaaaccagcagagacuccuuuucuccuaaccgucccggccaccgcugccucagccucugccucccagccucuuucugapaaaggacaag\n", + "ggaacaccuauuaagugaccugcagaauacagagugapcucuaagaggaaguuaugagaaagcupcuagaggauuaaaggaaagcauccupag\n", + "aaccgucccggccaccgcugccucagccucugccucccagccucuuucugapaaaggacaagaugaaguggaaggcgcuuuucaccgcggccauccugcaggcacaguugccgauuacag\n", + "cugcagaauaaaaccagcagagacuccuuuucuccuaaccgucccggccaccgcugccucagccucugccucccagccucuuucugapaaaggacaag\n", + "acccggugccaagccagcuguuuacuuucccgccauguccagcucuucgugaggagaacuggaugauuuccugagaucugaggcuuucuggaaucacagcggccaagcgg\n", + "aaagcuguuggagaaugugcaccaccaaaauaapaauaaguaaaggaggaagaagacccugaguucaggaauaag\n", + "cucuuuccucacccggugccaagccagcuguuuacuuucccgccauguccagcucuucgugaggagaacuggaugauuuccugagaucugaggcuuucuggaaucacagcggccaagcgg\n", + "gcgagacuuucapucggagcgcpccggccgagaggaaagcuggaggcgcpupaac\n", + "ucgcgagacuuucapucggagcgcpccggccgagaggaaagcuggaggcgcpupaac\n", + "agucuucpaggagcugcauuacacacaggcuucggaggcuuccguggagaagcuuggagguaauggcugucguaaaugcuaguuauuuucagagaguucucgaagauuuggaauaaag\n", + "ccgagccccagaaagacaggucaaccacagaagugcugagccagguaaagacccugcuggacaagcagcuggagugagaaucaagacagcuggaccacaggaccagacccagcaguauccauguaaca\n", + "aaccggcgccagccauggccucupcpcggaagcupucgcuccccaccgcagagcgcagucccgacg\n", + "cgcgcggaucccuccgcpcuccucguccccgucacgcugacuuuccgugcagugcuguggugcgaaaaugccucgccg\n", + "agacagccgauuuuuacgacccagcaagaggccgagcugguacaauauccugacuguaaaucguccagugguaauauuggcgaggacccagaccacuuaaaucagagcucgucuccuucucaa\n", + "ggcucacucuggcagguaggaacapagagugcaccugcuaccagucaagcucagccagacugcaagaggaggcgaggcggagccagccgapagugaacc\n", + "gcgguggcgucacuuccggcpccucccagcuggaagaggcgguggcggcpucpcgag\n", + "ggucuugcucuguugccupcuggagugcagugccacgaucuuggcucccugcagccuugaccuccupcucaagcaguccucccaccccagccucugaguagcupacuacaagugc\n", + "gaaguccugaguugaggcuugcpauccuuuccggagaaagcgcaggcuaaagccgcaggugaag\n", + "guccguuggccuucguacccgucuugagugaggugacgaguguuuucuaguacupucggccgcgcagcccucucapupuggcaggaagagugccpucccgcguggugcaaaag\n", + "pacgcugcgcggcgguggcugaugcgguagccgugupcgcuccpcggcgacggcggcucucguaggcgguuccggucuuguaucuccaggcggcggcggcuc\n", + "gcacuuggcuucaaagcuggcucuuggaaauugagcggagagcgacgcgguuguuguagcugccgcugcggccgccgcggaauaauaagccgg\n", + "agcgcggugaguuugaaacugcucgcacuuggcuucaaagcuggcucuuggaaauugagcggagagcgacgcgguuguuguagcugccgcugcggccgccgcggaauaauaagccgg\n", + "gaacucuccgcccaguucgccgcaacuacuacgaccccuccucggccccupaapcguggugupagupagaacgacaauggcuccuggacgcccuacgac\n", + "cuagugaacagcggagccggacpaucgccggcpcggcaagcggaggcggcccaggcccggcggucuccgagaugucacg\n", + "agugaacagcggagccggacpaucgccggcpcggcaagcggaggcggcccaggcccggcggucuccgag\n", + "gauucucaccagccuggacagccaaapucuguguguggccpaggauggcpagugagccccauggaacagccaggaacugguaapag\n", + "pcccugccccuucccagaguaaacccacupucuaagagupcguugucggcucccccagcuucuguccuccccagaaucuuccagg\n", + "aucacccacugaagauucucaccagccuggacagccaaapucuguguguggccpaggauggcpagugagcccc\n", + "aaapucuguguguggccpaggauggcpagugagccccauggaacagccaggaacug\n", + "agauugaccguacgccagccucagagagagaaggcccaggcpaggaguaaagccucccupagag\n", + "auucucaccagccuggacagccaaapucuguguguggccpaggauggcpagugagcccc\n", + "gaguuucugagcaauuuuuauuuuucucuuuuguucucucucacaggucugcaaaaguugugcuuuucucaucgugagcuugagaagagugugupcugccaaaggcaaauauaaugaag\n", + "acgcgcagugcucuuggccpaggaggcugugcugcaccagcaccucuugcuccacaucuccagagagcccag\n", + "ggcccuguggccgaguguguccagcccagugucaupagcuuccauaucucauggcuccuugcupccaagcccuccagaaccccaaacccccaaagacugauga\n", + "agcgucgcgcgcguggaucugccgccpuugcugugcgacuauucuccpagccguccgugucaccgccggaaccuggcgcag\n", + "pccuccgucccaccagcaugagcgaaugaaapaguuugcguccggupuagaugagacucugguugagcagcaa\n", + "pcucuccagccugcauuccauggccaacagcagugcagcugcagaagcacuucuggaagccuccugacuugaacuagaccuugg\n", + "agagucguuguuuuuucugauucuucuugcuccucauccuauuuccuuugucuuaauuuccccacaaagacacccucuccagagcccagcaauugugapacug\n", + "guggcuaaagcaauccuagugagacaauggcaugaguaauaguaacagaggaguuaagcaguugugauuuucugcuccaauaauagaaug\n", + "guguugcagcaucccuggaagugucagagagcccupaguauccagguggcccpucagccagcaguccugcccugcacuuucacuaccagcgcugcccucauuaaccucaaugucauuugg\n", + "apcagaagaagugagccuagaaggauggacuugcugaacuucuguuuauccuccaagaugugauuagucuucauagaacuccauagaaguucaggaagcaaggag\n", + "caauuugacuuuagcagcaguguggaggauggauuggaaguggaccggaggagaucaguugaggcugucgugguuguuaaagaucau\n", + "cucuacacauauuugapccaguguccuuaacugugucuuguauauuugagaagccguaugccauaauguauucuggagcacacuucuuagauuugaaucucagcuagcccacuuacacacuuag\n", + "ggcacaguccucaggauguuucpagaauaggagccagaaccugagccccuaagcuauuccccucacca\n", + "gccugcccccccagcuggaaccaagaagguugugucccccuuccucupuguccuugucuccugcuaucag\n", + "cugccugcccccccagcuggaaccaagaagguugugucccccuuccucupuguccuugucuccugcuaucag\n", + "gcaugcgugcagcucuuuggaggcgguagcguuuucggcgucgagacuggaggcugagugcuaaacugugupcgcggaupauccagcuguuagucgg\n", + "aaaugapcaauagaaaagaaaaugaaacuccacgaagacguucucauucccccaguccuaggcguucuagaagaucaagcucaagucacagauuccgucggucucgaagccca\n", + "augcgugcagcucuuuggaggcgguagcguuuucggcgucgagacuggaggcugagugcuaaacugugupcgcggaupauccagcuguuagucgg\n", + "uguuuugaaauuugugauggaaaauuaaaauggaaggaaaauaaguauauagaagaugagaagagaauaauggaaaggaaaaagagugaggaaaag\n", + "augcgugcagcucuuuggaggcgguagcguuuucggcgucgagacuggaggcugagugcuaaacugugupcgcggaupauccagcuguuagucpuaggcauag\n", + "gcgcaugcgugcagcucuuuggaggcgguagcguuuucggcgucgagacuggaggcugagugcuaaacugugupcgcggaupauccagcuguuagucgg\n", + "cpacggcguuccugccpaauaccaccccggcggcagcccaggcugccgcgcagagcccggauuccgcgacugccpcaccgcagguuuuggacucgcugaagcg\n", + "ggaggcgguagcguuuucggcgucgagacuggaggcugagugcuaaacugugupcgcggaupauccagcuguuagucpuaggcauag\n", + "guuauuuauuucauaagaugacuauccauaaaucuuccgaugaacgaaccucuuuaugaccagagcuccupuuaaaggagaaagguuuuauaauggcugucuuaauuuguuuggugguuuuccag\n", + "gcgcgcaugcgugcagcucuuuggaggcgguagcguuuucggcgucgagacuggaggcugagugcuaaacugugupcgcggaupauccagcuguuagucpuaggcauag\n", + "aaccucagaaaacugauuuauccuupaapucaguuucuucauuaggacaaugaagaaaaauccagcugucccuuccaapagguauc\n", + "agaaagcugacaguccuugauccuguggccacugccccaucauuccugcuccugaggacucagucuc\n", + "agagcagcugcagccucagccggccgccccuccgccagccaaguccgccgcucugacccccggcagcaagucgccacc\n", + "pccuucugagguuupcuguapccaupccucapccagaggugguuguuagccuggcaagacaggucupcaac\n", + "acauuucagaugugaacauccugucucaccaaaacaaccccagcuaagaaguuccgucpuggaggacuuuuuccaagccuuuguuucuguggagucucugugcauggccugcugugaugag\n", + "cugcccucuccucgcacccugcucapcaucugaagagccuggaaacgugaacaggcuugaaguauggcauguugcaaag\n", + "gugagcgcgagugugcgcacgccgcpagccucucugcccucuccucgcacccugcucapcaucugaagagccuggaaacgugaacaggcuugaaguauggcauguugcaaag\n", + "accacgapagugagaccacuuggagugaagauucuuugaggagaaggaagagacugagcaaac\n", + "agucaccgaugcuggaapuuucuuuggcccugagugaagagagacccagapaacacugaggugccugcccaaccacucugucccgguuuccuucagcaggaccag\n", + "agucaccgaugcuggaapuuucuuuggcccugagugaagagagacccagapaacacugaggugccugcccaaccacucugucccgguuuccuucagcaggaccaggugagagaag\n", + "aagagcagauuuccpagaagaucacagguuggauuuuggacauggugauucucaaaugucucaagauggauaugucacacagacagguggacauaaag\n", + "gucaacugacaagcgcupacaguggcguccuugucuugccuuugucgcucccgccccgcucuucccuggcupcuggcggaggccuugcug\n", + "aauggaguupaagucagcauaaagagcagauuuccpagaagaucacagguuggauuuuggacauggugauucucaaaugucucaagauggauaugucacacagacagguggacauaaag\n", + "gccugucaccauguaagaagugaauuugcuccucguucgccuucugccaugauugugaggccucuccagcc\n", + "gaaaugucucaauagagugccugccugguucaaguccuuguacugaugcucuaacguguauaaaagcugauuuauuuugugauggagaaguaaacuguccagaugguucugacgaagacaauaaa\n", + "aaaaaaaaaacccaaaauaacacaggacaucccagugugcaguucgaaggcugcuuuuguuguccacuuccuccacaucuuuuuccucaucaucuaagcagauguaggug\n", + "guauugaugucaagcugaaccaucguaggaaguugaaagccuuagaaagaggacuugguaaaguuuuuggauuaucuugaaacucuggcaag\n", + "aagauuaugaagcaacaacacuagcuacaguuuaaaugaaggcauuucuucacuuuuaauauauuucuuuuuucaccagaauaacaauaaaccagaaauaagugugaaagaguuuauagauugg\n", + "caccaaacuaacacucgcacacacccccgcgguuacuccgugucaaacuccuagaggagcccuuggccagcucpugcggcgguggcgaccggcaggcgaggaggcccgcpcagcag\n", + "gugaaguagagugagcauuagccuggcagacagcuapuaauagaugacuuccaguggaagucaaagcacaa\n", + "agucucacucugucucccaggcugcaacauccaccucccagguucaagugauucuugugccucagccucuccaguagcupauuacaggugugugccagcaugccuggccaauuguuggauuguaug\n", + "gcacacugcguuccaaguupacuucccagaaaaugaagucagcuggaguupccgagguauacuuggua\n", + "aauacaacaagaagaugcccaucuguagaccaggagguggucccuccccagaaacuggaupccagcacguugauucugaacuucuagccuccagaacu\n", + "cagcucccgucccccuuccgccgcgupugccauggcaacggagagagacggcaaccupuuccggaagccggagagcuggagcuuugaagccaccccggucaaagg\n", + "auggcaacggagagagacggcaaccupuuccggaagccggagagcuggagcuuugaagccaccccggucaaagg\n", + "agucacauagcugugugguacgugacuggaggcauaucacuguccucgccuggaucacgccaaugugaccccaaccccaccacccuccccacccc\n", + "ccgugagcagaggagccuuguggaacaaaguagaacuugaggagcagccgccgcggugacgaggucccaggaugacgucaccgugcgauauuuaaaaupagccuuuugcucugagu\n", + "gccuccccaacucpuaaagcuccucggccucggcgugcugcgccuccgcggcugcccugcgccag\n", + "uucgccgucuccacgccuccgcpcaguuaccagcuuuggcugcucgcgccuccccaacucpuaaagcuccucggccucggcgugcugcgccuccgcggcugcccugcgccag\n", + "aguuaccagcuuuggcugcucgcgccuccccaacucpuaaagcuccucggccucggcgugcugcgccuccgcggcugcccugcgccag\n", + "augccuuggcguuuccuuuggcggauuuucuguuuucggaaguugcupuucguuuuauucagcggcaguggugcuuucccgaaucucaga\n", + "gcacagcagcucaggcggcggcccgguuccupagugucggugcggcgcguugguupcggaucccgcpcccpcpaaggagucaccggcccggcc\n", + "aaapaagacggugagccggaggagucagucagapcgagcaggagcgauuccgucgccaaacag\n", + "auccuagaggcggcugagccggaggcggucgcacaaagcpccccpccguuccagccgcggccgaccauagagaugcggcucccgccggcucupucuggag\n", + "gugaagguucuuaaucuugacggcucagcguccuccuuggcuccccccggaggccauguauggucaagcuugaagauuccccagaacagcgauaauauuca\n", + "auauccaaagagaagaagaaaaagugaaacgaucugugaaagaugcugccaagaapccagaaggaugucugcauaguucuggccaaggag\n", + "cuccuuuuccgcpccccgcccaggcggcugcccgugaccugccupcgcpaacugaaagccggaapcaagacpuucaguucguc\n", + "gcugcuggaccucggcacguugacaagauuucucupuaccgcggaggauuacuuugaauuucgguggucgccuguggucuggcauauuuagaacuuaagucuauuauuucpcacc\n", + "gcgcagcuuccccgagcgagaccaaaacagguggaauccpcuggagccggagcuccggcggcgcpuggcggcacgucccuccag\n", + "gcggagcgugugacgcugcggccgccgcggaccupauuaaupaaaaguuuuggcaggagcpagaauucugcggagccugcpacggcggcgguggcgccguaggcagccpacag\n", + "uguuguacaguguuuupcaugcacgugauacucacacaguggcuucugcucaccaacagaugaagacagaugcaccaacgag\n", + "gcugaupaaccacccuguagagguccaucugcguucagacccagacgaugccagagcuaugacupccugcagguguggcgccgapagaucagcc\n", + "ggcaggagcpagaauucugcggagccugcpacggcggcgguggcgccguaggcagccpacag\n", + "ggucuggaauggucuggaguggucuggaaagcapucagauaccccuggaaaacugaagcccguggagcagugaucucuacaggacugcuucaag\n", + "uguuguacaguguuuupcaugcacgugauacucacacaguggcuucugcucaccaacagaugaagacag\n", + "ggagaggugauugauguccagaacuuagacaauuucuagcaagcgaapauugagcucacagaagaagaa\n", + "gaaaggaagcggcugaggcgcuuggaacccgaaaagucucggugcuccuggcuaccucgcacagcggugcccgcccggccgucaguacc\n", + "ggaacccgaaaagucucggugcuccuggcuaccucgcacagcggugcccgcccggccgucaguacc\n", + "gcuuggaacccgaaaagucucggugcuccuggcuaccucgcacagcggugcccgcccggccgucaguacc\n", + "ggccaccuccuccccagccccuccugcagcgucucugcuccggaccucgccuccuccugcucucccupccucagccuccugcugcuugugguugucugugugaucggaucccaaa\n", + "acucccagcugcaggaggagcugcpccugagagagacguucagcaacuucacagcgagcacggaggcccaggucaapcuugagcacccagg\n", + "aucacuccagccugcugcuccacgugaagcaguucgugucugaccugcggagccugagcugucag\n", + "aguggccgagagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "acacaucaucucagaguuggagcaccugacguuugucaacacggaugupccgcugccpcauggcugcggcuggcccugaacgauggccug\n", + "gagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "gucaguggccgagagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "uuccuguugucaguggccgagagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "gcuuccuguugucaguggccgagagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "pcgccgcuuccuguugucaguggccgagagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "agaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "aucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "gccgcuuccuguugucaguggccgagagaccgcaucgucggcucggaggcugapcugccgcggccpagcgccccucgccucgcuccucgcuccgcuug\n", + "agaaggaagauaaacuccacauauuucugugaguaugagaaaggugcacacucuupuucagcaaucuguaggccugacuupuacacag\n", + "auauccugcuggaugacauuguccuuacccauucucucuuccucccgacggagaaauuucugcaggagcuacaccagua\n", + "aaugcuaauucacccaagaggccuucccagcucuucucacagaaggaagauaaacuccacauauuucu\n", + "auauuucugugaguaugagaaaggugcacacucuupuucagcaaucuguaggccugacuupuacacag\n", + "gcgagcccuugacuucgccgcccupccccucupcgcccccgagcggcccgagcaucuucugaaccpuucuggagcggcuugcuggapcuaccapacagcgccgccucag\n", + "agugaagcgcagugaagcagupaaccggaauauccaaagagugguuugaaggagaaagaagcauuguggcuuuauauccucupccupuuuccugaagucaccacacauagaggagagagaaa\n", + "acgugauguuupugcccgccccgcccgccucgcccgccgugagcgcccggagcgguccgcgagccaccgaggcccag\n", + "uguccupacaauuuuuggcacauuggaaauguucagccaaauuccucuacaaaaccaucagcugcuguagcugcacagucuugaguguuccugucc\n", + "ugcccgccccgcccgccucgcccgccgugagcgcccggagcgguccgcgagccaccgaggcccag\n", + "gacccugagccgcagccccgcgagagcgccgcauuucpaccggcccgcpcacaugagccccucggcpuccucgcgcgcuguucagaccccag\n", + "uuugcucugccuucaucacauugguguuuacugugcccaguccacugcuggcauuugcucugccuaacaag\n", + "agaggcaacagcugcagcagccgcgccgcccccucgcccgcggcucccapugaucccgagcacagccgguggcucgcggcgcggcagccccagaagacpaaaguucgcggccggagcgcggag\n", + "gaagaggaguuguacgcaugucagagagguugcaggcuguuuucaauuugucaguuuguggaugauggaauugacuuaaaucgaacuaaauuggaaugugaaucug\n", + "cauguacagaagcauauucccaaucugaugagcaauaugcuugccaucuugguugccagaaucagcugccauucgcugaacugagacaagaacaa\n", + "aggaggccccgcuucgcgcuaacgcuugcgaugguugaauuccccuccucacgccagccuaggagaagaaguucguagucccagag\n", + "aagupcgagucagagcacauccgguguuagaagcgcugguaggccuuggagaggcpuuaggaag\n", + "agacapuuucgccguguuggccagacuggucucgaacuccugacgucaaagugauccaccugccucggccucccaaaguacupauuacaggcgugagccacugugcccaaccu\n", + "ucagccggcaucgaaucaccgcgguucccagapcgugapcuggcguggacacaccpaauggaccguacccuuuuucaaaaggaacucaugauguauacaa\n", + "uuccuuaaaauuuggacuuguacaguaaggacuucaacugaccuuccucagacugaggacuguucccaguguauacaucaagucacugag\n", + "uggcggccucagccggcaucgaaucaccgcgguucccagapcgugapcuggcguggacacaccpaauggaccguacccuuuuucaaaaggaacucaugauguauacaa\n", + "acuaaagccagaaucccaagacugcagcgcuaccccuucacaagccgucpcugucccpcpccggcccauuuucacuuucuccacuagaggcagcagcgcaccgugacccuggcuuacuacg\n", + "cucagaggagagagcaacaaccuuaguagguucugcagcuucucacuguaucuguccuuaagaacagaauuaacaaaaguucugag\n", + "upcgagucagagcacauccgguguuagaagcgcugguaggccuuggagaggcpuuaggaag\n", + "auugugagaacaguaaguguggcccaaagaagaacauuuuuaaagaaauacaaccauupaugauagcagauucaca\n", + "gcuggagugcaguggcacaaucucagcucacugcaaacuccccucccagguucaagcaauucuccugccucagccucccaaguagcupcuacag\n", + "uguuguuguuguuuuccgcacagacauccuuuuugaaaauuucaccaugacuuuugcuuguguuuucaaugcucuguacuguugaaggacuguugcugacgacagaag\n", + "gcuugccagaaaaucgccauugcuucuaggcugacgcuugccuacuuguuuugaucgucugagagaagagacuuuguuugccaaaaccacaguugauagaaauagaaag\n", + "acuccuuuupcgguupccgcgcgccugupcpcccggagcaggccaccgagcca\n", + "ggcggaggcggcgguggcggcgguggcggcupucpccccgacpcggcggcggcugagguggaggcggapaggcggcggcggcggcggcpaag\n", + "agagaccagagagcauccagaggccuggccpuccugcagugcagacguupaggcacggagacpagapaggcgguccaggacucacucugcuccaccucugacuccuugaag\n", + "ggugccaaguaccpcuccauccaugacuucccaggcuuugaccccaaccaggaugccgaggcucuguacacugcc\n", + "cpcuccgauccagcgagcgcugcguccucgagucccugcgcccgugcguccgucugcgacccgaggccuccgcugcgcg\n", + "uccagaggccuggccpuccugcagugcagacguupaggcacggagacpagapaggcgguccaggacucacucugcuccaccucugacuccuugaag\n", + "gcuaacpcuccgauccagcgagcgcugcguccucgagucccugcgcccgugcguccgucugcgacccgaggccuccgcugcgcg\n", + "agcgagcgcugcguccucgagucccugcgcccgugcguccgucugcgacccgaggccuccgcugcgcg\n", + "gcgguugcugcupcuaacpcuccgauccagcgagcgcugcguccucgagucccugcgcccgugcguccgucugcgacccgaggccuccgcugcgcg\n", + "gauccagcgagcgcugcguccucgagucccugcgcccgugcguccgucugcgacccgaggccuccgcugcgcg\n", + "pcuaacpcuccgauccagcgagcgcugcguccucgagucccugcgcccgugcguccgucugcgacccgaggccuccgcugcgcg\n", + "uucugaugacauugcacauuauuaugugugugguuuuugagacauucauuagccaaagagaaaguuaaaauauaccuuacauauaugag\n", + "gacupccaggcgccpcaggaapaggcggccgccgugccauucuuaaaggcgcccgaguguaggcgacaggccgcugacggccggaaggaaa\n", + "cgacupccaggcgccpcaggaapaggcggccgccgugccauucuuaaaggcgcccgaguguaggcgacaggccgcugacggccggaaggaaa\n", + "acugagagacgcccuggaacgucuguggcagcuucugucucgcupacccgcacugacagcpaggcagapaggaaccuggacgccggaagccpaa\n", + "acuggacgcgguaacuguccucuugagagccaucuugccuagcupccaagccgagauagcacacucaacgcccagc\n", + "aguugguguupcuuaggcgapacguuaccpaaguugcaggcpaggacucuuccccauccagucaccugacag\n", + "gacuguucuucccucaaggccucccugccuguguuccacgucgcaacucgaapcggcuuggcaguuccugcugacauccccgcccggcccagcuuupaggaaaggcpagaccugg\n", + "cggaaguuggauuccuggccugagaauauuaggcguaguuuuccaguuuuuggcaaagcggaaauacuuaaggccccupuugacupuucuuuguuuuaucuaccggcuucugcuuuacgacag\n", + "agcuggugguggcuacaguugguguupcuuaggcgapacguuaccpaaguugcaggcpaggacucuuccccauccagucaccugacag\n", + "gugugcuuuggaaagccgcggagcuggugguggcuacaguugguguupcuuaggcgapacguuaccpaaguugcaggcpaggacucuuccccauccagucaccugacag\n", + "ccugccugaguucgccagugguccaggagccgcuuuuuuccacucpaagacuucagagaagucucacaaaggacucggcuggcugcuuuucucagugccgaagccgcgcc\n", + "gccgcuuuuuuccacucpaagacuucagagaagucucacaaaggacucggcuggcugcuuuucucagugccgaagccgcgcc\n", + "uuggucgguucaaaacagcagacgcugagcccuggccuggccgcccguucuccucguucuagccaucucuuagg\n", + "acugaggaaucagaguucugauuguggagugccucucucuaggacpcugcagcauaggagucucagcugcuuacauccagguccaggauu\n", + "guccgccpcupccuggcgcgcaggcgcuaggaagaggccgcgupcgaaggcggcgcuuggcuggupcccgcggcpauuuucccpcggcgagagcg\n", + "gagugcgcaggacuggcaagapaagccpcugcuccacgccuuucacgccuuccaccuccugcguguccaucugugagaaggagccagagcccaapag\n", + "cuuugcuagaacuuaaucugaauggcucauacaaggaggupaaccucagaagcccagaaugauucuuuucauuuugcaugugacccuccauacacugacuug\n", + "aaaapaguuucccugcacaagcuucucucucuuugcuugcugccauucuacuuaagaugugaccugcuccuccuugcuuucugcc\n", + "agguucaaacacagacggcpugaacauggcguccucgacuuggucugagacgugauaggccugccuucugguugaag\n", + "cucagaggaccaguaucccucacapugacaccugaccagcucugucccaccuggccaupcuccagguaccucugaupaagaccuuugucucuupaacaagugaauccuuggcacag\n", + "agaacucacuccugagugcaaaggcaaugucaggcacgcugguaaaggaccacuagaauccagcagcccagaccccuuucuuuguggucaagaapcaggaaaacaggugcaggacugcuacaucg\n", + "ggaaaggaagaaaauccuacugccuuucuggagagacuaapaggcauugaggaagcauaccucucugucaucuggaucuauugaaggccaacuaaucuuaaagg\n", + "gcauuggaaccuugaaaagacaaauaagcuuugccuuccuuccuaguucauuaugaacaaacuaucaacaaaaaccauccuguucagccaguuucucagagcaaccaupagucacagcag\n", + "ccuuuucgcggccpccccagcauggcugcccccacggcugapccuggcagcugcugcgcccucgcuuucuugacauucccuggcuucugugcucucuuccccaggccaccccagcagac\n", + "cgcggccpccccagcauggcugcccccacggcugapccuggcagcugcugcgcccucgcuuucuugacauucccuggcuucugugcucucuuccccaggccaccccagcagac\n", + "gccccagcauggcugcccccacggcugapccuggcagcugcugcgcccucgcuuucuugacauucccuggcuucugugcucucuuccccaggccaccccagcagac\n", + "guggcuuugcccuuuggccuuugcuggcuguguggcggcuccgcgguucgcaggucguucgcugagcgucucugcuuagccgcgguc\n", + "gucuagaggcuggagauucaagaucupugccaucauuuucugguucuguugaugacccucuuccagguuacauacagcuuacaucuugcauccucaagcg\n", + "gucuagaggcuggagauucaagaucupugccaucauuuucugguucuguugaugacccucuuccag\n", + "gcagaaguccpcuggcaagcgcuuccugcgcagcgccuaggcgaccuggaguuugugacgcugugaug\n", + "gaggaucuagauccggauaguacuacagaugupagauguuacaaauacugaagaagaacuuauuagagaaugugaagaa\n", + "ugccaucauuuucugguucuguugaugacccucuuccagguuacauacagcuuacaucuugcauccucaagcg\n", + "gacucaagaguagccuuccucgaggaccugccuuucccauuugcugccugaaguuaauguuucuugcuggccaaaucapacaugccggcauu\n", + "uucccucuuaugcuuuucaucuccauccccagccccacccacagccapcuupuucugagcugaupuaccccccucugcagagcpaugagupuguuccggcap\n", + "ccccacccacagccapcuupuucugagcugaupuaccccccucugcagagcpaugagupuguuccggcap\n", + "ugccuuucccauuugcugccugaaguuaauguuucuugcuggccaaaucapacaugccggcauu\n", + "ccaccuccccgcgaguguccuccgagcuggagcaagcccggccccagacuaguggagaagaggagcuucagcugcagcuggcacuugcc\n", + "ugcuaagugcupugcucacuggugaugaggcagaugaagguuaccaaacuuguggacaggagccucauaucagagacguggaccucacuguagccug\n", + "auacupaagaggucagcugcccccugugauuuguuuucuauucaaggaagcuuuuggucccagucucccauguuccaggug\n", + "uguucauuucugugucpcacagugcuaagugcupugcucacuggugaugaggcagaugaagguuaccaaacuuguggacaggagccucauaucagagacguggaccucacuguagccug\n", + "gucaaacugagccagacgcggcgguggcggcggcuccgcpcuacggucgcucccgccucucgagcgcugccgguggccgcagcggcgcacccacgccggcccggaggagcagag\n", + "pugcgcacuuaccaaggacaggaagguuucucuguuugaapcuuuaaacuuauaacaaagaaaauaaaa\n", + "ccaccuccccgcgaguguccuccgagcuggagcaagcccggccccagacuaguggagaagaggagcuucagcugcagcuggcacuugccaugagcagagaaguggcugagcag\n", + "aucuguucucucaagcuugcuagccaaguuccuccccacacccuaaauuguaaugacugcagcagaug\n", + "aaacugagccagacgcggcgguggcggcggcuccgcpcuacggucgcucccgccucucgagcgcugccgguggccgcagcggcgcacccacgccggcccggaggagcagag\n", + "ggucucacucuaucgcccaggcuggagugcaguggcgcaaucuuggcucacuacaaccuccaccucucpcucaagcaguucucgugccucagccuccugaguaagcupauuacag\n", + "cacuugcaaacauuccaucuggcaaucugagagaagcuacugagagaauccugagacauccccagccaccuaccacugcuccuguuccaagcaaagaagaucugcucacuccg\n", + "acugagagaauccugagacauccccagccaccuaccacugcuccuguuccaagcaaagaagaucugcucacuccg\n", + "auapaugcccaauacauaccagcugugaggcuuaucaccacuguucuuccuggcauggcccuguaagcucaucuucggcugaagagaagcuag\n", + "gugccaggcaggaauggccugcuaggagaugcagugagcccccaggaccucuccacugccuccuccaccccuguauuucacuuggcucuccaaauugacucaacuccag\n", + "ccuuucuuagccaaaucaccaaaauguccaguuagaacaagaauuuagcauucugcaaaagaaguuaacagcugag\n", + "auuucaguuugcuagaggaacauuuuaaaucugaauugaaccacccauuuuccuuucuuagccaaaucaccaaaauguccaguuagaacaagaauuuagcauucugcaaaagaaguuaacagcugag\n", + "ggccauuuaucaucacuguguaccaagugguagaggaguaagcaaugauaugcuguuuagauaugcugaaaag\n", + "auagguaugaucucgugaaaucuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugagguuaaaap\n", + "guuucaggcacagaacuguauauccaauaauagugaaauggaucccacuaauuaugacagaaaugaugauacauuuaaaugacuuggauguuuuauag\n", + "guaugaucucgugaaaucuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugag\n", + "agguaugaucucgugaaaucuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugagguuaaaap\n", + "cgugugcagacccgcguguggcgcaggcaaggacccucaaaauaaacagccucuaccuugcgagccgucuuccccaggccugcguccgagucuccgccgcugcpcccgcuccgacgcggaag\n", + "gugcagacccgcguguggcgcaggcaaggacccucaaaauaaacagccucuaccuugcgagccgucuuccccaggccugcguccgagucuccgccgcugcpcccgcuccgacgcggaag\n", + "auucugcuuuccaacugccugacugcuuguucgucucacuggugugagcuccagcauccccuuugcucgaa\n", + "gcggccupcacccguuccpucuuapaccupcuccapapccuccuguggugugugg\n", + "gccucccgcuccgccgcgcuccagccucgcucuccgccgcccgcaccgccgcccgcgcccucaccag\n", + "gagccagagagacggcagcggccccggccucccucuccgccgcgcuucagccucccgcuccgccgcgcuccagccucgcucuccgccgcccgcaccgccgcccgcgcccucaccag\n", + "gugcaauguagcaggacaacucauggagcccccccpcccaucgaguaccggacuggcugacccccuapuuggcaguagccccugacccucagu\n", + "auggaguuucgcucuuguuguccaggcuggagugcaauggcgcaaucucagcucaccacaaccuccaccucccpuucaagugauucuccugccucagccuccccaguagcupauuacag\n", + "agauccgcugcugcugccgcggcpcagaccugcaggaggcggcggcggcggcggcggccgaggcugaaggaag\n", + "gcuagauccgcugcugcugccgcggcpcagaccugcaggaggcggcggcggcggcggcggccgaggcugaaggaag\n", + "gguuuccacccuggagguugcugacacccugugcccucggcugacuuccagccgguggcacagacgccuccapcagcacucaagcgcaucuuaggaaugacag\n", + "aguugcgucccucucgguugccaggcuggaguucaguggcauguucauagcucacugaagccucaaauuccupuucaagugacccuccuaccucagccccaugaggaccupacuacag\n", + "auggagucuugcucucguugcccagacuggagugcacugcugcaaucucagcucacugcaaccucuaccucccagguucaagcgauucuccugccucagccucucgaguggcupacuauag\n", + "gcaguaucagcuaaugagacaaugaauuccauggaggcagcagupaacagaaguaccucucuuggauaauuuacaacacug\n", + "ucccugacacggaugaaaauuaaagcagagaaaaacgaagguccuuccagaagcugguggcaacuucacupagauauugcaaa\n", + "cuaguugucuggugcugcuauauapacgupuccccacagaccugcagguuccggccccucuuuucucaacccagagcaaauugaaacguccgg\n", + "gucuuccuguggaacuuucuuaucucugcauggucucuggugcagupuagcaaaggaccaucuuucucucgg\n", + "aaguugcacggcggcgugugcguuuccuaguugucuggugcugcuauauapacgupuccccacagaccugcagguuccggccccucuuuucucaacccagagcaaauugaaacguccgg\n", + "ggacaagacaugacugugaugaggagcugcuuucgccaauuuaacaccaagaagaauugaggcugcuupaggaaggccaggaggaacacgagacugagag\n", + "ucuccagguuuaaaggagagcaacuagaagucguccaaacaccugcaucucauaaggagaagaaaaguccaccuggaucuuguuucuggacugag\n", + "aacaaupacuuccacagcaaupauuuccuuccgcauucaguuugugccuuucccaugagcgagagacuccuaggagagccgcagcccguuaggaagccaugupaacucauccacag\n", + "acupcgccguuccccacccggcgcggacuucggaaccggcccupacugacuggcucuaccacucgagcgcgucuccgcuggacccggaaccccggucgguccauuccccgcgaag\n", + "ggagccgccuccuccuggccaguuccccaguaguccugaapagaccugcuguguggagccucuucupacccag\n", + "aucccucccuggugccacagcagcugagugcgcaucaaaucugaagaaaaucuacacaguacagacaguacag\n", + "auauuuuggaguguauacaauaauaucccuccugugacuagccugccuuugagauguaguuaucauuua\n", + "guagaagagagaggaccacuuguugcuaggcaaccagcacccaccucacccauguugccauggugaugaugaaaguupcugaupauuaccagcuccugcuaauugcauaugagugcucag\n", + "cagcggaaguggcuccuguaaggcagcaagguagcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "guggcuccuguaaggcagcaagguagcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "aaagcaagaacagcacugcupcuggagacggcpagccgcugcucuccggcugapaaucagagacagcuccgucccuaguggagcgcapaggcagaaguc\n", + "agcacugcupcuggagacggcpagccgcugcucuccggcugapaaucagagacagcuccgucccuaguggagcgcapaggcagaaguc\n", + "gucgucaaaguccuacauuuuagcuuucagugcugaacuuccuucucccuuaaauuauuauaaacuuuugcugcuguuuaauaaacgugaag\n", + "cagagccaagcacagupaacuuucagaaagcacugguugaaggaacgcuggaaucccupacuuacugcguagcauguaguaguugcuccucuagaaaaguuucaccuuaugaaguauagcag\n", + "apauccugcaagcagaaaucuguggupcpcggcaggugagcaaggagaacgugucuguaaaggaagcacapaacaggugguggcuuuguaagacaguuggaacccaaggaag\n", + "gcaggccaucccccaggaaagccuauguuggugapuuaugaupagaaugagugaacugcagccuggcaccaccacacccuggaaggugcaguupaagaaaguuucugaggcuguagac\n", + "aggupucuugcuguguugcccaggcugaucucgaacuccugagcucaagugucuucagccuuggccucccaaaguguuggcauuacag\n", + "upcgcgcuuccpugucaccuccagapcgccggcugcggagccgcccucagagucgcgaggccggacgcagcgcggcgccgccccacucgccccagccgccgcc\n", + "gcgacccggagguagcauuucccaggaggcacggucccccccapaupcacagccacgccag\n", + "acuuucaauucuagaucaggaacugaggacauaucuaaauuuucuaguuuuauagaaggcuuuuauccacaagaaucaagaucuucccucucugagcag\n", + "gaauccuuugugcauugaagacuuuagauuccucucugcgguagacgugcacuuauaaguauuug\n", + "aucaggaacugaggacauaucuaaauuuucuaguuuuauagaaggcuuuuauccacaagaaucaagaucuucccucucugagcag\n", + "upcugugaaaaaaaucauuuguucaacacugaugucgugauacaaggacgugaagaugugagucauugugacaucaccagccagaauugcupauucagugagaugacucacaguaagag\n", + "guuccuucuuccacauguaucccucaguaucuagaacccugaaauugguuucucuaagaaaaccaagaggcccauaagg\n", + "aaccguagcgacgccggcccuggcugagaggcguuaggaguccpuucgcccgcggaggccpagcagccgacc\n", + "aagaagaggagcacaccacaccagaaacagacaucuugcaguguuucacugucucaaccuuaucugcacaguccgaggucagucugag\n", + "agagcuucugagagacccaggaugaapaugcagugaggucaagagcccaaccuucuuucacugacacccaccucuaaggacucag\n", + "uuuacauaaacaaaugcagugcuccccuggccugccggcagcuauccacaccagaaagaggaaaagguagacug\n", + "aaaaugcccagagacuucuaauccugcaacaagaagccagguauucugaaggugaaagauaccag\n", + "agauucucaaagaugcgaguuuucugugupacuacuccuuuucagugugaccupcagcacca\n", + "cauupaacucuaacaaacuuuaaauuucagcaaaaugcccagagacuucuaauccugcaacaagaagccagguauucugaaggugaaagauaccag\n", + "gaauguuauaugcauggaguuauacaggaugugacuuuuugagauuggcuuuuuucguugacuauccugccccugagauccacccaaguugug\n", + "ggagcggagcpcpccggcggcggagccpccgcggagccaggagugacuagcacgcagcgccgccaguccgcccgcccgcccucuccccguggcgcggcggcpaggcgag\n", + "upcauagauuuccucuuugagaacaucaaccugauuuuugagacuuuuugaaaaaauucuuugugaacuacggagg\n", + "agaauaucaacacaagaguggcuucauupcauagauuuccucuuugagaacaucaaccugauuuuugagacuuuuugaaaaaauucuuugugaacuacggagg\n", + "agaguggcuucauupcauagauuuccucuuugagaacaucaaccugauuuuugagacuuuuugaaaaaauucuuugugaacuacggagg\n", + "uguuuuaacucaaaupugaugaaaaggacucuuggaaagugaaaacuuuagaugaaauucuucaggaaaagaaacgaaggaaggaacaagaggagaaagcagagauaaaacgcuuaaaaaau\n", + "gauacuucuggcgagcgccgguugcuguuucuucucaggcucapaccggccgcggccccguap\n", + "auaucaucauuaggcgucaacacaggaagugaggauacuucuggcgagcgccgguugcuguuucuucucaggcucapaccggccgcggccccguap\n", + "gcuggugaguuuaaaugagcapcuggccpccggagccgcuacappccugaggcacugcagaaagupccugagccucgagg\n", + "aaaugagcapcuggccpccggagccgcuacappccugaggcacugcagaaagupccugagccucgagg\n", + "aaugagcapcuggccpccggagccgcuacappccugaggcacugcagaaagupccugagccucgagg\n", + "gcucggccucccccaucccccgguaacggucgcuggugaguuuaaaugagcapcuggccpccggagccgcuacappccugaggcacugcagaaagupccugagccucgagg\n", + "ggugaguuuaaaugagcapcuggccpccggagccgcuacappccugaggcacugcagaaagupccugagccucgagg\n", + "aauuggaaaauauuuaacucuuaacaaaugaauuccccacuugaacucugccgaauuccugugccaccuccuccuuuagaaaacugaucuuaauacag\n", + "aaagugcuagaugaagapuuuucuucuccuucggccgcggaaacuacagacpagcuggcgapuggucuggaaaggcgguagccgguguguugguggucccggaaccucucguaaaccag\n", + "auggaguuucgcucucccaggcuggagugcaaugcugcagucucugcuuacugcaaccuccaccucccpuucaagcgauucuucugccucagccucccaaguagcupuuaaag\n", + "gcuggagugcaguggcgugaucucggcucacugcagccucgccuccupcucaagugauucuccugccucugccuccugaauagcuggcacuacag\n", + "auagcaacaaaauaaacaaacuuuggccugccaucucccaapcaaaccucacaacucaggcccaagucacaggaaucugaaug\n", + "caugugaagauugugcuugcuuuccuuccaucccuuagccauaauugccuguuuccugagaccuccuguacagccuauggaacu\n", + "gacagaauucuucaaupucugaaauaugagagaguuuccuggaagcagagaaaccacacaaauuuacuucacacu\n", + "cacauggauuaauugauguauguugaguuuauggagcugccuuuugguggcuugcuuuaucugcaguuuuuaagaagaaaaagaaggcccugagucaaagaag\n", + "gugcaaccgccgaccuugcagapauggcugcgugcpagacccuuggcacuucupcgcccucgccgcgcgcgagccgagcag\n", + "auauaagucaaaugaagaguauguauauguccgaggcapaagaggaaaauacauuugugaagaauguggaauacguuguaagaaaccuagc\n", + "uuuccucucacgcccacuuccaaccuaggaggcuuuugguuucugcuuuuuuguuuuuaaaauuaaaaguuaaacccaggaagcuuuggaucagacuuuuguguugcaguucgg\n", + "gcggccgccgccaucagcagcgcagcuccapccggcugcagcggcagcggcuccgccpcguccuggcagcag\n", + "gaaacguggupugccguuuugacaccgaccuauccuuugugagguugaagaauuuuggaagagcaugagagcagcacuugguguucagaagaaaggcuuagc\n", + "guaauagagaagaggaaaccuaaccaaugacuguggaauaauauggaagaagauggaaaaaacuuguuuaaugg\n", + "uuauggauauuaacuuaucaggacaauaaggucaaagucccuguuagagcuaauuagauucuccuugacaaaaauuggagguagcaacaaagaaaaucaa\n", + "gaucuugacagccagccauucugcagcaaaccaccuacuccaapacuggacaugagugaupagcccauauuaugg\n", + "auucuuuggaupaagagaccuugaaaggaccucuaguuuauccugcaacuccagucaauaucccacuuaaaucauuccag\n", + "aaagacgcpaggucucuggccugacacuaugaaggaagagagaaacuacaacuucgacggugugagcaccaaccgccugaaacagcaguugcuggaagaaguccgcaagaa\n", + "guagugaauggaaaacccguuaugagacacaacuugaauuaaaugaugaacuagaaaagcaaauuguuuaucucaaggagaaaguggaaaaaaucc\n", + "guagugaauggaaaacccguuaugagacacaacuugaauuaaaugaugaacuagaaaagcaaauuguuuaucucaaggagaaaguggaaaaaauccauggaaacucuucag\n", + "accgccucgugccguacuggcuucupuggcccuuaaugucuugugcucuaaggugcugapaaagacgcpaggucucuggccugacacu\n", + "ggaaagacgcpaggucucuggccugacacuaugaaggaagagagaaacuacaacuucgacggugugagcaccaaccgccugaaacagcaguugcuggaagaaguccgcaagaa\n", + "aacggcucgcggagcggcuacgcggagugacaucgccgguguuugcpugguuguugcucucpccguguggaguaggucuggaccuggacucacggcugcuuggagcguccgcc\n", + "ccgguguuugcpugguuguugcucucpccguguggaguaggucuggaccuggacucacggcugcuuggagcguccgcc\n", + "ggagcggcuacgcggagugacaucgccgguguuugcpugguuguugcucucpccguguggaguaggucuggaccuggacucacggcugcuuggagcguccgcc\n", + "ggugagaaggacuggcagaaauacgagacugcucggcggcugaaaaaauguguggacaagauccggaaccaguaucgagaagacuggaaguccaaagag\n", + "acacaacuupccccucuccucuccagcccuucuccugugugccugccuccugccgccgccacc\n", + "gaaagcauagcuggapcccgccugaaucacaggugacpccugagaccagaggcacgcacacgcacggcacucagcacgaggauuuggagaaaugag\n", + "auccucacagccaccguggacaaugccaacauccugcuacagauugacaaugcccgucuggcugcugaugacuuccgcaccaa\n", + "guuugagacagagcaggcccugcgccugaguguggaggccgacaucaauggccugcgcapugcuggaugagcugacccuggccagagccgaccuggag\n", + "gagaggaguguuuucuugcauccagaaaagaccugagaggcggacgacaccugugcuccgcagagcagaacgupaggaacggcpauguuaag\n", + "gagaaucgaagugaggagccgccagaggagagcugaggagaggapaggucgacgaccupcccupccucugaag\n", + "gaaaggagcuguaacuucuauupaaaaugacugacuucaaaguuggcaggagguguaaucaggcugcaggucuupugauuapaaucauugaggaagagcagacag\n", + "gucuguuucuuucuagguuccuguagagaucuguauguagcuguucacuuggaaguuaauuaagaaagaacaaaaacuauucauuuggauucaag\n", + "gcauccagaaaagaccugagaggcggacgacaccugugcuccgcagagcagaacgupaggaacggcpauguuaagguag\n", + "guauugaccaagaagaaauuacaggacuuaguaagagaaguggauccuaaugagcaguuggaugaagauguggaggag\n", + "pagcggugccggaaguagucpapccgcgcagucggaccggcugcugagacgaacgcuucacupcagucucugcauaucaupagauagacgcugcugccu\n", + "uuaauuggccuugguccucacagcuccaaaaagaaacaggaucucgauaagcucuaugagcugaaguccaaagcucggcagauu\n", + "auagacgcugcugccugugagucuupcccuggcaguugaggaacaagagcpaggapagucaggacccagaccuacagugg\n", + "papccgcgcagucggaccggcugcugagacgaacgcuucacupcagucucugcauaucaupagauagacgcugcugccu\n", + "puuggaggcpagcggugccggaaguagucpapccgcgcagucggaccggcugcugagacgaacgcuucacupcagucucugcauaucaupagauagacgcugcugccu\n", + "agucpapccgcgcagucggaccggcugcugagacgaacgcuucacupcagucucugcauaucaupagauagacgcugcugccu\n", + "agucggaccggcugcugagacgaacgcuucacupcagucucugcauaucaupagauagacgcugcugccu\n", + "ggaccggcugcugagacgaacgcuucacupcagucucugcauaucaupagauagacgcugcugccu\n", + "ccgguugcaguaagugcupucuuucuugucaacugcucacgacagaaggcgucucauggcguuggaauaccggcucucagcggcu\n", + "ugucugcgagauuaaucucucauggccgcugcacaagaaccuggcuuuuagcugaacuaaggagaaaguccuacaacaguuuggcgugcaacaupcuugagaaagg\n", + "cgcacgcgcuuggcugccuggcgacugcacaagcapauggcgucgcuucagcguucucpugcuacgcugcugcagcugccgccucuuccaggcgcaccag\n", + "gucucuagaagaaacugucagugccagugaagaagaaaacgupacaccagcaggcupaaugugaagcagcag\n", + "gaaaaaucgcagcccucagagagucgcuggcugaaguaucuagaaaaggacucccaagaacuggagcuggaaggaacaggaguguguuucagcaaacagccuucauccaaa\n", + "cggccgcgcuggugaacagguaggucauccuugcggccuugcggcaupcaguauccgccgccauccucuuccgugaggcgcgcugagacccggaccggcccuccugagaggaugccg\n", + "gcauuucuaacaaguuucaaggugaupaagcuucugguccapacuacacuuugagaagcccugguguaaaaag\n", + "gugcggaagaguugcapccupaacaggcccugcgugagcucgagguagugauucuuagccupcuggagagaaacag\n", + "gacucugcccucccacccaggaagcagcacccagagcugcgugcggaagaguugcapccupaacaggcccugcgugagcucgag\n", + "ugcugcaupucaagcacucuggucggucccauggagcucugcacuguagcuucccuuccacaggccccgcapcgcccccugccucugagg\n", + "gugauuguggaaaaggucucaggcucucagauuguugacauugacaaacggaaguacuugguuccaucugauaucacuguggcucaguuc\n", + "gucgcugccgcugccgcugccgccgucguuguuguugugcucggugcgcugagcuccgcggcuccgcgagccgguuccguccccuucccgccgccgcc\n", + "agucgccgccgucgcugccgcugccgcugccgccgucguuguuguugugcucggugcgcugagcuccgcggcuccgcgagccgguuccguccccuucccgccgccgcc\n", + "guguagucgccgccgucgcugccgcugccgcugccgccgucguuguuguugugcucggugcgcugagcuccgcggcuccgcgagccgguuccguccccuucccgccgccgcc\n", + "uuucagucacgugccagacuuuuucuuaauuacaaacugauagaugguccacaucucaacuaacaguauugacgcuguaagagcaucag\n", + "guuggcuuuuaggacacuaguaagaaaauauaguugugaucuguguuacacaccaaugauuguugccgcugauuuugucaaaucuauaaaagccagagacagcgaauuuaccacaaaucaag\n", + "cuuccccuucucagaauccugcucuuccuccagagagauucccaggagaagapaacaaccaauucauuccugaaagccaggccucgg\n", + "gcgcgcgaaaagcugaggcggcaacgucpacggcugcgcpacggcucuguaggaaggaacuugguucccccucccucagcuuccgccccaaaag\n", + "uuucucaagagaauauuugaccugauguaauucuuggaucucugaggucuucuacacagaaguauauuuagagagca\n", + "uucuucuuuuuuucucaagagaauauuugaccugauguaauucuuggaucucugaggucuucuacacagaaguauauuuagagagca\n", + "cagaaguagaaaguaaugaaaaggacaacaaaccugaggaagaagagcaaguaauacaugaagaugaugaaagaccuucugagaaaa\n", + "auugguguugaggapagucagagaagagapcccpccgcgcagaggcgcagaggupuaccccpccaggcagaggupaag\n", + "guaugucaccacgccgacugccagcagcugcaccgccpccccucaaccucugcgaggccugugacagcaaguuccacagcacc\n", + "gagucgacugagcccgucccgcggcucccgucccccucuccccgcgcgccccaugaggcuuuggcagucucggcccgagccuuagagccuuagacaccpaggagacccugguccuguuccuag\n", + "gaagaccapagaggaaapuggaccugaggcccccauggagaapacpcaggaugugaguaaupagaggcaaucaccuauucuccupcaaugcuuup\n", + "agcauucaaggagcuccccaggagaaagagcaaguucugaggagcccucugagcccggcauugguguugaggapagucagagaagagapcccpccgcgcagaggcgcagag\n", + "gugcgapuccggcggcggcggcucugcggccucccaguccccggcguccccggcgcccccgcccgccgcccgccccccgcgcggcacpccugcuccaugg\n", + "acgaccagagccccgcugaaaagaapacugcgcugucagaaccccgccugcauggacaapcpcggccaag\n", + "aupccacpcccccaccgccgcccgccpaggaccgagccuaagapcagccgccugaaggaacgcgacggcggcgcccgcag\n", + "ccaacagaauccuggauuugagucuguccuuugaaagcaucucugcuagaguucccacuuccaaaccccuuucagcucuucpauucagccuccag\n", + "guugcccucggaguggagucuguggcuuuccaccggagcagcgcccaggaaguguuuucgugugaugaaagu\n", + "guccugucuggcggugccgacggugapcgguggcccaacggcpagauucaaaccuggaagaaggaggaacauggagaggagagcagcpcccaggcupcagccu\n", + "caccgcugcucccggcaaaccggagcaugcaccgcaggccagcggccgaguucgcccaucccagccaucacuuuuccaacuaguccuuagagaapaag\n", + "auauucuacauuuccucauuucucuacaccgucaauuacaucugguauuuguacacagagcugaggaugaaacacacccagaguggacagagcacaucuccacug\n", + "uuuucucucccagguuucuuuuuucuuaaacuccuggccucaagugaucgucuuaccucagccucucaaagugucpauuacag\n", + "cucaapuagcupacugaagucccuaugaccuuuccacuagacgcuagcauucuggaggacaguupacuug\n", + "auauucuacauuuccucauuucucuacaccgucaauuacaucugguauuuguacacagagcugagg\n", + "gcaupacgcuauagcaauucguuugcuguccuuccucuccuucgaagaugacaaggccuaccaucguuucuuccugccuuupccgucaggcaguugguupacccgcuccaacccucg\n", + "cggcugcucaapuagcupacugaagucccuaugaccuuuccacuagacgcuagcauucuggaggacaguupacuug\n", + "gguuuugcuccgcuuuagcagcggcgaapaggacccccpagccgguccccggcguccggucgcccagcccuuuucaggcuupcccgc\n", + "ccagaucaagucaaauuuacguucugaaguauguccaaggaaauuaagagcuggugcaugaaaagauaggaaaacaauccaaauccuagcaguuaucaaaagcaaguuuauaauacag\n", + "cuguuagccgagcaagugaguagucacaucaccuccagcccucugcauucacguagcauugcugcg\n", + "aggccugaggccuugucgagaagcuuccgugaaapupccagccpccacgagaaagaaagugaauaaaucaggaauauaagupcppccccugagappucgcaaapugagac\n", + "gccccgcucccuaccuaaggcgugaggcuacgagcggucggcuguggcagcuucucuugucucugacggcuuguaguu\n", + "uucugucaggccaagcagaaggcagccuugcuggagcugcugcaugaacucuacaauuuccuggccauccaagcug\n", + "agaaccuccaacaaaugguauauaaaggaaaacaaagcaaacaaaagapaaacuuugcaauuuauuaacucaagcaugaaaauacagaaaauaaagapcucaacauacuuggaaaa\n", + "ggcapcaggcagapaaacgagugaaggccggaggugcucugapugucccuuacccuggag\n", + "ucugccuuggagaucauuucaccaucagcucagaagaucuucuuucucuguuuucagccacacagcguuucauu\n", + "gugacapagaacccagccuccaguccacacucugcguguuuuuguguccugccaggcaccguggucucauccgccugcacagcugaguccagupagcugacgcc\n", + "acacucugcguguuuuuguguccugccaggcaccguggucucauccgccugcacagcugaguccagupagcugacgcc\n", + "guuuuuguguccugccaggcaccguggucucauccgccugcacagcugaguccagupagcugacgcc\n", + "cugcpucuacgcgguaggcgccgcggugauccuggcgcagcugcugcggcgcugccgcpcuuccuggagccag\n", + "auucaucacacucccugcuuugaaucgccucuccuucaguugcugaggucaauucccuaggaaaacag\n", + "caggaucuugauugcaccaucccacucaacagccucgcuupuaapaaacaccaaaagcagaaaaauccaugcugaaggaccccaggaccagcaccaguuccugagcaucuuucccpcu\n", + "agaggccucupupaucgcpccguaaguggcuguggagcupucacugcgcggupacc\n", + "pugagagcucauuuucuguuugcacaauugccuggcuccucuggccaaapugcucugcuucuggcagcugaagaucccaguagacagcuucuuaaacc\n", + "cauuuucuguuugcacaauugccuggcuccucuggccaaapugcucugcuucuggcagcugaagaucccaguagacagcuucuuaaacc\n", + "acacucccuacaccacacccauacucagccccugcaggcaaggagagaacaggucagguucccgagagcucag\n", + "uuuugcugcauuuaaauuaagugcugcucuucagcuuuuguguacauuggaauuuauauguauauauauauagagagagagagagagagagaaa\n", + "puupcgcggcagagaugcauuapucccgaucccpccccgcgguuagaggaagaggapcggcuagaggapaagagcuucccuuacuccagccgaaaggaugcag\n", + "agaguccauuggaaaucccagcuuaugguggaggaucagguucuagaccacccacccgccagucccag\n", + "gccpugcgguggcuaacgccuguaaucccagcacuuupccgagacpcagaucacgaggucaggagauggagaccauccuggcuaacacg\n", + "guuuucuggacpaagaagapugguaaaaagccuaccauacuugccgacugaaapacaucuacapcugaguguuugg\n", + "guguugaucuaccggcugucaaggaguccaaauggaagaucucaaagcccuuaacagacuauaacaaagaagagauuggcugaauauucauacccuu\n", + "augguuuacucucucugaugaaaugupagacacuguggccucuguagcccauuuacagaucauuucauagg\n", + "guagucgccgccggcugugccccpagcgccuccpcuggugcguggccggcagcucgcgaacagcagcugauccggacug\n", + "gcupaaguucaagaucaagaugcuggacgauuugguuccuuagugaaggcucucuuccuggcugguggaugacagccuucuugcuguguucucacaugacagaaagaggaagcaag\n", + "guggcaguuuauauaaaggaagcauupacuuguggccccaccauucaggaauaaaaaaauuagaaa\n", + "agguggcaguuuauauaaaggaagcauupacuuguggccccaccauucaggaauaaaaaaauuagaaa\n", + "gccggcugugccccpagcgccuccpcuggugcguggccggcagcucgcgaacagcagcugauccggacug\n", + "cgugaucggccaacacugagucuuaccucguuguggcgucagaaccgccgucgcucgcucccuucucggcagugguaccuguucccggugucccugaggacgugcpccag\n", + "guuugcpccaaguguugcggcgacgcaccucacgucgagaaucpaggaggagacugcaaggauaggcccag\n", + "paucucgaauuuggagcupupuggaaaggccacgaggagccgcggcgucucaggagcpuggupcaucugagaagucgccacc\n", + "gucuagucuucacugcucugcguccugugcugauaaaggcucgccgcugugacccuguuaccugcaagaacuuggagguucacagcuaagacgccaggacccccuggaagccuagaaaug\n", + "guauugcugucucuaagccagaccugaucaccuggcuggagcaaggaaaagagcccuggaaucugaagagacaugag\n", + "gugcacaaaaagcuuuaaacaaguuaaaaucuaggcaacagacucccugaaguguugacugcccaacuuaaucaugacugugauucaaaaauguuaauaaauaaaccaag\n", + "guagcupauuacaguugcccaccaccaugcccggcuaauuuuuauauuuuuaguagagacagaguuucaccauguuggccaugcugaucucgaacuccugaucucag\n", + "uugcgcauuggaggucagaggacagcgagauucucgcccugagcaacggccugacgucggcggapaagcaggcgcaggcuccgugaggaggcaag\n", + "guucugapacaggcugacaaguaggacccgaggcacuggaggagcauugaaggagaagaucu\n", + "gccugupucuucauugcccagcuccugcccgcacuccugccugcugcccugaccagagucauc\n", + "auuggaggucagaggacagcgagauucucgcccugagcaacggccugacgucggcggapaagcaggcgcaggcuccgugaggaggcaag\n", + "aucucapaguugaugaccuuguuuucagaaggugacucaggucaacacapcccccaucuggucgacagaugcagugguucuaggaucugccaagcauccagguggagagccugag\n", + "aauccpcuuugccccugcaaucaacccacggaagcuccpaauggcggccaagcacgcggauccugacguucacau\n", + "gaaucaggagcuccaggaaccaggcagugaggccuuggucugagucaguguccucaggucacagagcagapacgcagacagugccaacacugaag\n", + "ggaacucuggcguaagagcuuugugugaccapcapcugguuagaagugcucapcccagacucagccaggaaucaag\n", + "gucacuuuguaggucaccaccuagapaggaagaccucgcuuuggagagupaauaaaacgcucguggaaaapuacac\n", + "gucaccaccuagapaggaagaccucgcuuuggagagupaauaaaacgcucguggaaaapuacac\n", + "gaggcccugucuagguagcuggcaccaggagccgupcaapaagaggccacacccugcccugcucugcugcagccaga\n", + "aaacccggccupaaauuuccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "ccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "augcgcacucggucaaacccggccupaaauuuccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "ggccucggcuucccucacgauauugcagaaagacacagcuuuccucuuccucuccaaaccaccucgaagcagg\n", + "uccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "paaauuuccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "cuuauaagaauugauggccggaauuacaggaagaauccaguccaagaacagaccuaucaacaugaagaagaugaagaggacuucuaucaag\n", + "aaauuuccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "gcacucggucaaacccggccupaaauuuccuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "cuaucgcacgucugcugcagcagucuccuguuucuccuccuaccuucuccauuuuucuagucccugcag\n", + "ggagcggcucuggcaucaccucggagcugacgaagcpaagagccccgcaccagugcugccccuacagagcucucggcppuggag\n", + "agucacacagcugccugguaggugacuggaggccuugaucgguucuuauupauuuugcugcuguggccccaacccuuccucccuccccacccugcg\n", + "agauaagaucagcuggagugcaguggccauaauagcucacugcagccuugaucuccupcucaagcaauccuuccaccucagccuccugaauaacugagacuacag\n", + "accgcggcgacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "gaugaauaaucugauaucaugugaaaugaggaaauaagaagcuuucugcugacuucauuuugacccapuccaaaaggugauguaauccuguggcaagaag\n", + "uagagaupuuucaccauguugcccaggcuggucucaaacuccugagcucaggccaucugcccgccucggccucccaaagugcuaggauuacag\n", + "gacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "caauaucuuuugcuupagcagaaacagaaaguacaugauggacuucauugaaggauggagauuuggaagacaugaauggaugaagaaccaa\n", + "agaupuuucaccauguugcccaggcuggucucaaacuccugagcucaggccaucugcccgccucggccucccaaagugcuaggauuacag\n", + "ggcgacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "ggagccgccgacgcagccgccaccgccgccgccgccgccaccagagccgcccuguccgcgccgcgccucggcagccggaacapccgccgucpagccccaacacacgguccacagcucauc\n", + "auaauguaggcauuguuccuaagucaugcagapuuguguaagcauggucauuugcaucauuauccugcacgucugauacagccaaacuccacgccaccugguuugcu\n", + "agccaccgcggcgacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "gccaccgcggcgacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "cccggcagccaccgcggcgacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "gcggcgacuuggcggcpugccaugcgucuggagcuucacauucucugccccccacccaccgcgccggcgcucccuugucacgccucpaagcgcgcaccugccaagcag\n", + "acaaggucacucugucgccggapcaguggcaugaucauaggucacuguaaccuggaacuccupuucaggcaaucuucccacuucagcuuccugaguagcuagaauuacag\n", + "agacapucuugcuauguugcccaggcugaucuccaacuccuguccucaagaaauccuccugccucagccucccaaagugcupauuaccaau\n", + "ucccagguaagugcugaugcugcugcuuugapccacacaccuugaggaguaggaagaguacucauacuggaagaguauucagcacggacuggaauccugcauacauaucugagcucuguguucug\n", + "guugcgcaauugcuauuuuccccagagcggcuuugucuuuggauuuagcguuucagaauugcaauuccaaaauguguaagacpauauucucuucugugcugucaagg\n", + "gucacucugucgccggapcaguggcaugaucauaggucacuguaaccuggaacuccupuucaggcaaucuucccacuucagcuuccugaguagcuagaauuacag\n", + "gugccugcuuccccuucaccuuccaccaugauuguaaguuuccugaggccuccccagacauguggaacu\n", + "agagcggcuuugucuuuggauuuagcguuucagaauugcaauuccaaaauguguaagacpauauucucuucugugcugucaagg\n", + "cucuaacuccacaaauuucaacaugcauacaaaucaagaapupuguuacaugcaaauucugcuucagupuguuggagccugagauucuggcuuucuaacaagcucccag\n", + "cuguugcgcaauugcuauuuuccccagagcggcuuugucuuuggauuuagcguuucagaauugcaauuccaaaauguguaagacpauauucucuucugugcugucaagg\n", + "gccgacgcagccgccaccgccgccgccgccgccaccagagccgcccuguccgcgccgcgccucggcagccggaacapccgccgucpagccccaacacacgguccacagcucauc\n", + "agcaauaaaagaagcaugapaagacagagcagugcaugguuauggauacuggacaaggauauuuggaaagguaaaggcugaccauuggauaug\n", + "gaagaagcaggcagcuugagacagguggagcuggaucaagcugugaacgugauuugcuggaagcuggucauuagu\n", + "cuuaaaaaagugaggaggaaguaaaugcuaaauuauucaugagccucauuugacagcacaucagaapaagugucapuuuuauaaag\n", + "agagaagaagcaggcagcuugagacagguggagcuggaucaagcugugaacgugauuugcuggaagcuggucauuagu\n", + "auucacaaguguguguaaapuguggaupacaacugcaucugccucuugugcaugccuugg\n", + "aauaaaagaagcaugapaagacagagcagugcaugguuauggauacuggacaaggauauuuggaaag\n", + "aauguuuaugcauagaaauauagcugagguggaugugguugcugucagcuauucagguuugcuaccugaucaccuccugaagauguagg\n", + "agaguuggccuggagagugagcgguggapaguggaacaaggcuucgucaagaguccccaggaguccapcgcccccgagacgg\n", + "cauuagagaagaagcaggcagcuugagacagguggagcuggaucaagcugugaacgugauuugcuggaagcug\n", + "gcagucuauuuuuaaugcuauuuaaugaaggagcgagcgccucacucagcaauaaaagaagcaugapaagacagagcagugcaugguuauggauacuggacaaggauauuuggaaag\n", + "gagcgucgaugccggcggcagugaugaguccuaggaggcgcuggcucuuuggcggcucggaggagcggcugcugcugcugcugcugcugcugguggccccuuugcag\n", + "gaugaguccuaggaggcgcuggcucuuuggcggcucggaggagcggcugcugcugcugcugcugcugcugguggccccuuugcag\n", + "cugguucapcuagaaaagagcgucgaugccggcggcagugaugaguccuaggaggcgcuggcucuuuggcggcucggaggagcggcugcugcugcugcugcugcugcugguggccccuuugcag\n", + "aaugagccucgcaggcagucaccguucugucaacugagaggaggagcccgcuuugguagugcuguccuuauggcaagaauauauagaaguuggapaagauaaacucucuucuggaugucugag\n", + "pcacapucaaggauaccagaccuggagacuggaagucuuuucagagagacuguccucagagaggagaccagaggcaugaguucpucggcaggaaaucccccugugcagugaaga\n", + "gucpcagccagagcagcugaguuccagauaaaaacugucagacccggccuguaggcugcuccauugcca\n", + "gccagaggucccuguugcugugcauauauuauuagccgaguauaugaupaaggcuuucuaaacagcucuuagacccuguuuucagugcucagugguacacagucuuugcauugccu\n", + "auaaaugaaugugaaaggcuauuuagaccucugccuuuucaccguccucccaccugccacaggcupcucuugugcuagaaaugacuugcuagcuagacaucaugguucaggaucugagucagag\n", + "ggaaccggaaguagagccuggugccupagcggcuggcgcggcggaauccapccgacccpccggaccgaccccaggcggcg\n", + "acggaaucaguccccaaugccuggaaauuccucauuggauuacuguguuuuaaacagaauuucgugaacagccuuuuaucuccaagcggaaagaaag\n", + "agagccuggugccupagcggcuggcgcggcggaauccapccgacccpccggaccgaccccaggcggcg\n", + "gagaagcccggaucgaagcgcapuggcagccccggagccpaaugugaagagcucucggcugugcagugguaccgucpccupccgcgaaggaucuucugccacagcugcaac\n", + "cccccuccaucccaucggaagaggaaggaacaaaaggucccggaccccccggaucugacpcpaccuggcgccaccuugcag\n", + "auaccugaaaaaagcggcagucugcaacccagaagapccuuacuuggaaccuaaccaugcugguacccugaucucggacuugcagccuccggaacu\n", + "agguaaagccupcgcccgcpccuccagcuapaaguguuugcgugcguccgcggccpcgaupccgugucacauggccgcugcpupcupugug\n", + "aggaagccuuugaagcacagcugaagaacaguaggucuuggagaaauuuuugcuguagaccugcucuaucuuaacag\n", + "uauguuugaacauagauugcuaaaaaucucggucuccacagaggauugguuccpacucuccugcaagcaccagaauaugagaacgcugaagucccuuguauaaaaug\n", + "gaacggcugucucccccuccucgccugugugaccuuggccagccagcuuuuccuguggccgccugcguuuucucacpugaaagcucuggcuuuaagauucuggaauuuggaauggcag\n", + "guguccacgcuuagcagcuuucucaccgccgccaaaccuugccupcacupaccgupuggccgccugucccuagcuguggcugagccaagauugcacuugugagaaggccugacaggcagc\n", + "guugcccgccugacgcccgcccgcagcgacagcgcccgccggagccgaggccgcggcggcggccgugcccaugcccgg\n", + "aauaucauucagugauaguggcgguggauaacaaugaccuccuaccagcugugaauuucucgucuuccacuaguacuaguaaaagagauugcugcuggcuaagaauacccaccggupucuug\n", + "aucauucagugauaguggcgguggauaacaaugaccuccuaccagcugugaauuucucgucuuccacuaguacuaguaaaagagauugcugcuggcuaagaauacccaccggupucuug\n", + "agucuccucccaggupagcguggagccugucacugcagccuggcggccugagcgccgagccupcupccgcggugcugaggacgcaaau\n", + "cugucacugcagccuggcggccugagcgccgagccupcupccgcggugcugaggacgcaaaugug\n", + "ggaaccuuucaaacuuccccgaaaugcacuuguggucagcagcuagcggucuuuuguuupaaaaaaaggaguagcggcuaagagcggag\n", + "caaacuuccccgaaaugcacuuguggucagcagcuagcggucuuuuguuupaaaaaaaggaguagcggcuaagagcggag\n", + "gauacucgcaggcacuuccgcccaggaagacgacguagcagccaucuuuucccuggcuuuggugauucag\n", + "cagugaccuucaaggacguggcuguggccuucacggaggaggaauupcugcupcccugcccagaggaagcuguaccgagaugug\n", + "acccgaaacccgacgagagcccgacagccggcggcgcccgagcccgaccugccugcccagccggagcgaapcgccgccccgcgcagagcccgcgccapccgccggccgcagagcag\n", + "uuaaaacgugcaggcaccagaaggcacuuccugucggugaagaagaccugucuccggugucacpcauccuguguuuugcaaacpcugaccucccuuccupagcaggaapucagg\n", + "cgacgagagcccgacagccggcggcgcccgagcccgaccugccugcccagccggagcgaapcgccgccccgcgcagagcccgcgccapccgccggccgcagagcag\n", + "aagcpcgcggaccggcupucuugcppcgagcpcggugccaccucggccccccagcggaggaauuuccuccaagaaaacaaaacag\n", + "gaaggaaaagaaguacagaagaucuggcuaaacaauuucuguauggcgaaagaaaaauucuaacuuguacgcccucuucaugcaucuuuaauucaauuugaauauuccag\n", + "gcaccagaaggcacuuccugucggugaagaagaccugucuccggugucacpcauccuguguuuugcaaacpcugaccucccuuccupagcaggaapucagg\n", + "gccuucacccgaaacccgacgagagcccgacagccggcggcgcccgagcccgaccugccugcccagccggagcgaapcgccgccccgcgcagagcccgcgccapccgccggccgcagagcag\n", + "uguuaggaaggaaaagaaguacagaagaucuggcuaaacaauuucuguauggcgaaagaaaaauucuaacuuguacgcccucuucaugcaucuuuaauucaauuugaauauuccag\n", + "uguuaggaaggaaaagaaguacagaagaucuggcuaaacaauuucuguauggcgaaagaaaaauucuaacuu\n", + "acauaacupuguggagagcgccucauugccacugcagugacuaaagcupaagacgcuggucaguucaccugccccacugguuguuuuuuaaacaaauucugauacag\n", + "cuccuccucaccagcgcuaaagccpacuggaccgagcggaguugugcgugucgccgaappupccpapagguucguuccgcggagccccagccagaaccgg\n", + "gaccaagaaucgccuucagcccugucuggugcauccuuggcagaaagugaggaggaaaacacccccauu\n", + "cuguccacugccaaggagaucauccagcacuuuaapcugcccugcggaccuaguggugugugacpcuccug\n", + "agguaggugguagcccauucaucugguuacugauacuggccggcaucaguggacugucggcagguccuugagcaacuggugugugaa\n", + "aapaccaguagacpuggauucgaggupacaupacgcagcggucggagccgccuggapuacccgguggucccgauggagcuaucaucuuugag\n", + "cuccugcgcacgcggcccggucgcugucggaagcggcugugcpuggcggccggcgcgcggupc\n", + "acaccuugcccuacccaacccugucauuauuuccccuccgacupccggugccaucggaaaccggagugaccagaggapacacg\n", + "cauccaauuucacupcugcaagauaucaauaagccuugccucuuuaaacuacuuauguacaaauaaaagugauggugagaaccuggcucaggaaaugcaguagcaggccauauugcauccaaag\n", + "gaauuacucacagcugugcugugugcauucucugupccuagcapaapacagcccuguggca\n", + "accuugcccuacccaacccugucauuauuuccccuccgacupccggugccaucggaaaccggagugaccagaggapacacg\n", + "gucauuauuuccccuccgacupccggugccaucggaaaccggagugaccagaggapacacg\n", + "gaaucucuggagacagguaaaaauagaagcaagaaaaacugauagcccucagauuucauaauuug\n", + "auuguucuucuugccugccuggaagucugcagcuaaaauuguguuaaggaguuuacugcugaagcugcuacagaaacca\n", + "auguagapccaagaaggaagcaggaccaguggaugugaggcguggucgaagaacaacagaaag\n", + "gccagaccccgucgcccggauccccugagcugcccgccaucccacgugaccgcgccgccccccagcuccaccgcuga\n", + "agaccccgucgcccggauccccugagcugcccgccaucccacgugaccgcgccgccccccagcuccaccgcuga\n", + "cucacugcggacccuggauugaaacgaucuccccgcggccgccgccgcuaccuggugcccgcaggugccugcaggaguccupccagcuggccucg\n", + "auuuugcuuupuuccgucuucucacugcggacccuggauugaaacgaucuccccgcggccgccgccgcuaccuggugcccgcaggugccugcaggaguccupccagcuggccucg\n", + "cugccgcgaagaccggcuccccgacccgcagaagucaggagagapugaagcggagcagcccgaggcpcagccucccggagcagcgccgcgcagagcccpaca\n", + "guaacgccuucaaccgcccgccgcgauagagugcccacgacccugccucpaaucccgcucugcaccgccccaccagacccggacucggagccgcgagcggcccgag\n", + "uguaacgccuucaaccgcccgccgcgauagagugcccacgacccugccucpaaucccgcucugcaccgccccaccagacccggacucggagccgcgagcggcccgag\n", + "auagcagauggaguuuuugguugcuuuuaapugugcccuacuuaacucaauggaaugaaaagaaauagguugcucucuuauuucagauucccgucguaacuuaaapaaauuuucaca\n", + "ugaguuccguguagcgucccuggcgccuuccapcuagaaaaaugagcuuuuccugcucaaaugaagg\n", + "auagaccaccaggcugaguauccugaccugagucauccccapaucaggagccuccagcapaaccuuccauuauauucuucaagcaacuuacagcugcaccgacaguugcg\n", + "aguccccuccuccgcgccggccccaacccugucgcugccgccgcgcuccgaguccccauucccgagcugccgcuguugucgcucgcucagcgucucccucucggccgcccucuccucpacg\n", + "accaccgccgagaccgcguccgccccgcgagcacagagccucgccuuugccgauccgccgcccguccacacccgccgccag\n", + "accgccgagaccgcguccgccccgcgagcacagagccucgccuuugccgauccgccgcccguccacacccgccgccag\n", + "uagagauggaguuucaacauguuguccaggcuggucuugaacucgugaccacaagugauccacccaccauggccucccaaagugcupauuacag\n", + "caccgccgagaccgcguccgccccgcgagcacagagccucgccuuugccgauccgccgcccguccacacccgccgccag\n", + "gacucggcgcgccggaaguggccapcpcgaccucggcucacagcgcgcccggcuauucucgcagcucacc\n", + "ccgagaccgcguccgccccgcgagcacagagccucgccuuugccgauccgccgcccguccacacccgccgccag\n", + "aaaacccagcggcgcgacgcgccaccaccgccgagaccgcguccgccccgcgagcacagagccucgccuuugccgauccgccgcccguccacacccgccgccag\n", + "agugcupagaaguapaggccuuaagcgaagagaupucugcacuuuggaggagccggacacuguugacuuuccugaugugaaaucuacccaggaacaaaacaccag\n", + "aggaagugugcagaupauuaacguccacauggagauauggaagaggaccpauugguaccguaacc\n", + "aguggcagcuagaucacuccaaacguacugacuggcaaauacagacucucccgcagaacugaccccagcaagaagccuuupagcag\n", + "cgccuggaagagaaaaggagauuacagcuuccccagacuaccuggagauagccauuuacugcauapucuucuuaaucgccugu\n", + "aaacguacugacuggcaaauacagacucucccgcagaacugaccccagcaagaagccuuupagcag\n", + "cugugcagucgcggcccpcggacgguggcuggcugcuccgcagcgcucggcuggcugcagcggcaccgcpuugcgcggccpaugcuccagcpcgcg\n", + "accuuuuccggcgcpccagcggcuuccpapcccggcugcpcggcaguccggcaguggcpcccppcgcccaag\n", + "aguccagcgcccgccgcccgccaccccggaccccggugucuggcuucccccgagccpaccccgcg\n", + "gacagccacaguguggaagacccugugccccuucupugaggaguaccaagugcaccugccgcccaccuuccacgcuguggcuuucuauguc\n", + "ugaaggccgacupcaggapacagcggugucgguguupagagcaggagcaaaggcuccapaga\n", + "gccuagcgacagcapacgcucgupaccccaggcuaaaccccgcuguagccuuaaaucuccuacc\n", + "paapucggagcucagupugagcaagaaaagccacguggaagaaguaagcggccagauggcucaaagacaaacucuccccugcucaggcuugcacccagacacgacacc\n", + "auacccagcagccuuuggcaugagccauguggcccgaggagauaaacagacagagagaggaacauugaugcgugugaaauguuggcag\n", + "uguacuucuccuuuugcucucagaugcugccapucccugaagapaagacacgcggaaacag\n", + "cgccgucugcccuccgcagcgcucgccccuuucucupaggacaaccugcugacccgaagccag\n", + "gguaccgguggccucugccgagcaagcuuugugcagucuggauuuaccuggacgugcucuucuccacggccuccauc\n", + "gguuuccaggaagugacgucaggcggccgcggagauggaggauuugcucgacuuggacgaggagcuucgcuacagcuuggcuaccucc\n", + "ggucccccagucapcccgcucugcugaccaupaggacgcccuggcgcucccacccuacacaaugcucgaguuugcccagaaguauuuccgagacccucagaggagacccca\n", + "gugcuccupccagccagaggacccccaugaggcggcaugcaggcpagcaggccacagaacgcag\n", + "ggaauuggcgacugcugcpcugagcgcugguuucacgcgucucpagccagguuggcggugcg\n", + "ucacagugguccuccgccggcuacgucaguggcuuucaggcgcuuuccuguuggaauuggcgacugcugcpcugagcgcugguuucacgcgucucpagccagguuggcggugcg\n", + "auuccpcpcpcgccgaggcggcgcpcpacgagcgguccpccggcgcggcugccgcucggcgccgcgguccucgugccagugagcgccgcggccgccgcagcc\n", + "guaaagcaacuggaguguagcugcacaaguacaaggcgguugcccuuuuagacacuucagucgcgagcauuug\n", + "paaacgccugcugcucuugcccuugcccacpcccccagccccagccccucuccuguggcccaccaccccugcuuuggugcc\n", + "paagugaaucaggcgccpuagupuugcupcupcuugcugagguagaggcagcgccaagaagaggccuuugccgcuggucpauup\n", + "agucggcgacgccucagagcggaagapaagugaaucaggcgccpuagupuugcupcupcuugcugagguagaggcagcgccaagaagaggccuuugccgcuggucpauup\n", + "uuuccuucuccaucgcugcgcccacapacgcgcgcccugccpagapcuucucgguucgcacucucgcucccaguccag\n", + "ggcugaagcuccuggcaccaugaugcucaccccagcaggaccagagcaccgaggcccaaggccccagccugcc\n", + "ugaagagcaagcgccauguugaagccaucauuaccauucacaucccucuuauuccugcagcugccccugcupagupcugaacacgacaauucugacgccca\n", + "cugccccugcupagupcugaacacgacaauucugacgcccaaupaaugaagacaccacagcug\n", + "gcagucggccgauccucccgccgagcgagcggcgucguagccgccgcgcucgccgaggcccugcguugcpcucccggccgccggcgaaagc\n", + "gauccucccgccgagcgagcggcgucguagccgccgcgcucgccgaggcccugcguugcpcucccggccgccggcgaaagc\n", + "ggccggcucugaggcpagcccugauuggcugapucugaggcgacagauuccggaaapaagagcagccaac\n", + "aaaggaauaaupcgccuccgcccccpccpcagaugcgguuuccucccgacucgcgaucaaaaugg\n", + "accccuacggcgcuucggaggagccaaaggaauaaupcgccuccgcccccpccpcagaugcgguuuccucccgacucgcgaucaaa\n", + "guugcuapacgcaccaaacaccccuacggcgcuucggaggagccaaaggaauaaupcgccuccgcccccpccpcagaugcgguuuccucccgacucgcgaucaaa\n", + "gauaaaagcgcggaapcuccuuuccgugguguguagccggcuuggcgugacccucgccugauccag\n", + "guugugucgccaggcuggapcaguggugucaucucggcucauuacaaccuccaccucccagguucaagcgauucuccugccucugccuccagaguagcupaauacag\n", + "pauaaaagcgcggaapcuccuuuccgugguguguagccggcuuggcgugacccucgccugauccag\n", + "agccupaaggapaagaguaacccuucaucuuupacuagucgucuuguuugccuagacuacaguuuucaaguauuuaaggaccauuuauuucaaaag\n", + "gaauuacaguuugaaaggcugacccgagagcuggaggcugaacggcagaucguagccagccagcuggagcgaugcaagcucggauccgagacuggcagc\n", + "cacagguuucpcuucugcgugcugacaauagacagccaggcuccagaaagcgccgccugaaagccag\n", + "pacuagucgucuuguuugccuagacuacaguuuucaaguauuuaaggaccauuuauuucaaaagguacaguaaag\n", + "gcggccgcgcucagacaacaaaagcggaagaugcugcaguupcaaggucaggaccuugcccugaagccpcggcgccgcgcacgccucuucccggacugaggagcugucgccggcggapugc\n", + "cgupcuuccucuaauauuacaccguaaaaggcauugaucaccauaagaaggaacauuugugaagguacuccagugccagaaagag\n", + "acgaagucuggcucugucgcccaggcuggagugcaguggcacgaucuuggcccacugcaaucuccacuucccagguucaagcgauucuccugccucagccucccgaguagcupacuacag\n", + "gcucagguggccuuccuucapagagaggaaapcaggagaaucuaaagacggaccuggugcggcggaucaag\n", + "aaccuggccggcaaucagagaggaupccacugcuggucgcccuuucucucagaguaaaaguaauuguccaggagagugguguuupuguggaap\n", + "agcacgcuggccgcpcuccugagagaggcgacucgagcccuggapaggcuaagagaacucpaaagg\n", + "gagccgagccgagccacccacucuugucccuaagcuccagaaguagcuucccacgccucccagagacagaugcucug\n", + "accacgcuuuucaucugucccgcugcguguuuuccucuugaucpaacuccugcuucuccuugccucgaa\n", + "cccggcucggccacugcupcggacaccupcgcgccgccgcpaggagcccggacucpccgaggcugcccaggca\n", + "acccggcucggccacugcupcggacaccupcgcgccgccgcpaggagcccggacucpccgaggcugcccaggca\n", + "cacugcupcggacaccupcgcgccgccgcpaggagcccggacucpccgaggcugcccaggca\n", + "guugugaccacaggaugagcugaupacuguggaucucacacaccuggcupacagcauuuccaacugugacaccuugaacaaggcaccuaaccucgccagagcuuug\n", + "uggcauccagcagcuggapucugucagccauggagguggaagucaggugcagcugcagcggccgucaccacagaaacagcccagcaugcccapugcaaaaccucaaguucaaccgcagaagag\n", + "gcuuuucuggaaucuuucgcccccggaapcagcggcpcgccuguguggaaggupuggccagagacacccgapaccugag\n", + "gcgcuuuucuggaaucuuucgcccccggaapcagcggcpcgccuguguggaaggupuggccagagacacccgapaccugag\n", + "gcccccggaapcagcggcpcgccuguguggaaggupuggccagagacacccgapaccugag\n", + "pcgagccguupauugcgcuugcgcacagcgugucuuguacguucccgcgcuuuucuggaaucuuucgcccccggaapcagcggcpcgccuguguggaag\n", + "gucguccpcaacccpagcguuuguccacacaauuucugcuccgacucugcggacuacugcaguggagcuugacucuuaaug\n", + "ucuggcaguaagaaaaagaaagucaccaaagcugaacgauugaagcugcuacaagaggaggaggagagacgacugaaagaggaag\n", + "gucguccpcaacccpagcguuuguccacacaauuucugcuccgacucugcggacuacugcaguggagcuugacucuua\n", + "pagcguuuguccacacaauuucugcuccgacucugcggacuacugcaguggagcuugacucuuaaug\n", + "cugucguccpcaacccpagcguuuguccacacaauuucugcuccgacucugcggacuacugcaguggagcuugacucuua\n", + "ggaauauuccucacuaccauuacccagacacacuucaucgacagacgguacuauaacuucaagug\n", + "agcuuuuuagaugaggaauuuccucacuaugauucccuguccugcgcagaugcaauucaacaaccucuucaagaaaaauug\n", + "caguguugccacaaacuauaugguggucaagaagcaagaauacaucagacaccccugaccuugaaacauacgugcugguacacaccucugcugg\n", + "aagcaguguugccacaaacuauaugguggucaagaagcaagaauacaucagacaccccugaccuugaaacauacgugcugguacacaccucugcugg\n", + "gcuuuuuucuuaaugacugcuagaagcugcaucuuauugacagauggucaucacauuggugagcuggagucaucagauugupcccggagugaggcugaapaguggaucagagcacugccugag\n", + "agucaccucuacuuuccugcuaccgcugccugugagcugaapcugaaccauacacuccuuuuucuacaaccagcuugcauuuuuucugcccaca\n", + "aagcugcaucuuauugacagauggucaucacauuggugagcuggagucaucagauugupcccggagugaggcugaapaguggaucagagcacugccugag\n", + "gcauuuuuagagagcuaaaaaccaaauaggucucagcuuucucapugacauauaauuuagauuugacuuggaacuacagaaggaauaupcaaaggacaugagaaacauugcagag\n", + "auggucaucacauuggugagcuggagucaucagauugupcccggagugaggcugaapaguggaucagagcacugccugag\n", + "uguaguuuccgccgcguuuauggccgcguuaagucugagugccgcuuugaguuguugaaugaagugaacuucauuugucagcguucg\n", + "ggagcccaguggaggcgcccucccgaagcgccacugcccaugcugaccacccagcccuccggcugcugauguc\n", + "ucapcaguagaacauauuuuaaucaaugccccuugauaaaagagcuugauuccagcuacugcacuuccuucaucagcucuccacug\n", + "guccggagcucggcgguggcgccggaggaggcugcagcggcggcggcggcpcccggacgagcguccggagguggcggacgaggcgccpccccc\n", + "gagucacgcgauuuccpaacccgucaggaaggacauaaacaaaacaaacccgaggcagcauggagapccguggccccugcagcggaaccggacccagucccugagccgccccuacacccacag\n", + "paacccgucaggaaggacauaaacaaaacaaacccgaggcagcauggagapccguggccccugcagcggaaccggacccagucccugagccgccccuacacccacag\n", + "gucccggcgccgcgcucguccgcagaggaggcggcccggcccpcagcugcggcucpauccgucgapaggccgagcuugccaagcuggcgcccagcpuc\n", + "ggcagcgacugcgccccgucccggcgccgcgcucguccgcagaggaggcggcccggcccpcagcugcggcucpauccgucgapaggccgagcuugccaagcuggcgcccagcpuc\n", + "uuuaaacccaggcagccugcgcugcagccgguuccugguguccccacuucgccucccuccugcugcccccaagac\n", + "pagaagcguuuccgguggcggcggaggcugcacugagcpaccugcgagcagcgcpcggcagcccpaagcg\n", + "ugcacugagcpaccugcgagcagcgcpcggcagcccpaagcggugagucgcpcggcaggcccagccag\n", + "gguggcggcggaggcugcacugagcpaccugcgagcagcgcpcggcagcccpaagcg\n", + "acuaguuugcggcauccugugguauapaagcgcuccpccuggaaucccuacgcgucccuuupuuuagcacg\n", + "uacagcuauuggaaucagaugcaaagaugguguugucuuupuagaaaaauuaguccuuucuaaacuuuaugaagaagguuccaacaaaagacuuuuuaauguugaucggcauguugga\n", + "ggucuggagcpcgagacggccapccggcgagcgcagugcagcgccgcgcggugcpcggccgagupcguc\n", + "gagacggccapccggcgagcgcagugcagcgccgcgcggugcpcggccgagupcguc\n", + "gagucacaaagucacaggcpupauccuuucaacapcucccagcaauagagcagucccacucucccagaugagcuggagaaguagcuaccucucccagacagaguupucaaauuc\n", + "aggaggaucapuguaagucagccagagagacaaggaaaauuuuggaucuauaggagaaagaacuuucaaacagcaaaagucacccaaaa\n", + "gaagcuacuaacuaucccacccuaugcagagaccccagaauccaacaauagcguguauacuuccuuc\n", + "gupugaaauccucuuuucccuucccccuuuggagccugugguuuaauaccucucauccuaucucauccuaagg\n", + "gugaagaaagcuuuuuuugcuuuggugacuaacgguguacgagcugccccuuuaupauaguaagaagcaaaguuuugugg\n", + "agaccccagaauccaacaauagcguguauacuuccuucaugaagucucaucgcugcuaugaccugauucccacaagcuccaaauugguuguauuugauacgucccugcag\n", + "uuuuagagguuugagagcgcapuugugagccggcuuugcupugaggcacpcguccagapaucuccgcuugcag\n", + "augupcpccugccccaagagaguuuccuaaagcgaggaaaccaagccpcgccucuugcaauggagacg\n", + "aggauguacagaggauccccaaccgccugcgaaacccaagccgccgcguaggagcgugcguucpcccucuucucccaccuguucg\n", + "gccagccuccacgauccagcugccaaccaucuagccuacccugaucucugagcapucgucgucauuuuacuccagaggagacugaagccaaaag\n", + "gaaaggauguacagaggauccccaaccgccugcgaaacccaagccgccgcguaggagcgugcguucpcccucuucucccaccuguucg\n", + "aacucaaauugcauaaacggcagaucucagucauaaaaaucuuuguauuaaauaggauucaaguuacaugcucugguaacgupucuaagaggaugcuaauug\n", + "guuaccuapuaugaauuaauacagacuuggaaacucugaaagaacuuagaaucagcauuuugag\n", + "agcagaagcuupcaugcugugauuuuccaauaaacugcuaucacaaugucaaaaugcaguucagacaagagcaacacagagaucucaaacauuaaaacg\n", + "ccpcggcuccpaggccupcugugacgcgcgcgccggagcpuccgaugguucucgaaggcccgcggcgccccgugcugcag\n", + "gcggaagupuguuuguuauuuccccaaaugcggaggccccugcaccacuaacgcgaggaaacgcaggcgagupaag\n", + "gcggcguuccgguuccccgaccagguguggcaccuggagcugcuggcgccgcgcagguugcuguacgcgcugugcgcccggapccucuacugccugucgcuggaccacccpcaggagcag\n", + "agccgcacagcccauupaggccgapcgcggccgupupaguccccggcaccccagguccgcgcc\n", + "auugcugccuggaccaaggcggaugcaggaagcupugguuccuggccuggccugaaucugauucuggugucuggupacgccagguucgccgcpcccag\n", + "guaacugcugguuccuugcagcugccgccucccuuacucuguauccccggcuccugcgccpuggucccuccuggacaggauuuccagcauggcuacgcaggcgucuuccacuuccag\n", + "ccgcauccaggugagacupagagcacaacaucaaaguccuggapaaugagcaguucaucaaugcggccaagaucauccgccacccuaaauacaacapacacucuggacaaugacauc\n", + "pccggccapugccgcagacgcpacgcuggcucgcucccucccucccucccuccgacgcu\n", + "augauaagagguaguggagcagaggcuugcaguaaugaagacggcuguagugaaaaapaugaaagg\n", + "gguggauuaugaucgcaucapauguuggcccugacapcggcauccgagugguugcugcgcugupcc\n", + "aguggcugcccgcacugcgcccpcgcucgccuucgcugcagcucccggugccgccgcucpccggccccccggcaggcccuccucguu\n", + "aacagcagccacggcucauagugupcugguguaacggagcagcggaauggcugugcccccagccuggagucaggccugugucgcccupaguggaauggc\n", + "ggagccccagccgcuagugcugguggccgccgcugcugccccagcuggagcccgagccgccgccucugcguccgcgcgucgcugcuucccapcggcggu\n", + "gagccccagccgcuagugcugguggccgccgcugcugccccagcuggagcccgagccgccgccucugcguccgcgcgucgcugcuucccapcggcggu\n", + "agugcugguggccgccgcugcugccccagcuggagcccgagccgccgccucugcguccgcgcgucgcugcuucccapcggcggu\n", + "agagccuucugccacacuuaacauggcggcggcggcgcccugccgaggcgccugagcpucgcgagcgugguguuacacuccaguc\n", + "gcauuccgguaccggacgccgagagcgguuugucuccgucucuggaguuguaggcgagaggugauc\n", + "acugcuccuccggcucccpaagccgcgaguuuccgcapaggcggcggcagcugcggcpccg\n", + "gucuguagccuuugcugagucaacacuacucacagugaaagugaugccuuuucuccauuugcacaacaugagugugacgugguuagccagaccaggagcucaaccucauguagaauccag\n", + "agccgcuupuguguaucugaguacuaagcccugccccapuggacccaguggagagcaaaggcuuuuaaaggagcccagccaccauag\n", + "augcgcacgagcaccccgccgccgcugccgccgccaccgccgccgccgccgccgccgccgcggcuucagcaccagcgcccggacagcggugccgcccacpc\n", + "gucpagcaggcugaacucacupcuccgccuggcaagcuupuugaaguuuaauaaaaucguccauucgucu\n", + "ugcaagugccugcauccugucugugcugagaccucuuggcguucccugcuggccugguucauguguguugaggaccagguaagcgucucuuuguccuguguaucag\n", + "gugcuggcagaggaggaguguccggcguupacccaggagcgacuuagccgugguggugaugccaaguccccaguucuucaggaaaagg\n", + "gccugcaggccucccpcuccagccacuccuapaugaggaccuggaggaggaggaagaggaggaggaggaugaggacgaggaugauuugcugacggcupugucag\n", + "gagcuggugacguuugaagauguggcuguguacuucucccuggaggagupaaaggcuggaagcagaccagcpccucuaccaggaaguc\n", + "gagcugguccuccaccuucucuggucauccgupuggacuucuupagaaagaacucagugucgucuuuggaggcagagacucuccacugcuucup\n", + "accucaccaucaagaaaggcccugguccaggaugugcaaggugugaugaaaucacapcupaaggucagcucpucacaagaagccug\n", + "cagaaguuccaccucaccaucaagaaaggcccugguccaggaugugcaaggugugaugaaaucacapcupaaggucagcucpucacaagaagccug\n", + "aguauccugccaagaguccucccugaccaccagaaguuccaccucaccaucaagaaaggcccugguccagg\n", + "agcggcggcugaggcgacugaggcggcpcggagcggcaggcggcggcggcgcggcagcggagcgcagcauc\n", + "gagcuuuccagccpcucccagagccgcgcugcgcaggagacgcgguggccugagagccugapuccccggacucgcccaggcucugagcgcgcgcccacc\n", + "gcagaagcugacaacauugugacuuugcagccauuuagagauaaaugugaaccuguuuuucucuuuaguguu\n", + "ggauguugugaaacaaaagcugacauuuauauauauauacauauauacaguauuugaguuccucaguagaaagcuaucauauauacucag\n", + "cpaugcaccgcugcpaccccccgcccggccucgcggacccgccucggcccaggacggaggaggag\n", + "ucgcggcagcccccguguacupccuugcaaaguccguuaggagcgcuccapcgacagugcccagcgguuaacaa\n", + "guggugguggagcugauccugcapccggccuupcccaaguccugaaagcccugaaucaccacuuuccagaaucuggaccuauagugcpaucccaaggcu\n", + "acaaagcaggaucugaggaagauuuuggaggcacaggaaacuuuuuaccagcaggugaagcagcugucagaggcuccuguggauuuggccucgaagcugcag\n", + "uaggagugaucggaaagccucacccauccpugaggaacccggapaccgccuccpcggagcccgccgacc\n", + "aaagaauccaggcccuuccacgcgcgugupugcpccccgaagugcucgugguuccccgcuaggucuccgcupcaggaaccggaauc\n", + "cuugcauugaaaggcucuaguuacaguggacuucuugaacgacaucauauucacaccaaaaauguagaacauauuauagauaguuuacg\n", + "gaaugapaauugagguucgucuaguaaagaggagagaauaugaugaagagacuguucgaupcagaugcugucauagcugcaggag\n", + "gcacuuaaccucugcccguccggcgcgaaguuagaggcccpcggcgcggacggcgcgcacucccggcgguapagcugaggcaapcccgagcccaagcccgcggccgcggcccggcccacg\n", + "uuucugagugcagucaaucauagcucacugcagccucgaccuccupcucagugaucuucccgguccagccuccugagcagcuaggauuacag\n", + "cugcuaaaacuaggcaugcucuguaugaguucuacugcuguugucugugguuupupcaaaacccacuggcauucugaggcucaupauguuuuuucaguuggcuuucuggaggaugug\n", + "pcgcupagcccguupccgcgaacgcagccgccacgcupccgccgagaucpugcccp\n", + "ggcggcgcpcpcgcagcpucpcgcupagcccguupccgcgaacgcagccgccacgcupccgccgagaucpugcccp\n", + "cucggccaucgacaagcggucapagaagguggccaucaagaagcugagccgacccuuucaguccgagaucuucgccaagcgcgccuaccpagcugcugcugcugaagcac\n", + "uaauuuucucauuguuuucauguuuugaguaagguaguuucacaacugauaugauucauuuagcuuuuuuaacaaagccaauauugguuaauaugauuguugugguuaauaugguuaaua\n", + "aagcuacucagauaagaggcuccaagaggacauuuuuggaugugaaaaacaaugagaaggaggacaacacacauuuacaaucgucuuaauuuu\n", + "aucuguguacaguuuccuuuugcuucaucuccugcaacaauguaaugaagacaccaugauaucauuaacauuucacacaaaaggaaaaugaggcugaaaug\n", + "ccuucagauuucuuaguuuacucagacgugacggacgcagacaaaacuaaucugcugguuuccuucucuucugaaauuacuuauuuuugcaaaccucguuuccucguugugaucgcuucucu\n", + "gcuggccccgcagucccccgccgcaccagcaccggagcuucacaccccacuuccpucaagucaccgccpaauccugugaucgcagaaag\n", + "gaugucaccuuucaacaucaccaguuugaacuuacaauacuuaaguccuggcaagucauaagupaaa\n", + "acuugacgucgcugagcaacggaagagupcagcauuugcucugaacgcucgugcgcgcuaccgcccagacggaagcggaagugccgguggagcgcgaguaggaaguggugaguucggaguagag\n", + "gcgaguaggaaguggugaguucggaguagagauggccgcgcuugcaccgcugcccccgcuccccgcacaguucaagagcauacagcaucaucugaggacggcucaggagc\n", + "acaggagcuggcugcpagcccgccguccugagucgcaggccgaggagacagugagugcgcgcccugagucgcaggccgaggagacagugagugcgcgcccugagucgcaggccgaggagac\n", + "gcucgguccgacucagcggupagugagccaggccucccgccaccgcugcugccgccaccacugcgucpcuggugcagccccpccaggccgcggccpcaggagcgcag\n", + "gugcuugaucuguugccuaggcuggaguacaguggugcuaacaaggcucacugcagcugaaccuccuaggcucaagugaucuucucaccucagccuucugaguagcupaccacag\n", + "uaaguggaggaacauuguugaaacuucccucaccacgcccucugcugaguguuugugaaacucag\n", + "gaugucacugcaggcccpcpaccupcucacggaapccppacccgcapuagaaaaaggaaguugucuuccacgaacgcuuggaaucgcaguggauuugaaucgaaaguuguucg\n", + "auuucucuugaaacugcggcucpaccugcgguaccugcuguagucacgapacpcggcggccuggucggcagagaguagccugcaacauucggccgugguuacg\n", + "cuguuuggcggccauuucucuugaaacugcggcucpaccugcgguaccugcuguagucacgapacpcggcggccuggucggcagagaguagccugcaacauucggccgugguuacg\n", + "cucuugaaacugcggcucpaccugcgguaccugcuguagucacgapacpcggcggccuggucggcagagaguagccugcaacauucggccgugguuacg\n", + "ggcgaagcucuucuaguucaucugcuggccggcucucaguccccguggcgcccccuuuccucuugucccagagcgcucucgacuccacc\n", + "agcugucgcuccacaggcgagcapcaggcgugcpcpupugguggaggcugcgapugcacggccggcccupcaggcgguagcc\n", + "guggugcacgccuauagucucagcuacucaggaaguugaggcaggaggaucgcuugagcccaggaguuugaugcugcagugagcu\n", + "agcacuagcugucgcuccacaggcgagcapcaggcgugcpcpupugguggaggcugcgapugcacggccggcccupcaggcgguagcc\n", + "aggcgagcapcaggcgugcpcpupugguggaggcugcgapugcacggccggcccupcaggcgguagcc\n", + "ggcccccuccccgccucucuccaccgccuccucuggcuccccggucagapccggagcgagaag\n", + "agugcgugucuguuuuggcaggaagaagacguuucuuccaaggagcagccuccccgcuacauccagccagugucgcccuuacacagcugcaugucag\n", + "guuaaucauucccagcucaaagccuugugcaagugcucucugccuucacgcuugcuuccuuupagagaaccuuccucuucuugaucpauucaggaaggagcccaggagcagag\n", + "gagccagccguucagugccgccgagacagccagugcgugucuguuuuggcaggaagaagacguuucuuccaaggagcagccuccccgcuacauccagccagugucgcccuuacacagcugcaugucag\n", + "uuaaucauucccagcucaaagccuugugcaagugcucucugccuucacgcuugcuuccuuupagagaaccuuccucuucuugaucpauucaggaaggagcccaggagcagag\n", + "gcuuccuuupagagaaccuuccucuucuugaucpauucaggaaggagcccaggagcagag\n", + "gucaauuucugcugucaaugugauuguggacaucuuuaugucuuacaggaaguagagagagagacaacauguuacaucugcaccauucuug\n", + "gucaauuucugcugucaaugugauuguggacaucuuuaugucuuacaggaaguagagagagagacaac\n", + "cgccgagacagccagugcgugucuguuuuggcaggaagaagacguuucuuccaaggagcagccuccccgcuacauccagccagugucgcccuuacacagcugcaugucag\n", + "uuuucuuuuauucuugucuguucugccucacucccgagcucuacugacucccaacagagcgcccaagaagaaa\n", + "gguuupuccupagucugguuaguacaapaagccuagupucuggcgcuccguuuucaagacacucggaguccgucuuugapaaagguc\n", + "pagucugguuaguacaapaagccuagupucuggcgcuccguuuucaagacacucggaguccgucuuugapaaagguc\n", + "gagugcgcacgcauccugcccgcggcgcgcgcgcaggucggugcgucugucpcgcgcucpuaccuguaccccacguagucgccgguuaccgaucggacuaaguuccag\n", + "aagcaagagauaaaguaauaaupuacugupaaaaacacagaagaacaauucgguaauauag\n", + "agucuacagacuccuccgaacacagagcugcagcucuucapaagaaaucaaaacaagaucacaag\n", + "aaacucccagccaaggcgcgcgguggcguccucgcgcccucgcucgcguccccgcccgccgccugcgcaagccaggc\n", + "aucagucgcgcagcuguguucgcggacucagguggaaggaauuucuucucuucguugacguugcugguguucacuguuuggaauuagucaaguuucpaaucaccgucgcugccaucaac\n", + "gauugucuuaccuuucuccaacccucuaacaccugaccaacaccccaaggugguagaaguugccapacagauaac\n", + "ggagcgcgcagcccgcgcgccgcapccpcggaaaguuuuuccugacggaguuuuggcugcggcagcggcggcggcggccggagcpcc\n", + "gguaaauauguguucauuaacugagauuaaccuucccugaguuuucucacaccaaggugaggacc\n", + "gcccuccccggagcccagagcucgcagcuccgccggcgccuggucccagcgcccgcggcgccgcguccccggcccaaccauggcguccuccgcggccggcugcguggugaucguuggcag\n", + "agagcucgcagcuccgccggcgccuggucccagcgcccgcggcgccgcguccccggcccaaccauggcguccuccgcggccggcugcguggugaucguuggcag\n", + "aauuaaaacucuguacccauugaacaacagcugcucauuucccccagccccagccccuggcauccacccuucuagcuuucugucucuaupuaccucag\n", + "cggagcccagagcucgcagcuccgccggcgccuggucccagcgcccgcggcgccgcguccccggcccaacc\n", + "gaagauacaaccugacagcacagccugagaucuupaucccucagccuaacacccacagacgucagcugguggauucccgcugcaucaaggccuacccacug\n", + "cuccucccccgacuuccuucccugagcacggcggcggcpacgagcaccggccugcgcgcggagccggcaccggauggupcpccagccgugcgg\n", + "gcacugccgcccugcacuguagcagaugccuaaauaaaguguggagccugaagcagaaguuuupagaugcuugccuuccuuuagaccacauuccucgccuuucucaagauuucuccgug\n", + "gccccgccuccucccccgacuuccuucccugagcacggcggcggcpacgagcaccggccugcgcgcggagccggcaccggaug\n", + "acuuccuucccugagcacggcggcggcpacgagcaccggccugcgcgcggagccggcaccgg\n", + "gacuuccuucccugagcacggcggcggcpacgagcaccggccugcgcgcggagccggcaccgg\n", + "ccugagcacggcggcggcpacgagcaccggccugcgcgcggagccggcaccggauggupcpccagccgugcgg\n", + "cucccccgacuuccuucccugagcacggcggcggcpacgagcaccggccugcgcgcggagccggcaccggaug\n", + "auaccuauaucccaacaaucauuuguucucaugaggacaaggaagauuuggaagccaguaaucgaaauguaaaagauguaaacapaacaugaugaacauaaugaaaaagaauuagaguug\n", + "gccauggaaacgaaagcggccaaguagagcuccguccugacgcgccgccucccgupcuccggccggcuaagccgcggcggacaacu\n", + "aaguagagcuccguccugacgcgccgccucccgupcuccggccggcuaagccgcggcggacaacuaugcugaaagccaagauccucuucgupccuugcgag\n", + "accuugauuccaaccacugcccggaggagguaguggaggcgagcccgguguuaaugagccccgaaggcccaag\n", + "aguggaaaaacuguuuuggccaacuuucugacagaaucuucugacaucacugaauacagcccaacccaaggagugag\n", + "gauccuagaauuugagaacccgcauguuaccagcaacaacaaaggcacpcugugaauucgagcuaupacugugguggcgaugcuaa\n", + "pccucucuccgucgccauggaaacgaaagcggccaaguagagcuccguccugacgcgccgccucccgupcuccggccggcuaagccgcggcggacaacu\n", + "guccugacgcgccgccucccgupcuccggccggcuaagccgcggcggacaacuaugcugaaagccaagauccucuucgupccuugcgag\n", + "auggaaacgaaagcggccaaguagagcuccguccugacgcgccgccucccgupcuccggccggcuaagccgcggcggacaacu\n", + "caaguagagcuccguccugacgcgccgccucccgupcuccggccggcuaagccgcggcggacaacu\n", + "aaccugauccuccgguagcgaapcuagaggcaaacaccgagcuccuccagagccgcccpagcapapcuccgcuagcccppcccuccccgcpcagaug\n", + "aguuccauauccagacucucaaaccauguuuupaucauccaaacauuccauccuccugacuccauaaacuauuggauucauaaccugcuccaugcuugaaaacaupauuggaauucg\n", + "gaacauuuuaguggacaaaccaaaugaccaaucuucaagauggucuucagagagcaacuauccuccccag\n", + "uacuugauucuaaagcucgaaaggccugcuauaguucagaauaucacauuuggaaaauaugagaaaacucauguuugcaauuugaagaaauuuaaagucuuuggugga\n", + "uccuccagagccgcccpagcapapcuccgcuagcccppcccuccccgcpcagaug\n", + "uuucuggcgcagaaauguuucuugaugaauguucugaaaagaauaaaguaucuccuggaguccuccacugucgucagcccuguacaaggcaccuugguaaacccacaggaugaacaag\n", + "aguggcgcgagcgcagcggcuacgcpcgcggagagguagccgcagaguggaccugcagguacuuggaucuccagupagcugcccucucgaaggcaggacagcgguggcggcag\n", + "agccgcagaguggaccugcagguacuuggaucuccagupagcugcccucucgaaggcaggacagcgguggcggcag\n", + "pcgcggagagguagccgcagaguggaccugcagguacuuggaucuccagupagcugcccucucgaaggcaggacagcgguggcggcag\n", + "agacagagucucccuguguugcccaggcuggucuugaacuccuggccucaagcaauccaccugccuuggccucccaaagugcugcaauuacag\n", + "gcpcgcggagagguagccgcagaguggaccugcagguacuuggaucuccagupagcugcccucucgaaggcaggacagcgguggcggcag\n", + "aguggaccugcagguacuuggaucuccagupagcugcccucucgaaggcaggacagcgguggcggcag\n", + "ccacgguguuggauacacuuguaugaggcuucagcugugcugcauaaauuucuugaagaaccugugagccagaagcaaaauuucaggacapcacacacugaacuugaa\n", + "agaguggaccugcagguacuuggaucuccagupagcugcccucucgaaggcaggacagcgguggcggcag\n", + "acaggccccagaauccuccgcgguuccccuugccupucagucuccuaggcaaccccgcuaaacaag\n", + "cgccaguuccuccgacccccuacugcucggccgcggcugcccgcgcccccauccgcagcuccucgcccgg\n", + "gcgcagcccgcccgucagcccgcucgcuggcgccgccgccgccggcagaccccgcgcuccggcuccggcucggcucgcucggcuccggugcgcgccgaggcc\n", + "acagaggcacagccacacpagugaaauccaccccuggacagucagccgcaauacugaugaagcugagaagcagccacaaugcu\n", + "ggugauaucaaggaacauccccuguuggcaucaugugagagugaagacaguauuugccagcucauug\n", + "ggcucggucucucucucucccaguggacuagaaggagcagagaguuaugcuguuucucccauucuuuacagcucaccggauguaaaagaacucuggcuagagacccuccaagg\n", + "cgcggcggugcgcpcguupucagcpucupacugguggcaccggcggcggcguaggacggaggcgucgcuag\n", + "aaguucpuuupuuggagcggcuggucacguggcuggcccgcggcggugcgcpcguupucagcpucupacugguggcaccggcggcggcguaggacggaggcgucgcuag\n", + "gcagcuucgaaccagugcaaugacgaugccagucaacpcccacaaggaugcugaccugugguccucacaugacaagaugcuggcacaaccccucaaagacagugauguugag\n", + "gaucaaaauacuugcuggaugguggacucagagaccaauaaaaauaaacugcuugaacauccuuugacugguuagccag\n", + "guggcggccggcggcggcugcpcugagcggcgaguuuccgauuuaaagcugagcugcgaggaaaauggcggcpag\n", + "agccgcuccacagcgacggcagcggcugcggcuuagucgguggcggccggcggcggcugcpcugagcggcgaguuuccgauuuaaagcugagcugcgaggaaaauggcggcpag\n", + "gcggaaaccacpcccugagacugaguggucccuaucccacuucucucupcggcgcuguagccagcggcugacaggcgcagcgaaaggcagcccucugcu\n", + "gcucugaagaagcuucaagagccacugaccccaaccaauuauugaucauccugucacccucuccuccuguauucagcaguccgccccaguugaagguugacuguggaguacuuuag\n", + "aaacucgaaaaccaaggcgcccapuugugugapuuuccgcucugcgccccgcpuuccaupuccugcacagcaucaggccugagccgccgguccaacugcuccag\n", + "aaaacucgaaaaccaaggcgcccapuugugugapuuuccgcucugcgccccgcpuuccaupuccugcacagcaucaggccugagccgccgguccaacugcuccag\n", + "guagccggagcccagccpacugucgcgcpccgcgccggcgaugccgcgcccccpccpcuguagcpccgcggcuggagugugcgccpcaggcpac\n", + "agccgupuacugccaccugcucacccacucucccuagccccagagcgcaguccgugcuggupagcguggcgacuaguugcacagcaacgguccaggaag\n", + "cgccgucupaggcucggcccggccgcccgagcaggccgcgcgcpccgccpcccgaggccagagcc\n", + "cgccgccgccgucupaggcucggcccggccgcccgagcaggccgcgcgcpccgccpcccgaggccagagcc\n", + "gucupaggcucggcccggccgcccgagcaggccgcgcgcpccgccpcccgaggccagagcc\n", + "acugcggugaaagccgaggcagcpcagacgagcapcpcggacaucuupauccggagaguggccpccggcagagcapccgaggacaccag\n", + "gcacugcggugaaagccgaggcagcpcagacgagcapcpcggacaucuupauccggagaguggccpccggcagagcapccgaggacaccag\n", + "agacgagcapcpcggacaucuupauccggagaguggccpccggcagagcapccgaggacaccag\n", + "gucaccgcuacacaugcgccuugcaaggaapcgagauuucpcapcppcpccuaggccpucucacagcgacugcgcggacpuuccugaguggaac\n", + "aggccuguuccccgcggcugcggcagcaccapccggccgccaccgccucuagaacgcggaggaggupuccupaagcpauguccaucgcuccagcuuggugguga\n", + "ccuucauccccccuuccucgccccuccacagacccapcauuugguggacacuuuugcuugcaguuaggucaaguggag\n", + "guauggaagaacauggaaauccauggaggaggacccuaucugucuucuucccccugccgcaucccapcuguggcuugucauguggcacuugcuupcuggauccag\n", + "agaagaggaaacugagguucacaaucpcagugaaaagccaaaaguaaaaccuaggcuuucuacaacucugccugcuccuacaaaag\n", + "aguuuauccagagauuccucccucpagcuccaaaucguccguacccuggaccacaagaacaucauccagguguaugag\n", + "acacgccuuucuuauuggauaccggcuuuucaupccgagcgccgcupuaggcggaaguagccgcaggc\n", + "cagcccuggagugguuucuuuacaguaauuucaacagaagagugagagauggaacccgaagaagaaaggauucguuacagccagagauug\n", + "guucuupuuuuucucugucugugaguacuugguaaaaaguuaaacccuaaagauaaaaggcagcaaauagugaccaaacgaauguuuuuggcaaauacauuggugaaggccuccuucag\n", + "uguugcaaucugguuccuaaggaggaagaggaaggcagcccuggagugguuucuuuacaguaauuucaacagaagagugagag\n", + "uggcuugguagugagcuuguucagcuccacugaaucuucuuuguggupcugcaagacauccugcaug\n", + "ggauuacccagcccagagucaggcuccagcuucupcuuuccacugcauucccugcccugcupaaggagaagcccccagcucccauccagugccccuggacacag\n", + "agauggugucuugcuauguugcccagacagaucuuguacuccupcucaaguuguccuccugccucagccucccaaagugcupauuaaagau\n", + "gucgguucucucguuaguccacggucuggucuucagcuacccgccuucgucuccgaguuugcgacucgcggaccggcguccccggcgcgaagaggcuggacucggauucguugccugag\n", + "ucguuaguccacggucuggucuucagcuacccgccuucgucuccgaguuugcgacucgcggaccggcguccccggcgcgaagaggcuggacucggauucguugccugag\n", + "auacgcaugcgugcacgcugccggucpcupcugagapapcggcggcggccgaggcggcgucguuauuuccgugguccggacagugcguggcggcgcpugaccacpagaaguag\n", + "ggcaauaaccgccuggucgccgucaggugcpcccagguggccggcgcgcccguupcacupacgcpcgcgucaggugaagacupccgcaggcgcgcuag\n", + "aauaaccgccuggucgccgucaggugcpcccagguggccggcgcgcccguupcacupacgcpcgcgucaggugaagacupccgcaggcgcgcuag\n", + "cuccuacagcucuggacaggcugcuuuucauuuuggugaguccauccaguaccuccacgugcccuguuuuucuccaggcacauccuuggccucuuccacaguccuugg\n", + "auucacuuggugaggaugaguupuuuuagguagaaguaaagagcaucaguuacauguuugccucuagaaugaagaaggauggaggagagcagugupagaagaac\n", + "ggaaagcgccgccggccaggcccagcuguggccggacapacuggaagagaggacgcggucgaguaggugugcaccagcccuggcaacgagagcgucuaccccgaacucugcuggccuugag\n", + "agaguacacuugacucucggcucugcggaccaaaaauuccaggacuaaggaauagcaagguuaggcugaaacaguccacacapcuugcgguaaacgucuuuucaggagccacucgcccagugca\n", + "agcuacgaccgcagcaggaaagcgccgccggccaggcccagcuguggccggacapacuggaagagaggacgcggucgaguag\n", + "ggaaggugupaaggacuugugaaauacauauucgaggaaaaacuaugcacaaggccgugcauuuaaaaauaaacucccuaaggcupugaaaccugcuacggucugcgcaaguugacuguua\n", + "cugcgcgugcupagccggcuggcaaggcgugcggupcpcgccgcgcugacguugcccp\n", + "accacuucacuugugugugaacauaagaaguaugacucugaaaugaaugcuucaugacagcaaggaucaugucuuucuuucuuguucaacacccuauguccagugccuugaacaguuccugacccaug\n", + "cuuccgcucugaggcgcuacugaggccgcggagccggacugcgguupcpaagagccpccguggcugacauggagcag\n", + "agacpuuucacuguguuagccagaauggucucgaucuccugaccuugugauccacccaccucccgccucccagagugcupauuacag\n", + "aucuucuuccgcucugaggcgcuacugaggccgcggagccggacugcgguupcpaagagccpccguggcugacauggagcag\n", + "cuucuuccgcucugaggcgcuacugaggccgcggagccggacugcgguupcpaagagccpccguggcugacauggagcag\n", + "gaucuucuuccgcucugaggcgcuacugaggccgcggagccggacugcgguupcpaagagccpccguggcugacauggagcag\n", + "cucugaggcgcuacugaggccgcggagccggacugcgguupcpaagagccpccguggcugacauggagcag\n", + "uagagacpuuucacuguguuagccagaauggucucgaucuccugaccuugugauccacccaccucccgccucccagagugcupauuacag\n", + "agcagugugaccuuugaagauguggcuguaaacuuuucccuggaggaauggagucuucuuaaugaggcucagagaugccuguaccgugacgug\n", + "ggcggcggcggcggcggcggcggcggcggcggcpcggcgccccgguccgcggcgccgaggcucgcaccpagcugcccaupccpcccggaguuccggcgcgccpagccg\n", + "aaagccuacaucuucaccuuccugcugagcucucgccucuucaucgagccccpagcuccuggcccpucugccaccugugcaucgagcagcagcagcuggacaagccggugcuggacaag\n", + "cugucucuagacggapacpaaguggccagaapaagugugaggaguucccguccagccugucaucagucuccccaggucuugaagcggcggcccugcuccuggccgugacc\n", + "agacgcgcgugcccagcugaaccaggugcgugagaaggcugccuucagguggccpcucccuccag\n", + "aucagacgcgcgugcccagcugaaccaggugcgugagaaggcugccuucagguggccpcucccuccag\n", + "cccauguggacuggaugcccagcgugaguguauaccgugapccuuugagcucucggacagcguggaguggucaapaggccuccaggaggaagagguggccaaccgccccaggcagcacagug\n", + "auguggacuggaugcccagcgugaguguauaccgugapccuuugagcucucggacagcguggaguggucaapaggccuccaggaggaagagguggccaaccgccccaggcagcacagug\n", + "pcccugcgguccucgguggucuugccagccccucgucaucccapcccuccgcgccugugaggacucccucag\n", + "acucuccccgcugcucgcpagccagapcccugcgguccucgguggucuugccagccccucgucaucccapcccuccgcgccugugaggacucccucag\n", + "agucggaagcaguguaccpccguggagcggcggcuccuguacccccggcgcggaccuaaapcucpccgcucpccpa\n", + "gagapuggagacaauapaggcaggcacagaggagaaagapuggapagccaggaccucaccgaaggccuccucagcccuggaauuuagaugcagucpcaupugga\n", + "ggccuguacauuuucaaggaauucuugagagguucuuggagagauucupagccaaacacuccauupauccuagcug\n", + "acauuuucaaggaauucuugagagguucuuggagagauucupagccaaacacuccauupauccuagcug\n", + "gaauauaaagaauggcuuaucaguggagaccaucgacaguugagaaaagaagaagcccaaaaaguacaagaaugaaaaucgagagu\n", + "auuuucaaggaauucuugagagguucuuggagagauucupagccaaacacuccauupauccuagcug\n", + "gaacuacupcpagccaacgucucuucuuucucccgcucuggcggaggcuuugucgcugcpcupccccapuguccccc\n", + "ucgucaggcuccugcgccccaggcaugaaccaagguuucugaacuacupcpagccaacgucucuucuuucucccgcucuggcggaggcuuugucgcugcpcupccccapuguccccc\n", + "acucggcpucggugccgccpucccaggugcccgcuacuucccagaaccuccgccucccgcuccpcccucgaaccagcgcggacaccaca\n", + "uuugagcagugacupaugcagugaggagcaagccaugcaaacaucupagacagcauccaggcagupaauggcaggugcaaagguccugag\n", + "cucuaucugcacauccupacgaaccpcagccggagagcugcggccggcccagucccgcuccgccuuugaapuaaaacccaaggcpccuugguucuggcagaapacgcu\n", + "aaagcuaaaaaucgaggcpccgagaggcugcggcggcugacuagguuuucggaccgcggcgcggcpaagagagacugcggcgg\n", + "gupagagacgcpaaagugcpucgcagaggcacuugaccaccccgcccuaggccgacccggcggacgcggcgucuggugugcpcgcupcpuaugagg\n", + "gccggaaggcggcguccgcgacgcagcuguucacgcuuaggupcgacgupcgcaggupcgcag\n", + "gagugaaacuugugcacaggaaggcuucccuuccuccagagagaacacuggaggccacucaccuuccagaccaccaaauuuaacaucacuc\n", + "gaaacggcguggcuuccpcpcgcccuggucccggagucgccgcupccuguccgcuggcguc\n", + "pccgcgccccgccgcggacaccaccpaccuggcugcgcccucccgaccccggccpcguccpcuccugcgcacucacuuggcggccgcgcccgcuggcguccucuuguucucuuccag\n", + "gcaccgaaaaagaaapaagaaaggcaaagccaaaggcaccccgauugucgaupcucgcuccagaggac\n", + "gagupaggaggccucuucaggaagagcaguuuauuuuugugaaaggaauacuuacugauuucaaacauuuggaacuaaacuggaacguauuuuucuuuccgauuucugcguuuuugag\n", + "ggagucucgcgaggaucuugugacuuaucgcggcaucgcccagcgguugccpaaacggcguggcuuccpcpcgcccuggucccggagucgccgcupccuguccgcuggcgucaug\n", + "gcaccgaaaaagaaapaagaaaggcaaagccaaaggcaccccgauugucgaupcucgcuccagaggacaugagcaaggagcag\n", + "agccggaapccggcggacgcucgcuaggucggcucgcuggccpcuccgcggcucccgugguugcc\n", + "guccaggccccgccccgcagcccagccggaapccggcggacgcucgcuaggucggcucgcuggccpcuccgcggcucccgugguugcc\n", + "cgugcpapaggccccucpaguggccgcpuccaggcgupucucggcggucaccgaucaccacacgcgcugccacugugcugc\n", + "cagcuacggcccaguucccucaaccugacccaguauguagaagccagucucugcaggcggccagcgg\n", + "acugcaacgugcguggccucaguugcgucauauccggcccuugcgaucapcuugaggaacccgcgcc\n", + "acggauuuccgccucccucacagaaggcagucacugcaacgugcguggccucaguugcgucauauccggcccuugcgaucapcuugaggaacccgcgcc\n", + "gugcaggaagcuguuuggagacucuggaaaaaggaaagccacucguagugguuauaaacgaaaaguug\n", + "gacggugcupaucccpapagcggagcggaccupcuuggucgccuccaagccggcpaccgagugcuuuaggccgcuugaaagaaaguugcuccg\n", + "acauuguapcugcuggccauggaapcacugucucucugcuuugacaaugguccccuugaacaaguuccuuuagcucug\n", + "gaggagacugcaagcaucpaugcccaggccccaaggaggcccucuuccugcagauccgagaaggacuggacaccuuucupacugcagcaccapuggcuacgccucccggcug\n", + "paucccpapagcggagcggaccupcuuggucgccuccaagccggcpaccgagugcuuuaggccgcuugaaagaaaguugcuccg\n", + "gagucagacuuccuguccccgagaccaacgcgugcpccgaaccccuccccccgccuucccccaacaauacaggacgccpuccgcgccgcguccucccugguccccccguccgauu\n", + "cucucccggapacuccucccaccgccgaguuuucccgagaaugaggccgcgcccacugacgcgcugugguuccaaaacgagaaaguacugaagg\n", + "guuguuggcugacuuccgguggugccaaagccguuuccguggaaucaggccggcuggugapuacag\n", + "gagaguguccugccugguccucugugccuggupupugccagguguguccagaggagcccaguugguagugaggcagcc\n", + "aapaapucacgcgcucggugugccgagaguguccugccugguccucugugccuggupupugccagguguguccagaggagcccaguugguagugaggcagcc\n", + "aucuuggaaaggacuuuggaaccugauagcucggaugaagagcccccaccuguguacuccccgccagccuaccac\n", + "cccuuaagagaggaacacugguggaaaagugacaagagagcaacaaguccuacuugcucaagaagagaaugacucaauacgcaggauuaggcuuauag\n", + "cuuuuaaggagucauuugguggccauggauccaacgugcucuucugagugcauuuauaaccucauacccagugacuugaaggagccuccccagccuccuag\n", + "aaaaaaacuuugaucggaacgugcccaaaaagccugcugugccauugaagacugaucauccuguc\n", + "cccugcgcucagccuucugagccuuccucaucugaugccuguuaggcucccuuugcugcugagguccupugccaucccagcacuug\n", + "aggaaaagaaacccgccuugagccaccgcagcucgugccapucucagaugauggacagacacugauauggagguucaaauuucpaaacacagcaacagcccagccaug\n", + "caggcugucpcggacpupcuggcaccgagaggcapcaggauaggagagupagacaccagguccgcgccaggcgucucp\n", + "ccuuuucucpcgcccgagaggccagcucagaccucccggcucgacaggcggcgcpcggcg\n", + "pauggaacugcugcaauaaaggupcgcuggaaagaagauguuuugagaagucaguguuuccgagaaacuuuaagcuucuaaag\n", + "pauggaacugcugcaauaaaggupcgcuggaaagaagauguuuugagaagucaguguuuccgagaaacuuuaagcuucuaaag\n", + "gugaagccggcccaggaggugaagcuucgcuuccuggaacagcugagcauccuucagaccuggcagcagapaggcggaucugcuggaggacaucag\n", + "ccucucuggacuucaauuuccucaucacuaaaguapccaauaauagcacccaccucauapaagauuaaaugacaua\n", + "gccacagccaccucuucuugcugcaaagcugagaucuccuuucucacucucaucuccaggagugcuggaguucaaag\n", + "agucpacgcpcugcgcgcgcpaccccggagcccaaacccpcaggcpcagcugugcccpcggcacggccag\n", + "gccggcggcggapcgugagcggcgcugagugacccgagucpacgcpcugcgcgcgcpaccccggagcccaaacccpcaggcpcagcugugcccpcggcacggccag\n", + "ggapcgugagcggcgcugagugacccgagucpacgcpcugcgcgcgcpaccccggagcccaaacccpcaggcpcagcugugcccpcggcacggccag\n", + "gauugcaucagcugguccagccgaggccaagucccpcgcuagcccaccucccacccgccucuuggcuccucuccucuaggccgucgcuuucpuucucucaucgcuucgucguucgcca\n", + "ugguccagccgaggccaagucccpcgcuagcccaccucccacccgccucuuggcuccucuccucuaggccgucgcuuucpuucucucaucgcuucgucguucgcca\n", + "augauuguuccacauaaagucagaapaggaaaggcgcacgcgcauupacuugacucuggaaagcguccagaccaaggucagcggagaguag\n", + "cgauugcaucagcugguccagccgaggccaagucccpcgcuagcccaccucccacccgccucuuggcuccucuccucuaggccgucgcuuucpuucucucaucgcuucgucguucgcca\n", + "auuggugcuggugaagagaagcaaaaggaaggaggcaaaaagaagaacaaagaaggaucuggagauggaggucgagcugag\n", + "ucccpcgcuagcccaccucccacccgccucuuggcuccucuccucuaggccgucgcuuucpuucucucaucgcuucgucguucgcca\n", + "gucccpcgcuagcccaccucccacccgccucuuggcuccucuccucuaggccgucgcuuucpuucucucaucgcuucgucguucgcca\n", + "aagucccpcgcuagcccaccucccacccgccucuuggcuccucuccucuaggccgucgcuuucpuucucucaucgcuucgucguucgcca\n", + "agagguuucuccaucaucuuaaguuucuguuguuuacagcuuucccuccucugcccucaucccucuagauuauuaaguuccugcaacuuaacupaacugaucaagauuucaagcuaaag\n", + "uggcacuaucacaacagagugacauaauggupauaacauggacacuugucuucuuccuuacuguaaupacuauuucuacuccacauaaucug\n", + "cacagugcucgacaugagauaaucacucacuguuccuucaguucaggacuggaaaucaauggaaaggaagaacaguuaag\n", + "guagcuucgauggccggacgugcaggcugcggauccccguaggcgagcgagcggcuagguucgugaucuggagagacgcucag\n", + "gccgaacccggaaguuccpccgaguuccucgugccaacgugucuuguaaggugcggcuagaaacupac\n", + "gugcucugaguuuuugguuucuguuucaccuugugucugagcuggucugaaggcugguuguucagacugagcuuccugccugccuguaccccgccaacagcuucagaagaag\n", + "gagcagccccupugcguccacuuucupcacgugagguupccuuggccgccugagcccuugaguuggucacuugaaccuupaauauugag\n", + "agacugagcuuccugccugccuguaccccgccaacagcuucagaagaaggugacugguggcugccugaggaauaccagupcaagagaauuagcauuucuggagcaucugcugucu\n", + "guucagacugagcuuccugccugccuguaccccgccaacagcuucagaagaaggugacugguggcugccugaggaauaccagupcaagagaauuagcauuucuggagcaucugcugucu\n", + "gcuuuaggaguaaaguuuacccugcaguuccuucuguggugaaguuuucucuuucucucggagaccagauucugccuuucugcuggapaaguguuuucacag\n", + "ggagaccagauucugccuuucugcuggapaaguguuuucacagguucuccuccuuuuaucuuuuguguuuuuuuucaagcccugcugaauuugcuagucaacucaacaggaagugaggcc\n", + "agacguuugcucuugucuuagaugcucagaugguaguggauaggccugugacgaaggugcuaccaucgugagaguaag\n", + "cuucuguggugaaguuuucucuuucucucggagaccagauucugccuuucugcuggapaaguguuuucacag\n", + "gagucaucucuguucugcuuuaggaguaaaguuuacccugcaguuccuucuguggugaaguuuucucuuucucucggagaccagauucugccuuucugcuggapaaguguuuucacag\n", + "gauucugccuuucugcuggapaaguguuuucacagguucuccuccuuuuaucuuuuguguuuuuuuucaagcccugcugaauuugcuagucaacucaacaggaagugaggcc\n", + "cuguuucaccuugugucugagcuggucugaaggcugguuguucagacugagcuuccugccugccuguaccccgccaacagcuucagaagaag\n", + "guagagcuggcuggcugugcccuuccguccuucauuagacguuugcucuugucuuagaugcucagaugguaguggauaggccugugacgaaggugcuaccaucgugagaguaag\n", + "cccccuccaauucugucccuccgccccccggcuccugcucucuccgccuagccuuuuccccucccagcugccugccugccapuagugagccggcugagaggc\n", + "puagugagccggcugagaggcauggagacgcaggaacuucppcccuggcucuucuccuccuuugcuuuuucacaucugccagucaggaucugcagg\n", + "pagcagaccaaggcgcuggucacccaacucacccucuucaaccagauccugguggagcugcpaugauauacgagaccag\n", + "uguaacgupcupcupaaupaacgugugupacugacacagacaucgauggcuacccagaccaagcacugcccugc\n", + "ggcccagauauuacacugucaaaacuuuacaaguuaauugaagagucuuguccacagcuggcaaauucagugcagaucag\n", + "gguaguguugugccuuguggugacaacuggcggcagcgcgccgcpcccgagacuuagucucpccgcc\n", + "apcccagauauuacacugucaaaacuuuacaaguuaauugaagagucuuguccacagcuggcaaauucagugcagaucag\n", + "ggcpuuucucaacggugacuugupcagugccuucugcugagcgagucauggcccgaaggcagaacuaacugugccugcagucuucacucucagg\n", + "uuuuucugugcaguuaacgagucgcuauguuucggaucugcguuacuuccccgguauuugaaggcaggagcacugcag\n", + "auauuauuuuuacagaugguuuuccauacuggaacccaaagguaaagacacucaaggacagacauuuuuggcagag\n", + "cggaaugagagacucaaccauaauagaaagaauggagaacuauuaaccaccauucuucagupcugugauuuucagapaauacuaagaa\n", + "gaaugagagacucaaccauaauagaaagaauggagaacuauuaaccaccauucuucagupcugugauuuucagapaauacuaagaa\n", + "aggucgcugucaagauggaguuuccaacccaguaaauccaapccagaccgugaccucauaaag\n", + "ggaaguuuucgcupcaacugagaaggugaguccpuaacugcggaggauccgapucaggcugcagaagcccagaaucccaccccaguccccaaguacagag\n", + "auucaauaagcucucuguugauuuuuugagcccaguaugcgauuuacauugucagucgucugaucuugcugcacuuucuauuacaggccagagaagaugugauccac\n", + "uccggaagccgguagccgccucagucgucagaccggugcuagcgacacpaguggcaaacgcauccucuugccguucccgguguuupccuugccugugacggupaaaagaaa\n", + "gcgacacpaguggcaaacgcauccucuugccguucccgguguuupccuugccugugacggupaaaagaaa\n", + "uagccgccucagucgucagaccggugcuagcgacacpaguggcaaacgcauccucuugccguucccgguguuupccuugccugugacggupaaaagaaa\n", + "aucguuuccggaagccgguagccgccucagucgucagaccggugcuagcgacacpaguggcaaacgcauccucuugccguucccgguguuupccuugccugugacggupaaaagaaa\n", + "uuccggaagccgguagccgccucagucgucagaccggugcuagcgacacpaguggcaaacgcauccucuugccguucccgguguuupccuugccugugacggupaaaagaaa\n", + "agucgucagaccggugcuagcgacacpaguggcaaacgcauccucuugccguucccgguguuupccuugccugugacggupaaaagaaa\n", + "acauaccapucuagagagucuagaagaagucuguguauaucauucuggaguaccuauuuuccaugap\n", + "gupuguuggaggcuuuaagguagcuuuaaauucguguuguccupagcucgcccuuuucggcuggagucpcuuuacggcgccgg\n", + "guauaaauagaaccgccuuaagagagauaaaauuauuacaggagcuaagucauccaaauauaauuggu\n", + "ggaagugaggcpauacuaaagcgacggagcccgguggacggaagupuguuggaggcuuuaag\n", + "aggcuuuaagguagcuuuaaauucguguuguccupagcucgcccuuuucggcuggagucpcuuuacggcgccgg\n", + "uguuggaggcuuuaagguagcuuuaaauucguguuguccupagcucgcccuuuucggcuggagucpcuuuacggcgccgg\n", + "agupuguuggaggcuuuaagguagcuuuaaauucguguuguccupagcucgcccuuuucggcuggagucpcuuuacggcgccgg\n", + "ggacggaagupuguuggaggcuuuaagguagcuuuaaauucguguuguccupagcucgcccuuuucggcuggagucpcuuuacggcgccgg\n", + "auccuuuaaauauggucuuuuuupcgcgcgcgacaaugugaggagupuggagcgugugugguguguggcugcggccupcaagagccgccgcggacc\n", + "cugaguaaguucuggapauccugccucuuggagccuucgcagccaggcagcugugaacugugagcuagagugaagcagaaaucuaggaag\n", + "cacauccuuuaaauauggucuuuuuupcgcgcgcgacaaugugaggagupuggagcgugugugguguguggcugcggccupcaagagccgccgcggaccaugag\n", + "gucacuuuaucagucugccupucacaggagaaguacugaacaugagagaucaagccugauuuguaguccugaugaugucu\n", + "auccuuuaaauauggucuuuuuupcgcgcgcgacaaugugaggagupuggagcgugugugguguguggcugcggccupcaagagccgccgcggaccaugag\n", + "aaauauggucuuuuuupcgcgcgcgacaaugugaggagupuggagcgugugugguguguggcugcggccupcaagagccgccgcggaccaugag\n", + "guucucgcaggucacuuuaucagucugccupucacaggagaaguacugaacaugagagaucaagccugauuuguaguccugaugaugucu\n", + "augugaggagupuggagcgugugugguguguggcugcggccupcaagagccgccgcggaccaugag\n", + "aggcuggcucuucucggcgugcugcggcggaacggcuguugguuucugcupuguagguccuuggcuggucpccuccgguguucugcuucuccccgcugagcugcugccuggugaagaggaagcc\n", + "ggcgugcugcggcggaacggcuguugguuucugcupuguagguccuuggcuggucpccuccgguguucugcuucuccccgcugagcugcugccuggugaagaggaagcc\n", + "uaucagaagcuuugagaucagcapcuaccaucucacucuucuguaauuucacaacauucuaaaggaaguaaaucaccagauuugcug\n", + "acagcugcccpacuccagugaucgccgcggcucgcucgcgccccggaaacugccccuucucpuc\n", + "ggcggcggcggccpccauggccagagacccccuccucupcucccugaaguccupagccgugaccc\n", + "agaauccagacgcuaaggaaaaucccuaagcagagauuuucuguuggaugcuaaaagcaaggaauaaaaguugaaaauuuggaaa\n", + "gcugaugcgaacupccacggcagccaucgcgcuuugcaguucggucuccugguguacggccaacgccaaguapauugcguucccuccagucgcag\n", + "aguuucccucuugucgcccaggcuggagugaaguggcacgaucucggcuuacugcaagcuccgccucccpuucacgccauucuccugccucagccucccgaguagcupacuacag\n", + "gcuuuucaccauucuuuagcucucaccuaccaacaaucaucuucagugaggacuuugccacuugauucacagucuguaucagugcccuccagucuuccag\n", + "gaaaaacaacauugcuacacaugcuaaaagaugacagacuuggacaacaugucccaacauuacauccca\n", + "auggagucucgcucugucacccaggcuggagugcaguggcacgaucucgacucacugcaaccuccgccucccaaguucacaccauucuccugccucagcuucccgaguagcuggaacuacag\n", + "gaugcgaacupccacggcagccaucgcgcuuugcaguucggucuccugguguacggccaacgccaaguapauugcguucccuccagucgcag\n", + "acagaguuucccucuugucgcccaggcuggagugaaguggcacgaucucggcuuacugcaagcuccgccucccpuucacgccauucuccugccucagccucccgaguagcupacuacag\n", + "ugcugagaaagguaaaaacaccuucaaauaaggaagaggaacaggcuaugaccuaaugcuugcuuggaccaguguaa\n", + "aaagaggcaaaggcagaggagaacaaaggaaggaggaaguaacuuguggaaugcugagaaagguaaaaacaccuucaaauaaggaagaggaacaggcuaugaccuaaugcuugcuuggaccagu\n", + "aucuuuauaaacaacgaguggcagaacucagagagupagaguguucccugucuauaauccagccacaggagaacaggugugugaaguucaagaagcagacaag\n", + "gcagauauagacaaagcagugcaggcagcccgccuggcuuucucucuugguucaguguggagaagg\n", + "auacaggcgagcgcgcccccpccgcggaccgcgcgcacagcccgcacugccccacgccgcpcuapacacccggcccgccacc\n", + "guccaccuucuccaaucccugccugcupagaggacgaucucuugagaaaggaaagacuucugugcucccgagaacuuccuaucag\n", + "uagaaccacagucccucuucggacaugcuguucucagaacaaaagaaaugguggaauuaugcaaugcuuagaaauggcaucgucgcuuucacucacauucauuuuccaag\n", + "guaccaguuacauucapaugugacugugaucuucacagaagcagaauggaagagacugaguccagagcagaggaaucuauacaaagaagug\n", + "ugcgauucpcapcaggcaguppacagccuggaaccagaacgcgaaacccagccucacg\n", + "aucccpcacgcuggcucuggugagcgcggccuccgcggcuccuuggccccaggaugcccucucucgupaaaggapucpaaaggccgagcguag\n", + "aaauccaccggcucaaggccucacucgaccupcuuugcaaaccccaggccguucuccuuccaccaaucccggacgccgguccccaagaaggccggcucgagcuup\n", + "agugcugcuaaauccaccggcucaaggccucacucgaccupcuuugcaaaccccaggccguucuccuuccaccaaucccggacgccgguccccaagaaggccggcucgagcuup\n", + "acuuacapcccpcugccggaccugccaacgugaaucuuaucgccauggaccuuaccuugcacaacccaaa\n", + "cuagcuaaagagcacggauuggugcauuuuacaaaccucuagcuacagaaaaguucuccaagucugcacucgacccaggaaguccaucuggcuucaccucucacuucaacuugg\n", + "ggcagcccagcugugaguugcccaagacccaccpacpaucucgcuccccgcgccacgaggcucggcca\n", + "ccacuapaugagcccgaacuapaugugacagagcgcgagacccagccuaaagagagcccggagccagcgupaggccgcugccgucgcgcgccuug\n", + "guccagcaccaugugcuaggucacucccagcgcgaggccacaccupccgucggagcagccccuccucacuucapucacccuccccagcacccauugccccacc\n", + "agguccagcaccaugugcuaggucacucccagcgcgaggccacaccupccgucggagcagccccuccucacuucapucacccuccccagcacccauugccccacc\n", + "paauauccgucgcgccgagaacgcugguuagucuuguuucpuuccggcugcguupcuugcgugcggcucgcuaagacu\n", + "acucucacucuccuccgcucaaacucagcucacuugagagucuccucccgccagcuguggaaagaacuuugcgucucuccagca\n", + "cccccuugucagcggagcuauaaggugaacugcaggaagaucccagcccuauacacgupcagagccagcagaggccagagcuguugcucugugcagaccacgagagg\n", + "gagcgcpcgucggaagcggcggagguggcagugucugcccupauggccuucccugcacgcgcgcguuu\n", + "ccagaaguggaauaauucaggaaagugcagguucupaagucucggupuuccccgcaaaaucag\n", + "gcccagaaguggaauaauucaggaaagugcagguucupaagucucggupuuccccgcaaaaucag\n", + "cucggccgccguaggccggcuuggaggcupapcccagaaguggaauaauucaggaaagugcagguucupaagucucggupuuccccgcaaaaucag\n", + "gcuugagugcaguggcgcaaucguggcucacugcagccuccaucucccpcucaggugauuuucccaccucagcuuucccgaguagcupacuacag\n", + "gaaucacugacccuggaggauguggcuguggaguucacuupaggaguggcagcuccucggcccugcucagaaggaccuguaccgagacgug\n", + "ggccggcuuggaggcupapcccagaaguggaauaauucaggaaagugcagguucupaagucucggupuuccccgcaaaaucag\n", + "agucugcpccuccpcagcggcgaggccggagcgucgcggcggagaggacgagaccpacaagaccapcaggapagccggccagccgcgagaaccccgcacgcccggcaag\n", + "aagaacaaaagcacuggaaccggucuccgguuggugagcgauucucaaapaauuuguuaagagcaggcacuuaauagaacagcccgagagaccuguaccacgauugcag\n", + "ccucuagacucagagaagcupucuaaguguaguguuagcugcagauaccugcucagcuggcuaagccuuuaac\n", + "gauaccugcucagcuggcuaagccuuuaacauggaaagaaggcucauaaagaaggaaaugaaaaagcucuu\n", + "gcacacuaugacuuggccaucaguguugcuuugcaauggcuggaucccucagaagacuuaacuuggcuggagupaggaacu\n", + "agucugagaugcgcggaugcuucagcaugccuccagaagcagagaaagaacaaaagcacuggaaccggucuccgguug\n", + "aucucccagugccuggaagagaaaacccauucuguuucgaapcauccagagcuggucacagupacccacccuccuuuuccaggcuacgccag\n", + "ucuucgcuucucpcuugucuccguguccuccgucucaguuguuucucccucucuauccuccucugucucagucuccccagccuupccggugccucuuccpcuucggcga\n", + "agucgacacgcucuucgcuucucpcuugucuccguguccuccgucucaguuguuucucccucucuauccuccucugucucagucuccccagccuupccggugccucuuccpcuucggcga\n", + "cucuucgcuucucpcuugucuccguguccuccgucucaguuguuucucccucucuauccuccucugucucagucuccccagccuupccggugccucuuccpcuucggcga\n", + "gucgacacgcucuucgcuucucpcuugucuccguguccuccgucucaguuguuucucccucucuauccuccucugucucagucuccccagccuupccggugccucuuccpcuucggcga\n", + "gcagacgcccagcggcgccaagaacccggccaagcugacuuggcgacuccucgcagccccugcucuggcacgccacaccucagacgaggcuuugaaa\n", + "cggcgccaagaacccggccaagcugacuuggcgacuccucgcagccccugcucuggcacgccacaccucagacgaggcuuugaaa\n", + "auguupagccauugagcugaaucucauuaacguucucauauuuggccpugugguggcucacgccuguaaucgcaccauuuuaggaggccaaggcggacggaucacuugag\n", + "uuucaggaauuagugacauucapauguggccauagacuucucucggcaggagupaauaccuggacccuaaucagapacuuauacapaugug\n", + "agugcgccuuucagccucaccugcagcugcgccuccuugcaccugcgccugugcuuuuucucccagcacugcggacgcgacucgapugacgcucgcuccgcucgucccgcucguc\n", + "aagcugacugccaagcuaugaaaaaguggaagagccaugugaaapcccauguggaggagaacupccccuggccaacaag\n", + "gcggaggcggaggcgcaggcgcuggcuggcaggugucgcuaaccggacgguggucgccapcgagaggcpagccggagag\n", + "ggcpaggcggaggcggaggcgcaggcgcuggcuggcaggugucgcuaaccggacgguggucgccapcgagaggcpagccggagag\n", + "ggaggcggaggcggaggcgcaggcgcuggcuggcaggugucgcuaaccggacgguggucgccapcgagaggcpagccggagag\n", + "acuuccggcpaggcggaggcggaggcgcaggcgcuggcuggcaggugucgcuaaccggacgguggucgccapcgagaggcpagccggagag\n", + "pcgagaggcpagccggagaggugaggcaggacccpcuccacugccgccucuccgagcucuugugacgcggaccucagugccagg\n", + "gaggcggaggcgcaggcgcuggcuggcaggugucgcuaaccggacgguggucgccapcgagaggcpagccggagag\n", + "cgagupacuuuccucucgcugccucccggcucugcccgcccuucgaaaguccapucccugcccgcuag\n", + "cacacaggaaggagccgagupacuuuccucucgcugccucccggcucugcccgcccuucgaaaguccapucccugcccgcuag\n", + "gcacaggacaggaguaggcaccucgccuacugcugcuuaaccuuucagcuucuccaggcccccaauccugcuugcucccagcuug\n", + "gupuuuugccccaccccugaacgcccucuguggcgccuuccacccaccuguaggcccagaagg\n", + "acccucugcaaaugugauaggcacaggacaggaguaggcaccucgccuacugcugcuuaaccuuucagcuucuccaggcccccaauccugcuugcucccagcuug\n", + "auucuugucuuacccucugcaaaugugauaggcacaggacaggaguaggcaccucgccuacugcugcuuaaccuuucagcuucuccaggcccccaauccugcuugcucccagcuug\n", + "aacuuuaggagccagucuaaggccuaggcgcagacgcacugagccuaagcagccggugauggcggcagcggcugugguggcugcggcpuccpccc\n", + "auguagaacaccgucugcuuccagugcguguacapacucpuaugguggagaagccggucccuccgguccucuuguggca\n", + "guugaugccggcccaggauggaucagaccugugaacuacccagaagaaauugucugcugcccuuuuccaauccagugaauuuagaugccccugaagacaaggacagcccuuucg\n", + "gaugauccagauuccaguaccaguacauuaggaaacaugcuagaauuaccuggaacuucaucaucaucuacuucacaggaauugccauuu\n", + "acagaaggcuuucuggaggaggcggaauuuuuauggcggccggauccggcuuucucugaacagcgagaaggcgcuuagcgcccuapaccagguaacuccugag\n", + "ggccpuapuucgccugcggccgcgucugcucpccugaggccucgaagaccccagcccaagcccccag\n", + "cgcgaacuuccucccggcgcggcccgugccccgccggccgccugcgaacaccucggccuccgccuccccucag\n", + "uuacguccuuucgauguugcgucaugcagugcgccggaggaacugugcucuuugaggccgacgcuapcccggaapaaacugcgaggcgaag\n", + "agugcgccggaggaacugugcucuuugaggccgacgcuapcccggaapaaacugcgaggcgaaggugaccpaccgag\n", + "puagaaucauuaggagcaaagaaagacccaggagccuacauuuuaagaugcauccpcacuuucaagcag\n", + "gaaggugaccpaccgagguacugcuccggcuggccggcpcgcccpauccccggugguccugacagccgcccucacpaccgcugg\n", + "cauuacagaaacacugucugcugacuucugguugaccacccaucuaguauaaugugcccuggagcuaagauaauccaguuuuuagcaugcuuuucuuuugaagacaccaucgapagucuaau\n", + "gugucugupagguuauguuuauuugagacuucuccaucpaucgccuggugucaccaaguguccacugguacugagguuugcugccugccuucuugcc\n", + "auucupuacauguggagaacaugcaguuuuguuacauagguauacaugugccauggugguuugcugcauccaucaacccaucaccuacauuag\n", + "uauuugagacuucuccaucpaucgccuggugucaccaaguguccacugguacugagguuugcugccugccuucuugcc\n", + "gcuguagccuggaggcuccpcgcpaagucaugcucgcuucacggaggcaauagcuagccg\n", + "cucccggccggcggcuauuuaagcgaggcccgccgcauccgcugcgcuguagccuggaggcuccpcgcpaagucaugcucgcuucacggaggcaauagcuagccg\n", + "gcugucccagucucauccugcccccccucccuccuaacuccgcugucacuucucuccucuuggucccuagaagugagaguccugaggcacaggaaga\n", + "caugacccucgcccgcugcccacugugagaaccapucuaggaagucagcugcugcaccccucgacggccgcuggccgcgaguccccaggag\n", + "aucagguaacgcaggugucpuccugccgcccccacagccaggugcacagcpccaccagcaccguggcag\n", + "pagcapucguggcguccgaaccuccpcugcapcgcggagcpcpcuggcccagaaaacaaauccugcggugucgcauuuccugcaacgugagccag\n", + "ggccuuuggcpugucuccccuaucgcucccucaagcccucaaguagguguuggagagapugaugccuggugcugguggaaccccugcacagagacggacacagg\n", + "gugucagaupcapacgcagugaaggacuugaaauuauggcagauggagaauggagccgacuugauggaaugaag\n", + "acgaugccgccguggagacagcugaggaagcaaaggagccugcugaagcugacaucacugagcucugccpac\n", + "pcucagagaacuccacaccugcacaccucccucucaccugcuccucuaccugcuccacccucaacccaccagaacc\n", + "cucaccugcugugcucuugcuugcacaguguccuggagcuggaccuggcucupuuuccaggaagcaguuugacuaaaggcagcaagcugcuuccucugcugccugagauaccag\n", + "accugcugugcucuugcuugcacaguguccuggagcuggaccuggcucupuuuccaggaagcaguuugacuaaaggcagcaagcugcuuccucugcugccugagauaccag\n", + "gaaugguuuuapaagacuguugccggaugacaaggcugucacuauuguucuguacuaccugacauu\n", + "aggcggccggaagcgcggccuuguupcccccguugcccgccucccaguagccgcgccucacccuaggccag\n", + "auagacuagaagaagcuuuggauccagaugaagaacgucgaauccguaucaggagacaggagcaagcugcucgcucugcccgaaugcucuacguccuccagcagcag\n", + "ugacuugaauuaauaaugguuauauuuggacaagaggagauauaucgaugcauccuuuucuacaaaaaagaucaauggaaag\n", + "aggaaugguuuuapaagacuguugccggaugacaaggcugucacuauuguucuguacuaccugacauu\n", + "uapcuuacugagagcuccauuucuggaaagccuuacaagacugaggaauaucagacugcgaaucaccpaacgguuccuuugcagcacagaagcaaucucucuccccaucuucgc\n", + "auuucuggaaagccuuacaagacugaggaauaucagacugcgaaucaccpaacgguuccuuugcagcacagaagcaaucucucuccccaucuucgc\n", + "aaaaaaaaaaaaaaaaaagaaaaagaaaaaaagaaaaaaaucagcaauuuauagaaagaagcuauagucugucpauauccaacaccaacag\n", + "ggcuuacugagagcuccauuucuggaaagccuuacaagacugaggaauaucagacugcgaaucaccpaacgguuccuuugcagcacagaagcaaucucucuccccaucuucgc\n", + "acccauucagucagaggcagccagcpaccugcuucaccgagcgcagcgaagccgagacccpcuggccccucugcugcccccggagcpcc\n", + "agcugaaggccacaggcaccgcccacuucuucaacuuccugcucaacacaaccgacuaccgaaucuugcucaaggacgaggaccacgaccgc\n", + "cccgcgcggcucugagcgccccgucccgccggcggccgcgagaccagagcgagcgaacgaaccgcggcgguccggagagccccgagcgcagcgcaggaccugg\n", + "ggugcuuggagacaacguggccaccupaguacgguucuupcaagcgccuacugugcgcccggcgccguucuacacaggaacacagcgcuuuucaag\n", + "augcuccgcugcaggcccgcgcccgcgcccggacuuugccaucggcpcagucgcpaugcgcccpagccacagccugag\n", + "gcccucaggucucugcaggugucguggaggaaccuagcaccugccauccucuuccccaauuugccacuuccagcag\n", + "gguuuaaaaagcuauuuuaaggccpcucggugucucacgcguguaaucccagcacuuupaggcccgag\n", + "acucccaccucucaacccaggaaucagagccugagacagacagaugcuucauuccuguaupugguauuccugcc\n", + "ggcccgcggagacuccacpcgccccpcgugaggcacccacucupagcacagagagcucagguagccugccuag\n", + "aagauaaaacuggacacupagaccacaacuucaugcugcgupaucucccagcuaccugcaguggccaccaugucuupuccugcugccuguacuuuggcucauuguucaaacucaag\n", + "agcugacaauuuacugguucaucaaugaaacaauauuaaauuaugaagauguaaggaaaaaauccuacgcuaacacugucgcaguuugaaag\n", + "cuuuaaaaaguugaagucuauuggaaaccuucuuauaagaaaccuuccuagucagagaauucaacuuucuucuuuucuucauucaugaaaaugcagauccacugagaaapaauaag\n", + "gguuuuguagacuuucauagccaaagaaaccggcuucggcuucuuuaaaauccccgacgacucaccugauuaaccugcugcaguucugacccugccaag\n", + "ggapcgapcpcuccucuggaggcggcpcuccaggccpcucccuaaacpucagcaauuggagcpaaggccggacag\n", + "agacapucuugcuuugucacccaggcuggagugcagugccacaaucagagcuuacuccugccuugaacuccupcuucapauccugcugccucggcccuccaagcagcugagacuacag\n", + "cuggacaacaccugauaccaacaauauaaugucaccucugcuauagaucacccaagaccagcugcauuuacauccagauguuaacuacugcagacuaagcuauuaag\n", + "ugaacaaaacuuuaaugucuagagcauuuaugapuuuuaaugauuggaaaaucuauccugagaauguggucaccauaugugacagccuugcuuucuaucuugucuucaguuucup\n", + "gapcgapcpcuccucuggaggcggcpcuccaggccpcucccuaaacpucagcaauuggagcpaaggccggacag\n", + "cupugcacaaauaaugguugccggucgcacauggauucgguagaacuuugccuuccugaaucuuuuucccugcacuacgaggaagaguag\n", + "aggucccacucugugcuuccauggagaapcggccaaugugauucupcaaaguguggugacuuguggauuuucacug\n", + "ugacaauuuacugguucaucaaugaaacaauauuaaauuaugaagauguaaggaaaaaauccuacgcuaacacugucgcaguuugaaag\n", + "gcaaauaapcgagacugaaaaaucaagucacucaguugaaggagcaaguaccugguuucacaccacgccuggcaauauuacag\n", + "ccaucucucugcccugguccuagaguuacuugaaacguaauuuggcuccugaguccugagaauauucugcauuccacuugaccucugccuguucuacccuugcpacaucugaaugcuuaauua\n", + "agugugauccccuggccagucccuaagcacgupuupuuguccugcuuggcugcggapaguggaaccucgauauuggugguguccaucgupcagcggacuaauaaaggcc\n", + "ggcugcggapaguggaaccucgauauuggugguguccaucgupcagcggacuaauaaaggccauggcgccagcagaaauccugaacpaaggagaucuccgc\n", + "gapaguggaaccucgauauuggugguguccaucgupcagcggacuaauaaaggccauggcgccagcagaaauccugaacpaaggagaucuccgc\n", + "guccugcuuggcugcggapaguggaaccucgauauuggugguguccaucgupcagcggacuaauaaaggcc\n", + "ggcugcggapaguggaaccucgauauuggugguguccaucgupcagcggacuaauaaaggcc\n", + "gauuggacgccggcgcugucagccgcgcgcggaccpcpcpcggugccccpcupcgapccpugcpccgcuggccgagaggcugaggcggcguc\n", + "uccccauugaauaacagccaaguugcuuugguuucuauuucuuuguuaagucguucccucuacaaaggacuuccuagupugugaaaggcagcgguggccacagaggcggcggagag\n", + "aagucguucccucuacaaaggacuuccuagupugugaaaggcagcgguggccacagaggcggcggagagauggccuucagcgguucccaggcucccuaccugagucca\n", + "uuaagucguucccucuacaaaggacuuccuagupugugaaaggcagcgguggccacagaggcggcggagag\n", + "aaguugcuuugguuucuauuucuuuguuaagucguucccucuacaaaggacuuccuagupugugaaaggcagcgguggccacagaggcggcggagag\n", + "cuuuguuaagucguucccucuacaaaggacuuccuagupugugaaaggcagcgguggccacagaggcggcggagag\n", + "ugaagaaauapccuuuccgccugcpcccagugagucgacacggupcccgcgauccccpacuuaccacugaauaaauccaguccagcgugcgacgacuuacuggcuuc\n", + "cggcggcapucucugcpcuggcpugcpcggccccggaggcgcguuggaacucpcuggcgcaaccgccuguggcucugccpaugcgcup\n", + "accaugucgccugaagaauggacguaucuagugguucuucuuaucuccauccccaucggcuuccucuuuaagaaagccg\n", + "ggagcaggcggcgcpcgcgcupcpaggcguggccggagcugcggcggcaagcpcupacugcucggccgccuccugcccggcgagcagcucag\n", + "acuucucccaagaucguaaauucuggaggagccauuccuucaucauccauguuugcauccuucacaccguucacugguuaagugcuua\n", + "uagccucuaguucguuagucaaaacgugaaaaaaaagaccugcuuugcccupaaauaguaacccugccaaauacaucagcuuguaggagacagag\n", + "aauaacagcaccuggccpugcaguggcucaggccuguaaucgcagcacuuupaggcugaggupcggaucaccugaggucaggagcucgagaccagccuggccaaaaug\n", + "aauaacagcaccuggccpugcaguggcucaggccuguaaucgcagcacuuupaggcugaggupcggaucaccugaggucaggagcucgagaccagccuggccaaa\n", + "pcggagcuagccggagccgcgaguccauuuupcugugcuuggcgcguaccgugcggucccuguaguuggaggacpcggucgcgcggccuuucccacuagccggag\n", + "aaguuugcuaauaaagacaucaccaaagguuaaagagaaaaucaucuagaggaaaugcuggcaguauggcauguguucuuuaacaaaucucuacagcagauucucucguuuuap\n", + "acucuguccugugcuggacacaaugguuuacccuggagagaagcccuucpaggaggaggcagccaggcugugcucagaggcauuucucuuugcuga\n", + "cucugccccaaguauuuucagccccagccggccacacagcucggaucuccuccuguggauccccccagcucugcg\n", + "auugucaaguggucagacuguuguuugccauuagcuugcagaccupauccuuaucggcuaauugcugaagcaaguguggacaacuucagcaagcupuggcguuc\n", + "agcgcggcgcggcapauucgcpcgaccacccggcgcaggagcggccgcguuucggccucagaa\n", + "acggagugucguucugucguccaggcuggagugcagugguguggucucggcucaccacaaccucugccuacupuuccagugauucuccugccucagcaucccgaguagcupacuacag\n", + "gagapcgcagcgcggcgcggcapauucgcpcgaccacccggcgcaggagcggccgcguuucggccucagaa\n", + "acgagapcgcagcgcggcgcggcapauucgcpcgaccacccggcgcaggagcggccgcguuucggccucagaa\n", + "ccagcaccccpcugcgcacugcagcuccccaggccacccaccacccuucuggucucugagcccaggaugcgagg\n", + "ugacapucuuacuauguuucccaggcugauguugaacuccuggccuccagcucuugaacuccuggccucgagcaauccucccacccug\n", + "ccacapaucugauuccucccapauguccugcgccucapuccggugguggccugcggcaucccuugcggugccagaagccgupacgag\n", + "gaaggcaauagaggcugugcucugaaccuuucccucacgaugaucuucugccuguugaccauccuggugucuuucccauguggcccuguaugguuggcaugguuccugucuuuaggacuu\n", + "acuucaguucccgccgcgagccuucuucuuggucuucuggccuggcggcgaucgucggccaguuuaucccucggaguugcacu\n", + "ugguggcaggaggcugcgaggagccggcgcggucgcagucuccacggcgcaggcccacgguagcgcagccgcucugag\n", + "gcuggagugcaguggugugaucucggcucucugcaacuuccacaucccpuucaagcgauucuacugccucagccucccgaguaguupacuacag\n", + "uuccugguccagaacuuuacacagaaaaggugcucaaaggauauuuguuuaaugaaugugguaugcugacauuuaaacaggacaaaacuug\n", + "gaggcugcgaggagccggcgcggucgcagucuccacggcgcaggcccacgguagcgcagccgcucugag\n", + "ccccuuucaguuccugguccagaacuuuacacagaaaaggugcucaaaggauauuuguuuaaugaaugugguaugcugacauuuaaacaggacaaaacuug\n", + "agaagcggcagcgcucgccauugccgcugguggcaggaggcugcgaggagccggcgcggucgcagucuccacggcgcaggcccacgguagcgcagccgcucugag\n", + "ggaaugauauauaucuaapuguaucacagccugcguguucacagccuagccugccagcagcccccagaagaaacugcpaauucagcgugaacaugauacaaucagcag\n", + "gacucgguccpccggagaccgacggcaacagcggcucaggacccacgcugcccccaccccucccgagcag\n", + "cucuuucaccacupcgcugcgcgcugcccuucccuccgcgcacaggcugccggcucaccgcuugcuaauggcagccpucucccupacagcaagaccuccgcucaggccccucuuucga\n", + "agcauaagucggaccugccucucacgcaauggauccccuggcggcaacccgagaccgguucuccuacccgcauuccgccaagucucucgcucugcccaggacgcacag\n", + "gcagagaugagcuupcuuagccgaguaaggagugagcggcuuuucagccucagugcugcggcagaggcgg\n", + "gcgcgcugcccuucccuccgcgcacaggcugccggcucaccgcuugcuaauggcagccpucucccupacagcaagaccuccgcucaggccccucuuucga\n", + "cggaccugccucucacgcaauggauccccuggcggcaacccgagaccgguucuccuacccgcauuccgccaagucucucgcucugcccaggacgcacagaugagagcgcuccgaagacug\n", + "agaugagcuupcuuagccgaguaaggagugagcggcuuuucagccucagugcugcggcagaggcgg\n", + "accgugcgacgccccaacccgccgcuccgccgcggugguacgcuccaggccgccaggccgcgaggcccaccgagcggacgccaguggaugacccgcggcpaggaggag\n", + "cgacgccccaacccgccgcuccgccgcggugguacgcuccaggccgccaggccgcgaggcccaccgagcggacgccaguggaugacccgcggcpaggaggag\n", + "aucuugcuaucacugcuauuaccacgccagaaccgccugagaauugagauugaagaagcucuggac\n", + "gcgacgccccaacccgccgcuccgccgcggugguacgcuccaggccgccaggccgcgaggcccaccgagcggacgccaguggaugacccgcggcpaggaggag\n", + "uucuuucugucacaggucugacagaaaccguuaaugaaguuuccaagcugagcaacaagauup\n", + "cuuucucaccgugcgacgccccaacccgccgcuccgccgcggugguacgcuccaggccgccaggccgcgaggcccaccgagcggacgccagugg\n", + "auaccaucagcaaaaugccagacgucaaggagagugugcccccgaaauauccuggcgacucagapcag\n", + "gugcgacgccccaacccgccgcuccgccgcggugguacgcuccaggccgccaggccgcgaggcccaccgagcggacgccaguggaugacccgcggcpaggaggag\n", + "cgguccugugcgcacgcaucgcacacgccggcgccuuccuuupagcccpccgguggcgcpcgcucggcaa\n", + "auucucccaccaaaccgaccaccaccugguagcaucuupuuuccupcguggccuguaaauuuguaucaucacaapccagugaccaguaaccagugaccaguggccuucauacuggacac\n", + "aucagacugcugccuuggaccpacagcucgcggcccccgagagcucuagccgucgaggagcugccupacg\n", + "auuuccccgaaaucagacugcugccuuggaccpacagcucgcggcccccgagagcucuagccgucgaggagcugccupacg\n", + "cagacugcugccuuggaccpacagcucgcggcccccgagagcucuagccgucgaggagcugccupacg\n", + "agcuucaucccaccpcaauuuuccugcacagcagcuguuacagucccauucucaccuggccccupccaguucggaagccucugagcag\n", + "cacuugcaccuccugcgccgccgccccccauccaaggauaugccuucaagccuccaccuagacccgacuuupaccuccpagaacaaucaaauuacaggccaauuucuucgaa\n", + "cuguuuggcgaggcggccgcgccpcggaucgugcggccggcggcucccucgcggcucgcggcgucpcccguggcgcgcgcgcggccgccccucggccccggagccccucggcggcgccacc\n", + "acgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagapugapugaauggugcugaggugcgaggagapaaggacaguaaagagcag\n", + "gagagcgguugcgcagugaaggcuagacccgguuuacuggaauugcucuggcgaucgapauccua\n", + "agcagugagagcgguugcgcagugaaggcuagacccgguuuacuggaauugcucuggcgaucgapauccuaguacaccgcaauc\n", + "agguucucagugagguucaaggagaacaguguggcugucaaggucguccapcccugcagguggugacaacagcaagcuacgcuacaaaaaaaapagucauugcuuggag\n", + "gagcaccggcagcaccagugugugapagcaggcagcgguccuagccaguuccuugauccugccagaccacccagcccccggcacagagcugcuccacag\n", + "ggcuuagcacgcccgacagcacuaacgcuccpccggcccagcaaaucuuuuguccpcggcgcugagccagcapcgcugcccgguguaaacpacccgcggaapcpcgcacc\n", + "cggcccagcaaaucuuuuguccpcggcgcugagccagcapcgcugcccgguguaaacpacccgcggaapcpcgcacc\n", + "uuuucugcuagugcugcugcugcupaggacgacggacggcagcggccaagcaagaagaaagacguggcagcaagcpagucpauagugucaucgguucgguaaaguuucuguucucug\n", + "ggacgacggacggcagcggccaagcaagaagaaagacguggcagcaagcpagucpauagugucaucgguucg\n", + "paggacgacggacggcagcggccaagcaagaagaaagacguggcagcaagcpagucpauagugucaucgguucg\n", + "ggacggcagcggccaagcaagaagaaagacguggcagcaagcpagucpauagugucaucgguucgguaaaguuucuguucucug\n", + "gacgcuggcagucuugguuuucugcuagugcugcugcugcupaggacgacggacggcagcggccaagcaagaagaaagacguggcagcaagcpagucpauagugucaucgguucg\n", + "ucucagguuccuaacccccagagapauccgauucagucucagccgcccccuccaggccucaugugaccauuggagcccuucccaaggcuuccuuc\n", + "gaaguucacgccccugagucupcuccgcaccucccupaccgcgucpucgcgcaggagccpcugccucgagccpcuggaggcuccccpag\n", + "uggapugupaaggcgcupaggcuguggcugupacggcgaucpuucggagagaccggccggap\n", + "ggcagauccucugacucucuggcugcagaacaguuucuuccgugcucuggccugagugccacagccapccucugcucuguacacag\n", + "gugaaacggcgcugaggacugacgaugupccpuccucuucccccgagccugapcugcagcupauapcccaugccuucugaugucuacaggcgcugacggccaccccuccag\n", + "acucggcuccccuugguuuccupuccugccccuucaagcupcpagcggaggaccccgcucucapuugccggacc\n", + "agauccagaaaauaugugaagcgaaacgcccaccgccccuugapcuguucuagaccuuugcuccuggugucguauagagcpauauuucaagcuggag\n", + "auccguuuucuugucccagugaacaggugcacuauguugaaauaagaguggugacggaggccuuguuuaucuuguaucuuauuguaaaag\n", + "auucuucucacaggucucaggcuccupaggcaccuuauaaacacapcguucaucuaccccacuaacuggagagaaggaaaacgcugg\n", + "augaguaacccgaagccccuagaggaguggucaccugccugapcacuucugucccaccagcaucagaccag\n", + "gappaaagccccggauguucguupauucaacauggcggcpaguguccgcggugguggcggugcaagagagcugapaggcgcgapcgcggaguuccag\n", + "ggauucaacauggcggcpaguguccgcggugguggcggugcaagagagcugapaggcgcgapcgcggaguuccaggucgagcaguuaggccgcgagcgacugcggcgccgagccg\n", + "ccuuccugcugcccaccccgcgucccuccagacupucccgugcucccgucccccagcccugaccacccupcagcugcugcaupacag\n", + "augaguaacccgaagccccuagaggaguggucaccugccugapcacuucugucccaccagcaucagaccaggugugugcag\n", + "gcpaguguccgcggugguggcggugcaagagagcugapaggcgcgapcgcggaguuccaggucgagcaguuaggccgcgagcgacugcggcgccgagccg\n", + "ggcggugcaagagagcugapaggcgcgapcgcggaguuccaggucgagcaguuaggccgcgagcgacugcggcgccgagccg\n", + "pauucaacauggcggcpaguguccgcggugguggcggugcaagagagcugapaggcgcgapcgcggaguuccaggucgagcaguuaggccgcgagcgacugcggcgccgagccg\n", + "uucaacauggcggcpaguguccgcggugguggcggugcaagagagcugapaggcgcgapcgcggaguuccaggucgagcaguuaggccgcgagcgacugcggcgccgagccg\n", + "auuauagupaccagucucauuagguugaaucuacagccuauguugguguuaacccaggucucuuagag\n", + "cguuaaaaggaucugaacaaagucugcucaaaucuccugcugugaaccagcagaauuuuugaacag\n", + "agaccacgucuccaccuccupcuccaacgauucucccaucuuggccucccaaagcgcuggauuuacag\n", + "acgugcguggcgacgugucggccaucuuguguuguugaggcugaggacugacupuucugagacucccugucccggaccgcag\n", + "augcugcuugaaucupcuucguuuauauuucaagacugcugccuguaggagcuccaucuguaucauuuguguuaauagugacccuggaguuuuguacuuccagaaccuau\n", + "gugacgugcguggcgacgugucggccaucuuguguuguugaggcugaggacugacupuucugagacucccugucccggaccgcag\n", + "agauacuguagcuaagugcaacaagguguccugaauuggagacuggcacagaacaaggauguuguuggaaaaacugaugaaaucugaauaaacucugaaguauag\n", + "agacugucucgcucugucacccaggcuagagugcaguggugcuaucguaacucacuggagcccugaucuaggcucaaaccauccucccaccucagccucccaaguagcupacuaag\n", + "gugcguggcgacgugucggccaucuuguguuguugaggcugaggacugacupuucugagacucccugucccggaccgcag\n", + "gcuggagcacaguggcgugaucucggcucacugcaaacucugccuucgagcaauucuucugccucagccucccgaguagaupauuacag\n", + "auuuuaugcugagcuuguccguaggcagapuuuguagacuauguucccaacaagcauucagugaaga\n", + "ggucacgugacgugcguggcgacgugucggccaucuuguguuguugaggcugaggacugacupuucugagacucccugucccggaccgcag\n", + "acagagcccpccacaggcagcuccuugccagcucuccuccucgcacagccgcucgaaccgccugcugagcccc\n", + "guguupaauucugugcccuaaagaauuccgacucagauccgaacpaucugguggaaucgapugaaagaccagapaca\n", + "uccucagguucugaaucuugugccuggagaaccagagaggacccuggagcaggaggagaaagagaagcuugucucagaagcuccaccuccuccupca\n", + "gcuguuaaccuccuupccuccccagccccuaguuupapagaagapcggcpaccuuuccuggcgccgcucg\n", + "gaucaucapaaggaagaccucucugaggaguugauguuuuaccuggagaccuaaaugaugaggauuuaaaagcuuuucggacaacagcaauuacaaaugcaaagaccuugag\n", + "cuuucgacugccccggaacccaccggagcaggcagcupuppcggcccupauapcuguggcaguacgcpacccggcugcgguggcugcpacugacga\n", + "acccggcugcgguggcugcpacugacgagugagucucpcupcggaaacggagcuccgg\n", + "ugcccggcuggucucaaauuccugaccucaagugaucucccucccaaaguguugcgauugcaggugugagccacugcaccuggcugcugagaaaucuuugccuacagugagg\n", + "accggagcaggcagcupuppcggcccupauapcuguggcaguacgcpacccggcugcgguggcugcpacugacga\n", + "ccuguuuucuuucgucgucgupupaauugucgccuaagugguuccpuugguggaugaccuugagcccucaggaacgag\n", + "ccaguggaauccugaapcuucgacccacuccucaaccuugugcuggacggcaccauugaguac\n", + "cuacuucacggauccgcuucaaagaggcagcugcaguggagaaucauguuaagcucggcuacugcggagagcccaagguagcccaaua\n", + "gugaaaccagcccagagaaguuacpauuugcccccpcuccugcccagcaagccagcgccgugacccaggugupaugauggugacgcuucucacucacgugugaag\n", + "gacggaaccacugcacuccagguuccuugcupugcugagcguggccugapacaggcccupucccp\n", + "gcuggaacccguggugaccucagaauucuccagacaccaccacagccccguccccgaccagccgaggcagccacagcaacagcuccggcacaag\n", + "aagucagaggccucaccapuguggacaucuugugcucugcuggaucuacuguguacgcaccauucacugga\n", + "gccacacacacagcgagcpcpcagaaggcgguucugcuggucuccucuuccugcugcagccagcccagcgugcpccaupcccugccggcpugaggcagccgcguggcaggc\n", + "acaaggagccccaaacugucucacaguccucaaccacccagucupugacccggucgagcauuuaucagagacguccgcugauucuuuggaagcc\n", + "ggaggaagcaggagccucuugaaaaacuuaccaccaaacuucauggaaucacccuggccuucuucaacaaaaaccucuuuaacagcacuaaaacacagcuaaaag\n", + "augugaaucccaaguaccagugugaucuggugucuaaaaacpaaugauguauaucgcuaucccaguccacuucaugcuguggcugugcagagccca\n", + "acagugcucugcaggaggaagcaggagccucuugaaaaacuuaccaccaaacuucauggaaucacccuggccuucuucaacaaaaaccucuuuaacagcacuaaaacacagcuaaaag\n", + "uuuccagauuguuugaacuucucuggccgcacaauacaggaaggaagacuaaagcagcaaapaccuacagcgucugcagc\n", + "cacacacacacacacacacacacgcacacauacaaugcacaaguucagcaggauuguauaaugagcaugaauuguaaauuuu\n", + "auuuaucccuaaucuggapcaaccuggagcuagguaagaacagaacagcccuuugacuucaacgcauggacaaaggacaacaaaggca\n", + "cacucauucugucuccugcuacccugugaaaaggugccuucugccauuauuguaagcuuccugaggccuccucagccauguggaacu\n", + "aauauuuaaaaaaaccauccaupacagucuaacauaacaaapaauuauucaucaagaagaggcccuuuagcag\n", + "gguauuuaaagugcccagguacuuacaauaacaaguuggacugaacacauuguaucucaggaauuaagaauuuuuccuaaaagaag\n", + "ugccuccacuucucauucagagaauucagugcauacaaaaucagcuucuguuguaucaucagauuccauuucaacuucugccgacaacuuuucuccugauuugagg\n", + "cccaugcaguccaguucpagcuaagucacuuaaacacugugugauaguuccuacacaucucauuauaguuu\n", + "uuaauguguuaagagccauugacauuugaagaucaucagaagugaagauaaaacaucucaaaaauuauaau\n", + "uucuuaguuauuggccgcaggugagccagauugcggaagauggaggaauuaaupauuggagacagaaauuuacuguuugauggugagagaggupaggag\n", + "aauucgcggauucugguuucugaaggcuacgccggaauuccuuccccpacuupaaccacuucugccucccucccupcguggaggcugaggaaaaggag\n", + "apagucucgcucuauccccuaggcuggagugcauuggcgccaucucggcucauuugcaaccucugucucccpuucaagcgauucuccugccucagcuucccgaggagcupauuacag\n", + "uucuuaguuauuggccgcaggugagccagauugcggaagauggaggaauuaaupauuggagacagaaauuuacuguuugaug\n", + "ggaccugcuggauuguugccccaauucgcggauucugguuucugaaggcuacgccggaauuccuuccccpacuupaaccacuucugccucccucccupcguggaggcugaggaaaaggag\n", + "ccaaagauguaacuuauauauguccauucacuggcgcuguacgaggaacucugacugucacgaauuauagguuauauuucaaaagc\n", + "uuccuuuguguuuauuuacaguuaauguguuaagagccauugacauuugaagaucaucagaagugaagauaaaacaucucaaaaauuauaau\n", + "ggaauuccuuccccpacuupaaccacuucugccucccucccupcguggaggcugaggaaaaggag\n", + "uguugccccaauucgcggauucugguuucugaaggcuacgccggaauuccuuccccpacuupaaccacuucugccucccucccupcguggaggcugaggaaaaggag\n", + "ggucaacuguauuaugaacaaguaauuccaggaggccaucaccugaaccuguaaaguuuggauuaugcccapaaggagauaaccuggauacagaugaccagaaagca\n", + "ccacccaagccaaaccaaagcugaggcaggagccgaaacucagaguccuucaaggccuauagccag\n", + "agugaaagcuggaacccggccggaguagcucugagcgccggcugugaggaaggagguucupcaagcuauagcc\n", + "ggaagugaaagcuggaacccggccggaguagcucugagcgccggcugugaggaaggagguucupcaagcuauagcc\n", + "gcuggagugaagcggaacaaacaaacauggcucacugcagauuugacuuccuggcucaagcaauccucuugcuucaaccuccaguguagcapaccacag\n", + "aguuuccggcgugagcggcgaaagccpapcgagcgagagagcaagcaggcagcaggcugccggcpcpcggacggcacagapapagcgagcgagca\n", + "acagcuucagacacaggaggaapapaapaggacagaggagacaggcaggugcuguccucaaagcccugcguucuucugag\n", + "gauuucucaggucccuccggcccccucccuggaguccacagcgccuccgguguccagaggaucggacacggcccggcccggcc\n", + "ggagcugguuguuuggcgccugcgucuugcggcgagcpcuggcgugcggcgccguugcpcpagcggcugcaacgccggugccugaggagcg\n", + "gagccauuccguagugccaucccgagcaacgcacugcugcagcuucccugagccuuuccagcaaguuuguucaagauuggcugucaagaaucauggacuguuauuauaugccuuguuuucuguca\n", + "pcuucgaaacauaaguugcauuacagaaaggaaguagaaauuacaaccacacuucaggaauuguuacucuacuuuauuuuuuuaauaaaccuauguauau\n", + "cuucgcuacaauccguuuccaucugcgcuucuccgcacccaucccgucacaupuuccugauacccuuuucacaggcgauggucuggucgcupccuaguug\n", + "ccaaguguuuacgauacgauuggugucauuguauguuucuccaaaaggagucucaccuucguagcguaacagugaugugagaccacuug\n", + "accggaagugaaggcagauuucccuccuucgucgcuguugcugccgccauacgcgcucucccuguuuag\n", + "agaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "cgcgccccgucgcacgagcgcucccugcgaguggcgcagguaacagaccgcapcaagacagccggcgcpaggagg\n", + "cucccccuucccggagccccgapccggagcuccuggcggugccggauccugacggcggccuucccccpucu\n", + "pcuuggccucugcccggccacagagccggagcuggaggugcugucccgucuggcggcgauccccpcapcccpccpuuugaag\n", + "cuccauucagcagcccuggcaucacuaaapagauauaguggaacuuaauaaacgucuccagcaaacagagapaacpaccuucuggaaaagaaauuggccaaggcacag\n", + "acacagguaggagcuccuaggaccaggcugaggcccapacagugaggccgaggcupuggccuccaggccaapcuupccccauccugagucuccaggacccaagg\n", + "agaggcuuuuugcggcaggacguaagugacggcgaaggcggugcgacagcagcuggapcagaggag\n", + "acaucauuucccuuccucggcccagccccacagcgcgcagcuucggcapuggcuuuacggccggaggagagg\n", + "puuuguguuucccpccgaaccpuuguppcgcpccupccaggcggcagcuaaggcccgcg\n", + "gcgccgguguccggaaagguguucauucagcgagacuacagcaguggcacacgcugccaguuccagaccaaguucccugcggagcuggagaaccgg\n", + "puuuguguuucccpccgaaccpuuguppcgcpccupccaggcggcagcuaaggcccgcggugacagcaugg\n", + "agaggaggcpuuuguguuucccpccgaaccpuuguppcgcpccupccaggcggcagcuaaggcccgcg\n", + "ccagccccacagcgcgcagcuucggcapuggcuuuacggccggaggagapupucccagaccugagguaggaggccgagcugapcpaagaggcuuuuugcggcaggac\n", + "aggcpuuuguguuucccpccgaaccpuuguppcgcpccupccaggcggcagcuaaggcccgcg\n", + "guuauugcauuucucucuccacugucucugaucuuccuggccaaauuucucaagaaggcagacacaagagacagcagacaagccugccugg\n", + "agcauuggaauuupcuucucccuucuaguggaguucggaggaugaaaauuggcugacucuuuggcaguucuguuaagaaug\n", + "acccuucccccuucuccaaccgccaacggccgccugcgccugaggcccggcccacgccccaucccgcucgcuccacgcugcggcagccccggcggccccag\n", + "ggaugcuaaugacuagccaaugcucuaggaagacauugagaccagccaacuucuugccuugauaacuacugaagagacauupuggcuggauuuugaaagcagacuucugg\n", + "ucaaapaugcuaaugacuagccaaugcucuaggaagacauugagaccagccaacuucuugccuugauaacuacugaagagacauupuggcuggauuuugaaagcagacuucugg\n", + "acagguuaaauacugcagagcuaauagauuggagugacuucugaccuagucacaucuuaaaggaaaacuuuucaguuuuuacuuuaaaa\n", + "aguuguccugagagugaugacuggcuccaccuugauguggcucacauaaauucagaaaguaugauagcaguguaggugguuagcagcaccucauaagguccuuccuagcaag\n", + "guuaaauacugcagagcuaauagauuggagugacuucugaccuagucacaucuuaaaggaaaacuuuucaguuuuuacuuuaaaa\n", + "uuccaguuguccugagagugaugacuggcuccaccuugauguggcucacauaaauucagaaaguaugauagcaguguaggugguuagcagcaccucauaagguccuuccuagcaag\n", + "ccagcuuucgaggcagacauaucugagcucauccuuugccagaacgagguugacuacgcucucaagaaccugcaggccugg\n", + "cpaagcapuccuuaaauacguccccucuuggcucuugccguuccaggagccccaguuaccpagaggcugugucaaag\n", + "ggauggaggcaapcuapagauacucuuucaaaaggaucauuuguaguuccuacuaauuuugugguaagucgaagagaagauuccauauuaaauugcugugaupccauccuugug\n", + "ggaccggcgcuccpaccpuccggcaggaggcguppccccpccgccgccuuccgcccc\n", + "aguaccaggugagcaaggaggacgcgagcggacpcgagaggcgcugcgapcgcccpccggcggcugaapccucga\n", + "gaagucggcuguggaagugupcggccauuuugagaccpcaagapcpacuggugcggccgagugacaguugaccgguuuuaaccaagugacug\n", + "gccggcpacpagcugcggcgcuggcuacgagagugacccagucagcguugguucccgucuuggcc\n", + "cpcccggcpaacaccgguccgcuguaacaccggcccggcgcagaagcpacgucggcuucuapcccaggccggcggcggcg\n", + "gccgcgccuguagcacucccggaacuggaacuaggugccagacgguccggaggcpccacgucagcpccacccapcucgcpucccggupugcc\n", + "acauaaaaaccpugccggcaggcgccagucgcaggugugcugcugaggcgugagaauggcgucccgcggccggcguccggagcauggcggacccccagagcug\n", + "agcgaggcggagccggcgcccggaggagcaagaggaggaggaggaggagaggucggagccgucuccaggagcccuuagagaccgagucccggcggcgacggcpcagcgcaccggcaggcgg\n", + "agacagucacagcagccuugacaaaacguuccuggaacucaagcucuucuccacagaggaggacagagcagacagcagagacc\n", + "agapaggaaggacagcagaccagacagucacagcagccuugacaaaacguuccuggaacucaagcucuucuccacagaggaggacagagcagacagcagagacc\n", + "auccuucacugaucauapaaagcaaauaucuccuuuccucaupacacagaacuaggcagaacaggaucaggaagcgaucaaaccuaccaaggcagucucacuucuca\n", + "ggcagcaccaugaacuaagcaggacaccuggapaagaacugupaccuggaggccuccaacgacuccuuccugcuuccuggacaggacu\n", + "gcacaaccccagcgcgagugccagagcccagccggcgcggagcpagcggugcaggcugaggucuccgagcggcucgcc\n", + "agcgcgagugccagagcccagccggcgcggagcpagcggugcaggcugaggucuccgagcggcucgcc\n", + "gauucagauggacugugaaaaacaacaagauggaugaucauauggagauugcuucuaacauaaaucugcauaaaaauuuuucugaaac\n", + "auucagauggacugugaaaaacaacaagauggaugaucauauggagauugcuucuaacauaaaucugcauaaaaauuuuucugaaac\n", + "gaguuuggagcaaguaacugucagugagguugcaguuggucupcuguuuggcugugagcgaaauagcugccccccacuucucacuugcacaccacpauacuccuccugaggcuccggaug\n", + "cauuuuugaaccggcacuuggaagacuuuccaauuccugucccugugauauuauuuuuacuuggaugcaguuuugaaguauuaagcuuuacaucuucacag\n", + "agaaggaggccaggaguugugaguuuccaagccccagcucacucugaccacuucucugccugcccagcauc\n", + "aucuggcccuaaagaaccugcggcagccagaggcggaggaagagagaaggcugcauaggagcugcagcgcggugcggccagcacacaccccggcccgcgaggccccpcucgccc\n", + "cgccgccgccgccgcuccgacgacagcagcagcagccacagcagcagccgccggcggcgccgcgcugaacaaag\n", + "gccuguugacupcugcuuuuaacccuuuccuauuugcugagaaugcagccgugugacaguaacugaacauuggucuaaagucuuuccaaaaggucaagguucacaag\n", + "cucccuucauggcagccaaaagcagaggagcuugcaggaagguaccaucccuacacaguaugugaaugcacacuuagacaccacacagcacug\n", + "gcacuucaaguaagugcagcaguuuuuaucuggccaaucuacugugacccagucaagccaccacccaugucupcupaaggupaaagaggcugcugcacaugcuupaugucuucagccau\n", + "gacgcaucccgugugagcagacacacauagcucgcuuucuupcucuuugucagccaccaacacagagagcacacacugacacacacguacacaaagaucugagccagguugupag\n", + "acacagaccccggcagcpaacgcagaugacacgcccguaacauggaagccgccgccgccgccgcuccgacgacagcagcagcagccacagcagcagccgccggcggcgccgcgcugaacaaag\n", + "gguauguucugucuugugcuuuuucuuuuagaagcuacuaaapuguupaugcuucugacuauuaugaaggccaaaag\n", + "agcuuccucccuucauggcagccaaaagcagaggagcuugcaggaagguaccaucccuacacaguaugugaaugcacacuuagacaccacacagcacug\n", + "aguaggauagcagcuuccucccuucauggcagccaaaagcagaggagcuugcaggaagguaccaucccuacacaguaugugaaugcacacuuagacaccacacagcacug\n", + "caucgcccgaggcguccgcccugcaaaucugccagcccccgagapuuuggaaccuuagcacccaagucuaagucaacuucau\n", + "gugugugcugagaucgugaguggaggcgugugugagaggucgcgcaggugcupaggugcgagg\n", + "gucaggccggcuuuucgccccggcgccuucucugcuccagccggccpucucccupcccggagcucggccpccgcgcagccccguuagaggacgagcucggcggacccccgcuccucc\n", + "gugcgupaggugugugugcugagaucgugaguggaggcgugugugagaggucgcgcaggugcupag\n", + "cggccgagcuggcccgcccgcccgucgcacauguuccggaacggcgcccggccguagccgccugcggcgccuccugucggcccgagaapagugcggagaggcgccggucgccacccgcggugccc\n", + "pcgagguccgcugcggucccggcggcuccguggcugcuccgcucugagcgccuggcgcgccccgcgcccucccugccpccgcupccpaugcacgcpcccpagcc\n", + "agaagguucugcgccucacugagugccuuaggccccugcaguaugupccuucucccpupuuggcagauuagcaaagauacagg\n", + "auuuucccagagcccuuccccaggcuggcggaggcuggcuuuggcccuggaguccucagaaaaccccccagcaucucugccuguguagupacuccgagug\n", + "guccccapccccucaccauggccagaggagaguucccgagaucaggagcuggcggcugugcug\n", + "cagcccagaggaccccaggcgaccagaguccaggcugaggcccgagguggcucaccagcuguucagaugcuuccaguaucaggaggac\n", + "aggcuggcuuuggcccuggaguccucagaaaaccccccagcaucucugccuguguagupacuccgagug\n", + "gugupaggagaggagagagacccaagagcpcuggcguuapaggcauccccgcagugaagg\n", + "ccauuuucccagagcccuuccccaggcuggcggaggcuggcuuuggcccuggaguccucagaaaaccccccagcaucucugccuguguagupacuccgagug\n", + "agacpauuucaccgcguuagccaggauggucucgauauccugaccucgugauccacccgccucggccucccaaagugcucggauuacag\n", + "uccauuuucccagagcccuuccccaggcuggcggaggcuggcuuuggcccuggaguccucagaaaaccccccagcaucucugccuguguagupacuccgagug\n", + "gcguucauuuucagccuggugupugagugguacccaacpccpcgccgcguccgcaggaagaggcgcpugcag\n", + "gcuagcpagcgcgagccagcaagaggcgccugcgcgauguccpccccugagcccgcggcgcugagccagccpacggacaugcgcpapcgccgcpcagccgccgcuccuccp\n", + "ggaaugaaagcuacugguugauuuuaaagugccupccucacagguuuggagaugucccagaauaaggcaca\n", + "auggagaaauuagcauacaaagaaacugacuugucagaagucagagcaagguauugguggauccapauaaaucccaaacuucuuaaccccuagaccgguuuuuaguccauugacu\n", + "caucuagugcuuuuugcauggcccaaapcucugugcugcuccacuacagaggaaacuucaagaa\n", + "agguauugguggauccapauaaaucccaaacuucuuaaccccuagaccgguuuuuaguccauugacu\n", + "ugauagacuggagugauguuagaaaacacaaauauggucaccuaucagagucugcaucccaauaucaag\n", + "gucauuuuaccupacaaauaccuaaaagaaacauguucagucccagcgccuguccauugcuucaagcag\n", + "aguguupucccgccguccugaggcucgagcucuugcpucgaucggucggcpccugcgcpcccpccc\n", + "uuuggcugcgucggccgcguagcccgcgcgcggagcguacccugcugcggccguuggccguuagcgcggcuucggcgguugucuuggagaagcaag\n", + "acaguaaaagcaaaagcaacagcucaagcagccuccuuggagaaaaccugaaaauucaacuuguucaagagaag\n", + "ucaggapaugaaccaccgcuuacucguucuucgcguccgcaacucuugucccaguccucucuaaagagcgcccgacgugacacucpccaaaauagcaucuaapccagagcp\n", + "gugaguccugcaaauguuaagugauuugcucaaggugcccauuucgcaggaauuggagcccaggccaguucucugagccuaucauuapcuaaag\n", + "gaaccucpagcggcagcuccggcgccugguagcgagaggcpuuccggagaucccggccucacuucgucccacugugguuap\n", + "guuaccucuccagugaagauuagccccauagagcuuacucuaupaagaacuuuucugacuccuuccugucuagg\n", + "aguguuaccuccuuuagccagagaacupugcaucugagccaguggagauuugugacuucuccuucuucuaggagugcgugaucaga\n", + "auucapcagugucuucugcaucuccuaggaaccucpagcggcagcuccggcgccugguagcgagaggcpuuccggagaucccggccucacuucgucccacugugguuap\n", + "aggcauucapcagugucuucugcaucuccuaggaaccucpagcggcagcuccggcgccugguagcgagaggcpuuccggagaucccggccucacuucgucccacugugguuap\n", + "cuccuuapccguggucccguagcuaccggucgcgucgccgupcgacgugcccgcuuccaaa\n", + "gccuggcuagcuucggcccugcuccgcugucugugapcagaugcagcpcapccugucacccccauuucauggaguuggcagagccucagagapcucp\n", + "gucacucuuuugcaucccaagccuggcuuaggcaagucccugagguuaguaaacaccuucagugccccucagccaagucccuuuugacc\n", + "cuagcucagcuccaccpccaacccuupacacugccugaaguagagacaauaapcaugcucc\n", + "ggccaapcguggcgupcgacgupaaacguagucccgcaacuccgcaaugucccuagcaaccgapaaggauuguuuucugapaucagucguucgguaaacaaaugu\n", + "uuugugcpccgcagccgcacguuggcaccgauggaacupucaguagagugacagccaccaguccgcaugaacup\n", + "ccucuucucagcugauuuggcugccuccauuguaauaggccucaugagacuccagccuaggccuggccuucaguucagcaggcagagcccagagauguacupcaaag\n", + "agcuuaggcggcgguggcugagaaggcagcpcggcggcggcggcggcggcggcggcuguggaggccgcaguccpuccuggcuucggccucagccccacc\n", + "gagaaggcagcpcggcggcggcggcggcggcggcggcuguggaggccgcaguccpuccuggcuucggccucagccccacc\n", + "auucgcgacccggaggugcgcpcgcpcgagcapucuccpupcggcggcgacgccccgcgcaggcuggaggccgccgaggcucgccaugccpagaacucuaacuccccc\n", + "aupucucacuguguuguccaggcuggucgugaacugcupcucaagcgauccuccuaccuupcucccagaguguuggaauuacag\n", + "aagauggcgccgagcgccpugagcagcgucucggcugccgcuagaguuuuccugcuccccgcgcucpuggcpcpucugagugguaccccggaggagacccuuugaag\n", + "uagagaupauuucaccauguuggccaggauggucuccaucucuugaccuggugauccguccgccucggccucccaaagugcupauuacag\n", + "guucugugucaucguccuccuccuucaacaucccagcccaagccucgugcacggccaaaaaaaggaaaagcaauauucccaaccgcacagguccc\n", + "cucggcugccgcuagaguuuuccugcuccccgcgcucpuggcpcpucugagugguaccccggaggagacccuuugaaggucccuugupacuggaaagaggacg\n", + "gcuggagugcaaugacacagaucuuugcucacugcaaccuccgccucccpuucgagugauucuucugccucagccucccgaguagcugugauuacag\n", + "gcpucugagugguaccccggaggagacccuuugaaggucccuugupacuggaaagaggacg\n", + "agaguuuuccugcuccccgcgcucpuggcpcpucugagugguaccccggaggagacccuuugaaggucccuugupacuggaaagaggacg\n", + "aagucuugcuuuguugcccaggcuggagugcaaugacacagaucuuugcucacugcaaccuccgccucccpuucgagugauucuucugccucagccucccgaguagcugugauuacag\n", + "gcuggaguccaguggcacgaucuuggcucacugcaaccuccacuucccagguucaagugauucucuugccucagccucccgaguagcupacuacag\n", + "cauuccuucugcaaaggacugccuggcaggugugaaaggcagcgguggccacagaggcgguggag\n", + "aagucauuccuucugcaaaggacugccuggcaggugugaaaggcagcgguggccacagaggcgguggag\n", + "ggaagccggaagcgugguapaapcgaccgcgaaacupacuuucucggagcgccpcccuaccagcguucacaguccgccgcucccacccuucucacgucugacggacucugcugacag\n", + "aapcgaccgcgaaacupacuuucucggagcgccpcccuaccagcguucacaguccgccgcucccacccuucucacgucugacggacucugcugacag\n", + "apaapcgaccgcgaaacupacuuucucggagcgccpcccuaccagcguucacaguccgccgcucccacccuucucacgucugacggacucugcugacag\n", + "agacucggccuggagaagcucgaucugaagaggcagaaggagcaggcucugcpagguggagcaccugaagagaugccagcag\n", + "gaapcgaccgcgaaacupacuuucucggagcgccpcccuaccagcguucacaguccgccgcucccacccuucucacgucugacggacucugcugacag\n", + "upagcaagugcauauccupcugugaagugagcgaggaagaguuucgugaagguuuugacucugauaucaacaaucg\n", + "gcugguuuaccaugacuucuucagagacccucucaacuggucaaaaacugaggaggccuuuccuppccgcupagccuugagagcc\n", + "acuauguuaggucuuaauggupaggacgcccgagugcucggcccguuucaccccgaggaggaaggacacupucaugacgccaucagapcgccagagcapaccggacgcgaguuggag\n", + "ggcccucgcppcuugupuccuccucccccucccacugacaacugccccaacugcucuucccgccccggucacagugaaaauguagacpucguugucc\n", + "ucgcppcuugupuccuccucccccucccacugacaacugccccaacugcucuucccgccccggucacagugaaaauguagacpucguuguccguacgacu\n", + "auuuucuugcucuugagcucuggcacuucucugcugcugucugcugcugaggccugcagagauuaauauaaacggcag\n", + "gaggugaggagaagccagagguccuuggugugcccucagaaaucugccugcaguucucaccaagccgcugugaaa\n", + "agacagccupapagaaggaguuggagcucaaguuggagacagcgaggagaaaccugccauagccapugugucuuugauccucuucag\n", + "uuggucaguucuacuucuugauccggaagcgaauucaucuccgagcugaggaugccuuguuuuucuuugucaacaaugucauuccacccaccagugccaca\n", + "gcaaauucguggaucgcuccgcugaauccgcccgcgcgucgccgccgucgucgccgccccccgucccggccccccupuucccucagcccagcccuguccagcccgguucccpagg\n", + "gaucaggcugcuggcuguggupuuggcagcgagccugaaacugcuguccuupacccaggaugaaaggagup\n", + "gugauaguagaaaaggcucccaaagcucggauaggagaccuggacaaaaagaaauaccuggugccuucugaucucacag\n", + "aaauucguggaucgcuccgcugaauccgcccgcgcgucgccgccgucgucgccgccccccgucccggccccccupuucccucagcccagcccuguccagcccgguucccpagg\n", + "gaacagcaaapuagagcagaccugcgccapcgcacaacggccguguccaccucccggccccaagauggugcuucccacaggcagccacgcguagcagccagagacagcuccagac\n", + "aggucaugcccgugugagccaggaaapcuguguuuaupaagccaguaacacuguggccuacuaucucuuccguggugccaucuacauuuuupacucpaauuau\n", + "cuagcgaaaaaugauuuggcucggacugucccgugacaggcggugcgaggaggccaggcccgcgcccgccgagcccuapccgcugcugccgacagcc\n", + "cpaaucccugcagcugagccugucucucacpaccpaagcuggagagagccccaacccugcccgcupccgagcucccugcuccugcagcaguccc\n", + "cugagccugucucucacpaccpaagcuggagagagccccaacccugcccgcupccgagcucccugcuccugcagcaguccc\n", + "acugagcucucaugaaagauccucagucucuuguggauuuagaauccugcagcagcccaccaucuaagagcaag\n", + "uuaacuacauucaupacaaccaaagcaagaaagccucauguuuupaaaguuugauaucagca\n", + "gccaccauguaagaauuccguuacaucuuuucacucaucucagaccuucucagcgugacucggugaaaauguccccguucugagg\n", + "gauugacuucuaaagacuugguacgugaggaaaaaacacggaagaggaagaggaaagcaaaggagucap\n", + "aaaccugagcccgcggcgcaagcggagccggcccgacggcaggcgccpccapagccgcgcagcccuugcagccgccgcpcucggacc\n", + "auugcuuccugaggaggcuggcacuucugaagauccugaagacccuaaaggagauucacaggcag\n", + "aucucapaguugaggaccuuuucuucagapugacucaggucaacacapcccccauguagucgacagacacagugguccuaagaucuaccaagcauccag\n", + "guucugaggagacaggccccggagcagcacuagcuccugcccacacuccuaccugcugcccugaccagagucauc\n", + "acugacuugcgcguuggaggucagagaacagcgagauucucgcccugagcaacggccugacgucgguggapaagcaggcgcaggcuccgugaggaggcaag\n", + "agagaacagcgagauucucgcccugagcaacggccugacgucgguggapaagcaggcgcaggcuccgugaggaggcaag\n", + "gucuucugcccggccccuucgcccacgugaagaacgccapagcugugaggcagugcugugugguuccugccguccggacucuuuuuccucuacugagauucaucug\n", + "uuuuuauuucacuuaggugguuccpagaagccuuuccaggacccauguguaggcacaacuguuuucccugaucaggauacuugcggcacucaa\n", + "cagaggaaagaaauuccuaapaacacugcucagaaaguacugcagcaugucuucaaaugccugaggaucaaguuggaaaacuagaagcaacagaaaacacaauaag\n", + "gugguuccpagaagccuuuccaggacccauguguaggcacaacuguuuucccugaucaggauacuugcggcacucaa\n", + "auguauguccucacaaugcaggaggugaaauguguaugucauguguccaaauuguaagauacuugcu\n", + "auacuuucccagcaacaucuagacugcuguuugaccaaacaacpcuccaacagccuagccaagugaaacauaaaacuaaccaucacaguauccuugucaaaaaucagucugacaacacau\n", + "gcggcccgcgagcgcgccucacggcuccugucuccccucccuccuucucucucacgccuagcgca\n", + "aaguaugaaacaaugacgauuucaugauggcucauuguucuuugguauugugccuuacgugagcupacuaacucu\n", + "aaaucaguuuuuauuucacuuaggugguuccpagaagccuuuccaggacccauguguaggcacaacuguuuucccugaucaggauacuugcggcacucaa\n", + "ccccaggcgugagucacuggagagcgcgacpaggaapcgcccugaguccacagcccupaggucggapucugaaagcgagaaguccgugaguagaag\n", + "gcggccgcggcggagcagcaacaguucuaccugcuccupaaaccugcucagccccgacaaugugguccggaaacaggcagag\n", + "agaucucgcagagcucagaguccugcaugccucaguccucgccucgcuccuccucgcggaggauucupaggugacgucgcpucucggucgcpcccguuugcagagcccgcggcgccpag\n", + "ggauucupaggugacgucgcpucucggucgcpcccguuugcagagcccgcggcgccpag\n", + "auucupaggugacgucgcpucucggucgcpcccguuugcagagcccgcggcgccpag\n", + "cucgguacuggacacaacgapaccupucuacgauaacgcgcuuuugcuccuccugaagugucuuugguccaacguuguuccag\n", + "auugacagugccaaagcucgguacuggacacaacgapaccupucuacgauaacgcgcuuuugcuccuccugaagugucuuugguccaacguuguuccag\n", + "gguacuggacacaacgapaccupucuacgauaacgcgcuuuugcuccuccugaagugucuuugguccaacguuguuccagguuugucaccguuucucuccggccggucapcaagagccag\n", + "gucgccgcccgcugccucgaacpacupcacpaggaagaggcupugguaaacaggaagupcgcucagagcucpcggcgcucag\n", + "aguuauuaagccuacgcucagaucaagguagcagcuagacuggugugacaaccuguuuuuaaucagugacucaaagcugugaucacccugaugucaccga\n", + "aguuauuaagccuacgcucagaucaagguagcagcuagacuggugugacaaccuguuuuuaaucagugacucaaagcugugaucacccugaugucaccgaauggccacagcuuguaaaag\n", + "acacaggagcccaugaaaggcaucacguguggaaggaagugacacgagucauagucugcccugcuuuucuaccaccugaagcaucauauaaaccuauaucuucuguuucaa\n", + "agacugccauacuguuuuccacagugacugcaccauuuuacauucccaccagcagugaauaapuuccaauuucucugcaucuuuucuaacacuug\n", + "agaguuacaguggagguaaaaggaguggcuugcaggauggagaagcugcaccaguguuauuggaa\n", + "agaguuacaguggagguaaaaggaguggcuugcaggauggagaagcugcaccaguguuauuggaagugagccaccauuugaauuugcuagcucaugcugcaguauucagauua\n", + "cacagugacugcaccauuuuacauucccaccagcagugaauaapuuccaauuucucugcaucuuuucuaacacuug\n", + "apagguauggugucaagaaaacauagucaccauuauuacgaaaaguaaaauauggaagagaugaucccuaccaucaaucagcuuacaacuagaggcacugacaaauguauacagauagcuguaau\n", + "gaagcgagcagcugcaaagcaucuaauagaacgcuacuaccaccaguuaacugapcuguggaaaugaagccugcacgaaugaguuuugugcuuccuguccaacuuuucuucgu\n", + "ggaguucupaaaucguucauucauuuacagaugaacagaaaagacucuucuugcaguuuacaacpcacagacagagcaccugupaggacuaggaaaauuaaag\n", + "cucuucugucupagauacaaguuuggaagcaaucuupuacuuacccacaaggcugguggagaccag\n", + "ggcucccggcgugcagcuugguggcggcugagccggcagcpccgccucaggcagccccggccpccgcccpuccccggcagcpuagg\n", + "cccggcgugcagcuugguggcggcugagccggcagcpccgccucaggcagccccggccpccgcccpuccccggcagcpuagg\n", + "cggcgugcagcuugguggcggcugagccggcagcpccgccucaggcagccccggccpccgcccpuccccggcagcpuagg\n", + "gcggcucccggcgugcagcuugguggcggcugagccggcagcpccgccucaggcagccccggccpccgcccpuccccggcagcpuagg\n", + "agaaauaauguauggapacuauacaapcauauauacuaguaaaaguguuuucucaauagaucaccaaagaauuugccacaccugauauauagaaaaguuuau\n", + "ugugcagcaccucuaccuucgcucuccugcuccugcucuggccacauaaaacgugcuggcuccuccuuugccuucugcuaucauuggaagcuuccugaugccucccaagaagcaaaugccauc\n", + "agugugagcugagcucuuucccugaaugaauccaaguaacccuggccuucugaaaugaccagcagacacacaacuguccagaggcugcccaaaguauaaacucugguucuaaaguacc\n", + "cuugucacccgcggucgcuucpcpaucggugccaccgagcgcaaagccugccucgccccccuuccccgucccccccaucucccaccgcccaguccccggcggcg\n", + "guupcaggcuguguguggcucgaaacpcucuugagacgcugagcgcguggugccacccuuccuguccgcagcggc\n", + "ccuuuucuccagugaggagugaacagupcaccugagauccuggcccacgcuacuaugcuuucaggcuacaaccacuagcacggcugacg\n", + "agacgucgcacccggaaguaaagcggcuccgugacggagcggcggugcgcgcggcapcccggaguaucccgcuuucuuuggaggaaaccaccgcaucagaucugcgcugcggcagaggcag\n", + "agaagaagaggaagugaaggcuacapuauccacgupuucugagcguguuucuacgucccuggaagccggucauuuaagcucauuccucgccacggcuuagucaac\n", + "gucpaaaccucucagccucaucuguaaaaugugaucauaaauaccpuaccuggaagugcucg\n", + "agacagaucucacuauguugaccpcuggucucaaacuccuggccucaagcaguccuccugcagcaacuucacagcaacacuggaaugacaggu\n", + "ggagccaagccugcpcgguggcggcugcacucgcapcccuggcagccgacccuggccccaagguccgaucgcccapaggagcagcaccpaccccgcgucggcupcgccccacaag\n", + "ggaagccagucuuaauaugauggaaacaucucugaacuucuaaaagaccaagguuggcguuuuagcucuauuaauuuuacuucgucuugg\n", + "guugcuauuuugugaauuacugauaggcauguuauuuguuagcuuauuuguuuacaguaugcucaacauugaag\n", + "aagguagcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "uuuccagcggaaguggcuccuguaaggcagcaagguagcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "gauucccuucaggaugugaapcgagcccucaaauuuacuuuuuauucaauggauuaaaauggccaguaauucuuauccuuuuaaacccgacuuccaauuaauuaauuacaa\n", + "gccgcucgcucggcuccgcucccuggcucggcucccugccuccgcgucgcagcccccgccguagccgccuccgagcccgccgccacauccucugag\n", + "gacucacgcagguccucccgcgcgcccgcaacacgcccgcaggcuccugugucugcugccpcagcpcccggaagg\n", + "cugcaccccuacugugccauccagaapcucugugcugccugcaauccagccagucgacucaagucccuaggucaaccccuccacg\n", + "accccgcaacucagccuggaccaguuucccuccuccacccacccccgaaucuugagaauccuguacuppapcacugcccccgcaccauguucuupagagcag\n", + "aggagacuaagagacaaugagcugagugaggagcccaggaacccpuuccgaacagcugcguagaaugcgagcggccaaaugguggagaaucuggccgg\n", + "aggucccgaauugacguccuucccucaaaaccuccpucuacaaaccaggacccucaagacccuucag\n", + "aaugcugcugccgccgccgccgccgccugccpuauuccugcugauccugcucggaccuuagcuucccugaccucucccugcccpagc\n", + "aauaaagaacgaggacacugcpugugcggcggcccaagcgguuucaaacggcuuagagcaggccgcuugguucugacccagcugag\n", + "uucugcgccugcgcgcggcuacagcacgguucguuuuuccuuuagucaggaaggacguugguguugag\n", + "auucugcgccugcgcgcggcuacagcacgguucguuuuuccuuuagucaggaaggacguugguguugag\n", + "gcaggapaaggaupcuuccugcaaccucccuugccccacggcuucccauccuacccccggccgcguuagcugaaggccagcapacgcaaaaguuuuuaggccccuuaggucuuuag\n", + "cccgcccgccgcgcacgcagccggccccggcucccggcgccccgcgccccgcgccccgcgccccgccaccgccgccgccgagcaaagccpcupcuuggagcugcuc\n", + "agacugagcccagguugauuucaggcggacaccaauagacuccacagcagcuccaggagcccagacaccggcggccagaagcaaggcuaggagcugcugcagcc\n", + "gcggacaccaauagacuccacagcagcuccaggagcccagacaccggcggccagaagcaaggcuaggagcugcugcagcc\n", + "uccccgccccgccccgcgccgcgccggccgcugucagcucccucagcguccggccgaggcgcggugu\n", + "agcucccucagcguccggccgaggcgcgguguaugcugagccgcugccgcagcpcugcuccacguccupccuuagcuuccugcugcagacccgccggccgauucuccucugcucuccacgucuc\n", + "acaaucugcuucauccugauucugcggcauuccaaacugugguauccuupuucucuuaacauugcuauggugcagaagauuuaaaaucag\n", + "guacugcaacagccacuugcagguacuuggcuuuaucccgaaaaaagagaggaagaaaaagaaugauccuauagaugaggugaaggucaggcaccag\n", + "aucuucacucucacccaggcuggaguccagaggugugaucucggcucacugcaaccucugucuuccpuucaagugauucuccugccucagccucccaaguggcupauuacag\n", + "gcagugccagcgccagcgccagacccgcgccccgcgcucuccggcccgucgccugccuupacucgcgagcccgcacucccgcccugccuguucgcugcccgagu\n", + "ggccgcpcuggaagugcgcaugagcagcugucuauggagauaccuaggccpagapagaacacaguuggagaaaaucggcagcugagacggccuuggccg\n", + "gacuuagcacucaggccugugaaucaggagauacaaagaccuccaaaaaaggaccaguuccucggaugugcccccucacagagag\n", + "gccccucaccaacauggccgcpcuggaagugcgcaugagcagcugucuauggagauaccuaggccpagapagaacacaguuggagaaaaucggcagcugagacggccuuggccg\n", + "gugaaucaggagauacaaagaccuccaaaaaaggaccaguuccucggaugugcccccucacagagag\n", + "gacuuagcacucaggccugugaaucaggagauacaaagaccuccaaaaaaggaccaguuccucggaugugcccccucacagagagaugaapugagugaagaagag\n", + "gugcaguggcuacupaagacccaaccaguguggcuauugccagcauccagucagcugccaccuucccugaccccaacgucaaguacgucuuccgaacugagaaupccag\n", + "acuuagcacucaggccugugaaucaggagauacaaagaccuccaaaaaaggaccaguuccucggaugugcccccucacagagag\n", + "ccugcgguggaagcacaccuccucccugaagguggccaacgagcccgucuuagccuucacgcapcagcccugagcgagaugcccugcaaaag\n", + "ccpcgcppcacccggagupcpacucacccuuuagcugcucpuccuugaccgcuucgcacag\n", + "gupcaccaaucuuacugacaucguggcacagagaaagaucaccauccpagcuuppugc\n", + "ppcacccggagupcpacucacccuuuagcugcucpuccuugaccgcuucgcacaggugagcucccpaupaaaggcgaccupagccgcccccgacacggcccacg\n", + "gupcaccaaucuuacugacaucguggcacagagaaagaucaccauccpagcuuppugcaupccccaucugguccaguuacuauggaaacugccguucucuccug\n", + "pcgcppcacccggagupcpacucacccuuuagcugcucpuccuugaccgcuucgcacag\n", + "agaaugacgcccuugaaagacguguucccuuuucaccaaugcacagacccagaggaccccuccauccugcaguuccugcc\n", + "aggccupcggagcgcacagcgcupcgcupaggcugcgccgcagcacccgguuggucaggaccaagupcccgaggcggacgugagaapucpccaag\n", + "gcccggaucgcccagcuccgcguuagccggagcugcacgcpcugccpcggacgcugcucugccugcauccggaggcggccgccagcggauuugccacccag\n", + "guccuaagacucucaguccagagapcccugccccacacccagaaggaaggaaugcugcccagagaugaccagaggaaucuagacag\n", + "gcaaaggcagcucgagcaucucaucugacgugaguucaaguacagaucacacgcccacuaaagcccagaagaauguggcuaccagcgaag\n", + "guuguguccacuaaccggacucagaapacuucccugcucggcuggcuuucgguuucucugcucaccuccggauaaaucacpucucccgcgccgcuc\n", + "auucgccucupagguuuaggaagcggcuccpucgguggccccaggacapaagagcpcgcu\n", + "aaagcgcaaggucccagcgccccuuggauccucgguggcapuccpcaagugucauugcgapuucaggaagccccggccugugaucgugagcg\n", + "acacugccuaaucgucccgcccaguagugagcaggccugucccauuccauacugaccagauucccagucaccaaggcccccucucacuccgcuccacuccucpcuggcucuccugagg\n", + "auuccauacugaccagauucccagucaccaaggcccccucucacuccgcuccacuccucpcuggcucuccugagg\n", + "aguugucuucaggcuuuggagccacaggccgugucuucuuacuugagcccuggugcucccuuaaaag\n", + "pcagaacugcuucpacccgucccupcucaguuucpugcaccuggugaagauggucauucugacagagccugag\n", + "ggugcuccaaauaucacagccaaccucaccucgucccugcugagcgucugupuggagccagaccaucaacccugaggacgacacggauccuggccaugcugaccugguccucuauaucacuag\n", + "cacugccuaaucgucccgcccaguagugagcaggccugucccauuccauacugaccagauucccagucaccaaggcccccucucacuccgcuccacuccucpcuggcucuccugagg\n", + "ggagcugcuggccccpcggcugcuccagucugagcgcccuccgcucgccccgagagagacccggcc\n", + "cgagagagacccggccaugcaggagccgcugcupagccgapcccggacuacgacaccuuccccgagaagccgcccccgucgccapacapcgcpucgg\n", + "cccucucccacaaggcagcgcgccggcucggacgcggccggcuaccgagcccuuugugapcugugagcugcgccugacgguggcacc\n", + "gcuaauaugcucccucucccacaaggcagcgcgccggcucggacgcggccggcuaccgagcccuuugugapcugugagcugcgccugacgguggcacc\n", + "augcuaauaugcucccucucccacaaggcagcgcgccggcucggacgcggccggcuaccgagcccuuugugapcugugagcugcgccugacgguggcacc\n", + "paggagccgaggaaccgaaagagaaaacaggccgcgcpcggcagaggagccpcgccgca\n", + "cuggccaugaccaaagccccugcuggcacccuggcccagcucugaguccupacccucgguccucucuccupcc\n", + "cpccgacuguguaguccgcuccggcagcgcgcucugcccggcuuccucagucuccucgccpagcguccpagcagcuccgaggccgcggcgaaaccag\n", + "cggcagcgcgcucugcccggcuuccucagucuccucgccpagcguccpagcagcuccgaggccgcggcgaaaccagguggaguccgagguucggaggaguaucagag\n", + "uuuuuugcgaguggcpccgacuguguaguccgcuccggcagcgcgcucugcccggcuuccucagucuccucgccpagcguccpagcagcuccgaggccgcggcgaaaccag\n", + "gcgaguggcpccgacuguguaguccgcuccggcagcgcgcucugcccggcuuccucagucuccucgccpagcguccpagcagcuccgaggccgcggcgaaaccagguggaguccgag\n", + "cgcucugcccggcuuccucagucuccucgccpagcguccpagcagcuccgaggccgcggcgaaaccagguggaguccgag\n", + "acucgcgcccagcgcagucgcuccgagcggccgcgagcagagccgcccagcccugccagcugcgccpacg\n", + "auaaggagucaggccapcpaugacacucauugauucuaaagcaucuuuaaucugccaggcggapcuuugcuggucuuucuuggacuauuccagagag\n", + "ccupagaagaggcagcugaggccguggcccggaguaguaggagccacaagccacccupcaggacgaggcccugapag\n", + "aaggaccccacuguuuuccapagucccuuccaaaggucucacccagcucagcugagguaacucauuuugccauuucuucauuuuuaggacaacugucaucupaaguaacaacgcagg\n", + "pcccagucaccacugacaaaaaugacaguaaccacaguugaagugugcccagcupcucauccccaagcacccucacauuauga\n", + "gucugaugauggaggagccuuggcccuggcugucccapaggaggugaaauuccucagcucuccaccaagauuggccacaaaagccugauccccuggaacacagcag\n", + "cccapaggaggugaaauuccucagcucuccaccaagauuggccacaaaagccugauccccuggaacacagcag\n", + "gcuggucuggacugcccucugagcucucapucucuaugcaggcagaguccucccagccccucucucccauucuupcgapucggcuggagagaggccccupacaucugg\n", + "gcuuagcauuccaggcccupcaucuccaagugccccaggupcacucuccupucugugacagcuugcccccaaccacggagaggugacaggcacg\n", + "agauagaguuucaccauguuguccapuggucucaaaacuccugagcucaagcgaucugccugccucugcuucccaaagugcugagauuacag\n", + "guucggugcgcggccpccggaguucgcugcaagucggcggaaaguuuggcugcgcpuucccccgaaguucag\n", + "cpuucggugcgcggccpccggaguucgcugcaagucggcggaaaguuuggcugcgcpuucccccgaaguucag\n", + "auuccaggcccupcaucuccaagugccccaggupcacucuccupucugugacagcuugcccccaaccacggagaggugacaggcacg\n", + "gcgcaccugagcuppcgcggccaaauucucccucccgguccucgaagcuucuggccccgcucuagapcagaaagauagcagauuuccccggag\n", + "cccccpuucggugcgcggccpccggaguucgcugcaagucggcggaaaguuuggcugcgcpuucccccgaaguucag\n", + "aaagccuuccccapccuuguggugcccuccacccuguccugagcugccgcugcpuggcagaugcuguuucaucggucgag\n", + "acacagccgcagugcccuguguguggacagccugupagacucgcacgcccacacucaccccgccuggcugcaccccugcccagc\n", + "acuuccgguguuaccugugucguuaccpagcuguaaacaaggugugcaagcaucugaagagcugccp\n", + "agcugccagccpccgguccguccuccapaccccgcgcaguccaggugagcpccgcgucugcuucggugacaccapugaggccaggccugcag\n", + "guccuccapaccccgcgcaguccaggugagcpccgcgucugcuucggugacaccapugaggccaggccugcag\n", + "uccaaguggcacagagcugucuuccuuggagcaaacccggagcuaccuccucagcgaupaccugcaagugcggucuggaguguccacuuaauguccccaag\n", + "guuuucaacuuugacccuuuggccccggugaccccpupcupupccagcaucagaggaggac\n", + "guuuaauuuuuagaagucaaugucaccuguagcagagaaguuccuugaaaucaaaucagacauauggcaauugugaaaagauugaa\n", + "ggcaacagccugcuaugaguagccagccapcagaggccpcugcagguggaggcpaagcgauuccggccaccuuug\n", + "ugaucapccaaagcggucagugagaaggaaguggacucuggaaacgacauuuauggcaacccuaucaagaggauccaguaugagaucaagcagauaaag\n", + "augaguagccagccapcagaggccpcugcagguggaggcpaagcgauuccggccaccuuug\n", + "ugaupcgucucacuaccuacaaagucagcccagugauuucaagacagcccuggagacagugcuuccugcccuccugucagcuucugccucccugua\n", + "cauuuggauggaagupagcapcgagacpccauuuucacucuguggucaaaggaaaugacuggucugacucggucupagcpcacccag\n", + "ggucuaaggauaacucupccaugacagccaugagucucacagaggaccccgagacuucugugcugcgaguaaccggacuuguucugagaccuuugcccuagagg\n", + "agucgcgcgcggugcagucpagguggaggcaccggcugcauuguuuucpaucgapugapcgcu\n", + "aguaccuuguaaugaggcuggccauaagaaucagaagcaacuggaaauggcugcuuaacacacaaaagaacaaaaccaagagccuucuacuagucacucuca\n", + "aaaugcuccuagccggcagaggagcuapaguguggcacugagccggcucaggcagagacgcggcacc\n", + "gcgauagagugcgagagcgagugcccggagcauccuggcccugagacagcupccagccccgcapcucugcagc\n", + "cuugagaaagagagcgauagagugcgagagcgagugcccggagcauccuggcccugagacagcupccagccccgcapcucugcagc\n", + "aggccuugagaaagagagcgauagagugcgagagcgagugcccggagcauccuggcccugagacagcupccagccccgcapcucugcagc\n", + "puaccgcugcuggcuagcgaccgacgagcaaccgucugaggccaggagcgcugcgacggagccuugaccgccguugcccggcccucucccgcgcagccccpcuuccgcag\n", + "uccuuccuucagaapaaauuucugapucaggaapaaucuguaccucacuccuugaacaccaaggaag\n", + "auucucuuggagcaagcapaagcagaggagcagcapucapugcupuuccuaaggugcaagg\n", + "auuggcuuaauugccuapcpacuaacuagcaaacpacuagaaauapaugcugaaaagcaacpagagacgcagucguaacgcacuuccggcggucuacgcgaggaag\n", + "gaguugcugapugappcaucggcggcagcagcgguggcugcuguggagagagagagagaguggcugguuppaapccagaguugapuccauagccuaguaacupug\n", + "ccaccagagaaacggcggagaacaauugaggauuucaacaaauucugcaguuuuguuuuggcauaugcugguuacauucccccuagcaaagag\n", + "gugcucgaguagaapccggapcpagcgguucggcguggucauccuggacccupcuggcpcggcgugugcggucucggapcccgaggcgguggagcgcggccgg\n", + "cuggucuccccgccgcuccccpapagcggcuuggugcgccugcgccagccuguggcuuucupaaucaaaguuccggagguuc\n", + "apcccgguaguucgccgaggupuaguuuguggcggugguaccggagcuccgaguaguugccgccggaga\n", + "aguggccggagaguugcucaggapaggacguagaagaggcugagugapcccgguaguucgccgaggupuaguuuguggcggugguaccggagcuccgaguaguugccgccggaga\n", + "agaggcagcgguuggaggcgcggupugucugcpucucgcpcggcugcgguguuucaccpaaaggcucgaggagagcgcggcucacgagag\n", + "auaacccagcugugcucccuggaaccuucaauuucaaggccucccugccucuacuaggcgccuuagcucacu\n", + "agucggaagugcgcaggcagugcucgcggcggcggcgacggcggcpagguucgguugucgcccguuggccgcgcggcgccgcgcucggcggccgccauugcag\n", + "ggaccgacpcgcacccagguappcggcugagccgcgcagugcggacccucgcpaacugcgccgccgccacc\n", + "cggcugcuggaccgacpcgcacccagguappcggcugagccgcgcagugcggacccucgcpaacugcgccgccgccacc\n", + "acaaagaaacugaggccgaagucacuugccagcaagcapcagcugcgauuugaacccuggccaccuggagucagagccupcucuaac\n", + "gaggcaccgcccccugcccugcgcggcugcuggaccgacpcgcacccagguappcggcugagccgcgcagugcggacccucgcpaacugcgccgccgccacc\n", + "ccuacucagugugaagacaaugaggaugaaagccuuuaugaugaccuacuuccacauaaugaaua\n", + "guauauggcuuccucauugcacuacugucaucauucagguugcuggaaaaaucagcuauugaggacccaccaucuaugua\n", + "aagugaaauaugaaacagagaagcaccauuucugccucaagacgcauguaaagagguguagauucag\n", + "cuuuaagugaaauaugaaacagagaagcaccauuucugccucaagacgcauguaaagagguguagauucag\n", + "guuggagugcaguggcaugaucacagcucucugcagucucgcccuccupcucaagcaaucuuuccccaccccccgguuuccugaguagcupacuauaggcaugcgccaccacacccgg\n", + "uaaauaccupcacaggacuucaaagcaaacacagauucccccucccccuuaauauuuaagaauuaaaag\n", + "uuugapuuauuuuauuuauuuuucguuuuuuaacggaggauuuugccuuuauuuuuaauuauuupaucugauauuuuucuacuaguagauaggacucuugguuuggacauacuacauggaucag\n", + "agagaaaaggaacaguuccguaagcucuuuauugguggcuuaagcuuugaaaccacagaagaaaguuugaggaacuacuacgaacaaupaaagcuuacagacugugug\n", + "pcaguuuaugaggcguuuapaapuucuccccaccauccuccaccgagcggupcggcapcuucagcuggugcaacauggugcapucggaggccuggaag\n", + "agaaagcggagagucacagcpccaggcccupagcggagccuccaccgccccccucauucccag\n", + "caaacuucagaagacaaagapauaucagauggcuucapagugacuggugaaugguuugaagaaauucaaagaaaaaaguuuugcaaugaaacagauguuagccaa\n", + "caggcaaaaauauacaauucaccucuggaaaaucaucuaguugacaguacauuugucccaaagccagcaguc\n", + "cuggacauuccuggacauugcupagccagacacugaguugaucauagugugcugucaacagugaaagaaaaucugapauccucacagaaacpcgcacuuuggaaugaaggagcacuuuug\n", + "ccaccgcgcgccgcccgcgcuggcugugcgcupcgcuggugcuggcpuggcuucuuucuccucggcuuccucuucg\n", + "ggcugauaagcgaggcauuagugagauugagagagacuuuaccccgccguggugguuggapcgcgcaguagagcagcagcacaggcgcpucccpaggccggcucugcucgcgccgag\n", + "gaggacugcagucuggaguuggagcccuugucccaaccapcuggauaagaagguguugguguggugcucucgguguugcgaaggcuguuuaaguuauaugaugag\n", + "ggaggucagcagugccacagaacaaacuggaguuaagaaaugucguucuucagauuuaaaaagaaaaccuuuacugaaucagcugaguguuaauaauacgaauuuccuuuucuug\n", + "pccugagagauucgaaaggagccccgcccccucggagcugauucccpacuagguugcpagaaagccuguugcguggaagauaaggcggcgcpaaguggacacagg\n", + "cugcgagccuupcagaauggauaccugaggaaagguaugguuucucuccagcucagaucuaacuggacucucgcuccugcuggcuggac\n", + "gauucccpacuagguugcpagaaagccuguugcguggaagauaaggcggcgcpaaguggacacapupcuggag\n", + "cugauucccpacuagguugcpagaaagccuguugcguggaagauaaggcggcgcpaaguggacacapupcuggag\n", + "pagaaagccuguugcguggaagauaaggcggcgcpaaguggacacapupcuggaggugugcuucgcgugugaugccapaguggaaag\n", + "agacgccuccgguaguguaaaugaggacaaugccugcuggcccacaugacppauguagacggcagcggcgccagucgcuccuggcacc\n", + "cgaacggccggacgcgguggcucacgccuuuaaucccaucaguuupagucugaggcaggcggauuacgag\n", + "ggaapcpcccgccpagccaggccgcucggcgccacgaccggccgagappccggaucccggacc\n", + "gagaggcuuuagccuagacagcugagugugaggaacagugauucccauugauccuuguucccuccgupucacagaguccagaacuuaagagccacccaag\n", + "uccapcppcggcugagacagcgcccapccucggagcaaggcguuggcaggcaagua\n", + "guggcacauuugauuauuuugcaaacucuggaagaccuuggcugapucuagguggacugucugag\n", + "gcuccccucuucaacuuuagcacuuucuaaugcugacaucugugauucugugacauuccccacuuagaggaaguucgucugcgguuucacugg\n", + "gacucaccpcggcuccuggccgcgcaccuccapcppcggcugagacagcgcccapccucggagcaaggcguuggcag\n", + "gupcuccggcugcagcuccggucugcucucuuggcuccggaacccccgcpcgcuggcuccgucugccagg\n", + "accgcccacacgcaaggcugccugccucuacacauucucccaagaguugucugagccgccgaguggacaguggcugauu\n", + "guucuuccgaaugauccagucuuucuugagccucaugaagaaaugacacucugcaaauacuaugagaaaagguuauuggaauucuguucgguguuuaagccagca\n", + "ggacgcccuaggcuuccgcgagaucuucggupuacpuguuuuacgccaggacgcugaugcguuupuucucgucugcagacccucuggaccuggucacgauuccaua\n", + "gagccauugauuggucgacgcccccagapuuacaauucaaacgcpcpcpcccgcaguccugcaguugcagucguguucuccgaguuccugucucucugccaacgccgcccgg\n", + "ggcagcgcpuuuuugcccggaaagaggcgcucucguucpucucccaguuucuguuuuuggaguugacagcagaguuuuaaauauuggauauugaagucuucauuuucguguguuucgu\n", + "ggcucucggcgguuagaacccacagaagacccgagcauuuuggcgcuuaugccgcgcauggcgcuagcgcucucugcug\n", + "gauggccpcuggugugguugcaaaugaugccggugaccgaguuacuccagcuguuguugcuuacucagaaaaugaagag\n", + "auuguuggauuggcagcaaaacaaaguagaauaagaaauauuucaaauacaguaaugaaaguaaagcagauccupcagaag\n", + "gauacuuaugcacuaagccaaaaacuauaguuguuuggagagaauucaauauucagugacaauaaauacaucccc\n", + "ccuccpaagauggcggccgugcaggcggccgaggugaaaguggauggcagcgagccgaaacugagcaagaa\n", + "gugagaaguuaauucacucguccaagucacauaauugacaaguguguuggaauuuagucccaggcagccugacuacaaagaug\n", + "guaggauccaugccaaaagagcuucupaaagcucaucuucuaugaucuucgaggagapugaaguugcaaguc\n", + "acuuuupucpcccuccpaagauggcggccgugcaggcggccgaggugaaaguggauggcagcgagccgaaacugagcaagaa\n", + "uccpaagauggcggccgugcaggcggccgaggugaaaguggauggcagcgagccgaaacugagcaagaa\n", + "auaacucucuuccccucucagagccucpccccgcagacgccgaggupcgcucgugccaggaucgcpcgcpuacpcuccuupcgccccgapcugcuggccp\n", + "uauucuuccaaauggaaacugcuaauuuuugaagcagaagguugacagcuucaguaagaucucaagagagcgagaagacuggaaucag\n", + "ggaaacuuagaguucagagapugugauuugccugaggucacacagcaaguuagagacccagcuccacgacucauugucuug\n", + "aucccuguuucucuagagccuuggaggagcgupcacuugguagaccuggucgcuuugauucccucaauaccccucagag\n", + "gccauggcugcgcagcpcuggccpucuccugaacccpccccgccgccccgaccgcccggccccgccgccpcuguccccgccgcguccguagcgcguccugccag\n", + "uaugcuccuuuccccugagguucuacagauugaacagcuguguuccuacccaaucacaaupagaagcuaaccaguauagccuggcaaacaagag\n", + "acuuuaagucuuuuccuuuuggucuuggaggaacagugcucagcuuuugaucucugugauucugauagagaag\n", + "gaaccucggacaagucuaaucuggagcugaucacucuaacaugcaccuguguggcugcgacucucuucuggcuccuauuaacccucuuuauccgaaaaaugaaaagg\n", + "gcaaaucacuuggaagapcuuuuggaaaagugguucaagcaucagcauuuggcauuaagaaaucaccuacgugccggacuguggcugugaaaaugcugaaag\n", + "apccacggccagcgaguacaaagcucugaugacugagcuaaaaaucuugacccacauuggccaccaucugaacgugguuaaccugcupagccugcaccaagcaaggag\n", + "ggccucugauggugauuguugaauacugcaaauauggaaaucucuccaacuaccucaagagcaaacgugacuuauuuuuucucaacaag\n", + "auucugacgguuucuacaaggagcccaucacuauggaagaucugauuucuuacaguuuucaaguggccagaggcauggaguuccugucuuccagaaag\n", + "ugcauucaucpaccuggcagcgagaaacauucuuuuaucugagaacaacguggugaagauuugugauuuuggccuugcccpauauuuauaagaaccccgauuaugugagaaaaggagau\n", + "acucgacuuccucugaaauggauggcuccugaaucuaucuuugacaaaaucuacagcaccaagagcgacguguggucuuacggaguauugcugupaaaucuucuccuuag\n", + "gupucuccauacccaggaguacaaauggaugaggacuuuugcagucgccugapaaggcaugaggaugagagcuccugaguacucuacuccugaaau\n", + "cuaucagaucaugcuggacugcuggcacagagacccaaaagaaaggccaagauuugcagaacuuguggaaaaacuaggugauuugcuucaagcaaauguacaacag\n", + "auacguaaaugcuuucaaguucaugagccuggaaagaaucaaaaccuuugaagaacuuuuaccgaaugccaccuccauguuugau\n", + "ugcaugcccagcccaggcaugcaguggaaacgcapcaggagagaggaggccuucagagugcagcuggacuuccuucccaacccucuugcuuccuucagaccpucpuuggcaaaccaag\n", + "ucuggagccugguuccgcgcgccggagcgcgcuagccgcauugcgagccgaacccpagcuggcgcc\n", + "cgguuccuccugucaacugccuccgcccgcgcgccucccgccuagccacacagcgcggaggacgccgugagccgccgccgcagucgucucggcccgcggapacgug\n", + "aagacggaacugccacaapcacgcpccucaccagcugccucacucucggaugucuucccaggucacccuugacgcccucag\n", + "aggcauauuugagguuuuggccuucupcaaguuuugguapugucugucauuuucccucuacugcuggaaaagaaggcucaagaggaagaauccag\n", + "auauuugagguuuuggccuucupcaaguuuugguapugucugucauuuucccucuacugcuggaaaagaaggcucaagaggaagaauccag\n", + "guacuaagacccgugugcagcagcggcggcggcgguagaggcggcggcggcggcggcagcpcucggaggcagcgguupcucgcggcgagcggacpucgagucagugcguucgcgcgag\n", + "ggccugcugcaggcauauguuagcgcuucccaaccucaapccccaggagcuuuccugaaaaacccuccugugaaguguggcggucagccaggu\n", + "gcagauugupcggcugugucagcugacccaapccuucgaggugccuuaggccgcuugccuugcucucagaaucgcugccgcc\n", + "gugucagcugacccaapccuucgaggugccuuaggccgcuugccuugcucucagaaucgcugccgcc\n", + "ggcggcugugucagcugacccaapccuucgaggugccuuaggccgcuugccuugcucucagaaucgcugccgcc\n", + "gucuggaaaucucuccaggcacccugcuuuggcccucuagaauacagacaguuccugcucuaagaggccaucugugaggcucagucucccaacaccucug\n", + "cguggagaucgcupagcgguugcggcgugccpagcugaguuauagcugugacuucugcccugccaggccgcacacaagcuggcugacccgg\n", + "agaggcggcguggagaucgcupagcgguugcggcgugccpagcugaguuauagcugugacuucugcccugccaggccgcacacaagcuggcugacccgg\n", + "agucagaggcggcguggagaucgcupagcgguugcggcgugccpagcugaguuauagcugugacuucugcccugccaggccgcacacaagcuggcugacccgg\n", + "gacaaggaguagaugaaccucuuucagaaacuggauuuaaacaagcagcagcugcugguauauuucugaauaaugugaaguuuacucaugcuuucuccagugaucuc\n", + "acucucugcugucgcccgucccgcgcgcuccuccgacccgcuccgcuccgcuccgcucggccccgcgccgcccgucaac\n", + "caggugauucucauuuugacaaagcucuaugacuauaaccupagcaucacagagagcucgcuuuggag\n", + "gucaaccgauuauggaacaaccuaugagaagcugaaugauaaaguugguuugaaaaccauuuugagcuaucucuauguguguccuaccaacaagcguaag\n", + "guucgcagcgguccaagaauggaaccagaaugacacguacaaccucuacaucucagacacacguggugucuacuucacccuggccuuggagaauguccagagcagcagaggcccugapcaacauc\n", + "accaguaagucguguauuuagcauucauucaucaaagccuccggaugccuccuacgugcccugcacu\n", + "gapcpccucppcpcccggaagguuagaccuupcgaggccucpaggcpccuggcpuugcgaccgcccaagcapccccapag\n", + "acucggccpcagccgcpccgagcgcagccgccuccgccaccgaugcgccugguggccagacuccaagupaccggcggacacgcagccucgcg\n", + "gapcucuaacuccgugaggaccccagcauuauuucuauaauuguuugugagaaggacugaaucccagagcauugccuuguugcugaccuuucagu\n", + "aggaaaggagcgcggccuccaggaagccggcuggccgugaugcugcccacugguggucccccgcucccpuccccggccggccaagcag\n", + "gauuggcaucuccugucuuuuuccugcuucuuggcauuuuagcauaucuccaguapuguccucgaauucugaauaccaauuuacgccaaauu\n", + "agcpcgcgcggcagcggcpauuacuuugcugcuaguuucgguucgcggcagcggcpuguagucucggcggcagcggcggagacacuagcacu\n", + "caucccaacaggaauacuaugacaaaggagauuacaucauuagagapcgaggaaggaaguaccuuuuucauuuuggcaaaaggaaag\n", + "guccuccacuuuggacagauaaaggagcuucuaccaguagagucccaugcaauucuguuugaacacuggcuuuggaguggaggccacaggacccccuaagaaauaauaacuucuuagugauguuau\n", + "guaaaaguaacacagagcacagaaggccaugaucaaccacagcugauaaaaacacugcagaaaggagaauacuuuggagaaaaagcucuuaucag\n", + "ugaugaugucaggucagcuaacauuauugcugaagaaaaugauguugcaugccugguuauagaucgaga\n", + "aacauucaaccaaacugucgguacauuugaagagcugcaaaaauaccuugaaggauauguggcaaaccugaaccgugaugaugaaaaaagacaugcgaa\n", + "aggcggcupapcggcgupagaggacgcugagacgcapcggccgcgccgaggugacaagcugcgcaccuggaaaguuacccggcugucuggugag\n", + "gcacaaguggaccpuguupugcuagucggcaccagaggcaapugcgaggaccacggccggcucggacgugugaccgcgccuapuggcagcpcagugcpcggcaaggcgacc\n", + "paguuucuggapcugaacacguggaggcaaacaggaaggugaagaagaacuuauccuaucaggacggaagguccugugcucpaucuuccagacgucgc\n", + "ucapaguuucuggapcugaacacguggaggcaaacaggaaggugaagaagaacuuauccuaucaggacggaagguccugugcucpaucuuccagacgucgc\n", + "ggagcuauagaugaaccuuuuapauucuguaauuuuucugucccuuugauuuccacaggacucuaaauugcccccucugaggucaaggaacacaag\n", + "gaguuucuggapcugaacacguggaggcaaacaggaaggugaagaagaacuuauccuaucaggacggaagguccugugcucpaucuuccagacgucgc\n", + "cguggaggcaaacaggaaggugaagaagaacuuauccuaucaggacggaagguccugugcucpaucuuccagacgucgc\n", + "gcggugucagaaacccuguggugaaauucagccuguggauuccagaaauuuggaguguucuuppaaaaauccgcacacacaaagcaacauuuggaaaucccugug\n", + "ggaguuucuggapcugaacacguggaggcaaacaggaaggugaagaagaacuuauccuaucaggacggaagguccugugcucpaucuuccagacgucgc\n", + "acuccacugucagaucccucuccaacucuuccugugupaugauggcauuuuucacagaagaapacauguugauauggccuacaag\n", + "guugcuguaaugcuggucuccugucugugugcggcacugcagauguggcpcapcuupagcucupcaggcgcugaaggcag\n", + "aggcagugcggagcuggccgupcugccuacccuuucaucucugcaacuccuuccucccupccucccuucug\n", + "caaaccccugagacgguguccaagcccapcccuguagacucugcggaucccgagaccagcgccacucauccugcagcacupacagacagagcag\n", + "gagcupcuggcuuccguccugguagccaaggcuaauucucccucgaguucuupagaupcauuuggcgagaaggcuggcguuagugaagcgcgcccggcgucacg\n", + "gaaagaagcacuuguaaggaaauauagcauccauugugaaaguggaaaaguaaagauaauucauc\n", + "cucgaguucuupagaupcauuuggcgagaaggcuggcguuagugaagcgcgcccggcgucacg\n", + "ggcuuccguccugguagccaaggcuaauucucccucgaguucuupagaupcauuuggcgagaaggcuggcguuagugaagcgcgcccggcgucacg\n", + "aaaucpaaaapugagcupcuggcuuccguccugguagccaaggcuaauucucccucgaguucuupagaupcauuuggcgagaaggcuggcguuagugaagcgcgcccggcgucacg\n", + "gcugcaaauacuguaaaugcuaucaccacagaaugcacugagcguccaagucagcuuggacaggucuucccauuguccagccaucgaagcagaaacaguaacagaggaucaguggucccaaaa\n", + "ggaaaauauuuauccccaaacagaaaccuguacagacuuuuacagaagaaaaagugucucuugauccagaauuagaagaagcuuugacaagugcuucugauacagaauugugugaccucgcag\n", + "cuuuaagaaaaaguagagaucacuucugacuguacugaacagcaaaaauuaagugacuugcugcccugcacauc\n", + "auupacuugacugagauugauccapcuaguuaccauguauuuccugauggaagaauguuaa\n", + "ccapuggugcuugugupaaggacuuuaaauccagcugccagaccccuggacpagaaggagagacggcuggccacc\n", + "gucaucgcgcupucuguagucugagcgcuacccgguugcugcugcccaaggaccgcggagucggacgcag\n", + "aucgcgcupucuguagucugagcgcuacccgguugcugcugcccaaggaccgcggagucggacgcag\n", + "aapcuuucuaccuccccagcauucccccaaagcapaccacaccauucuugacccagcuccaccccugucg\n", + "gucugagcgcccggcggaaaaccgaaguuggaagugucucuuagcagcgcgcggagaagaacpagccag\n", + "agcagcagcccgacgcaagaggcaggaagcgcagcaacucgugucugagcgcccggcggaaaaccgaaguuggaagugucucuuagcagcgcgcggagaagaacpagccag\n", + "uuaucuacguugcuaagccpcgauuuccuuguuccuccugcgaaacggugcggucuggacacgucuccp\n", + "ccuugccaaguaacagcuuugcuguccaacaucgugugcugcuucgcgagaaagucacauucggacccuuuggcuagauu\n", + "agagcauucaaaaaagucuccaugccucaguguauuaaucuagaaaaggagagcagcaacauaauggcaggcugaccaccuaggaauagcaugagaacacgaag\n", + "gaaagaagcuaagcagaaaauacuccucauuaaguuauuuuucaaauuuagcacaauuuugugcuccggucuuguuauagaaaaauaaacaauuggacuuuagagccaccuacuggaauaaagag\n", + "gugguagaaguguugccauucaccgucacuuauugauguguccaaaggauuguguuaguugaucaag\n", + "ggugacguccucccaagauggcggagacagagugaagaaacuguguuccccccuupuugcuaucg\n", + "acagucuuagcapcagcagcccugcagccuccccgcuggcacggucacaggccgcucugaggacuggapaccagccgcccacagagccccgagcccguggucccg\n", + "auggagaaacugacuaaagcgccucgcgcgaggucccugapuucgaacccaagucugucaggaucpagcccaaguuguccccaucguacuggauguggcucagcucugcaggaagccgcggcgu\n", + "gcuguucucugucaguggaggcagcagcgguagaggcggcggcgaggacuggcgacggcgaggag\n", + "uccagagagugaacacauucaucaccuuuggaauuccucccucugccuccucacucuucaggaaaccauggaacugcuuucuguuacuauag\n", + "acagagucuugcucugucacccaagcuggaauauagcggcgugaucauagcucacugcagccuugaucuucupcucaagugaucucccaucucacugaguagcuggaacuacag\n", + "caggcagcaggccucaggcccagacuupuguuacaggaacaguguggccucucuggaacucugcagaccaacugccgug\n", + "gcuacuucccugcggcpuaaccgccucgcaccuaccpcucgguucccuggcuccggccgcpagc\n", + "auuuguaggaucacupuaccaucaucauaaaauguaaagauuuucgaauuauucaguuggauauuccugga\n", + "guuugcgcuugagcgccgauaauuugguggcggcguccggapugcugguuuguucucggugaacggcgcgcpucucuccugagugcgagcuacpaccuucgcc\n", + "aauuugguggcggcguccggapugcugguuuguucucggugaacggcgcgcpucucuccugagugcgagcuacpaccuucgcc\n", + "gcguuugcgcuugagcgccgauaauuugguggcggcguccggapugcugguuuguucucggugaacggcgcgcpucucuccugagugcgagcuacpaccuucgcc\n", + "auaauuugguggcggcguccggapugcugguuuguucucggugaacggcgcgcpucucuccugagugcgagcuacpaccuucgcc\n", + "cuauuccagagauguuccugaacaaguuaccuguuggugaaagcuucaaaapauacuuaagugaccaauccuauucauacugupccaggagag\n", + "guccgguggucgccugguaaccggucguggcuguacuggcggcggcapcuggcggcuuaggccgcagaggucugupccugagcccacgcuggacucuguccguucugcg\n", + "gccugguaaccggucguggcuguacuggcggcggcapcuggcggcuuaggccgcagaggucugupccugagcccacgcuggacucuguccguucugcg\n", + "gaugucaucaggcuuugugapacuguacugcccuuugaguacuacuguguggccccgcaacccagcacaaccag\n", + "cauugaauucugcaucuuuuagugaagaaaauaacugaacaugguuuucuucugaagacacaaaguccaaaggccaaucacacaccucuuacaucgaucucuug\n", + "apaaucuggaaaaauugcaaucaaaacaucauuucucuaagaaaauuuupuaaccgaaguucuggacaacag\n", + "guaagccucagccggugcugcaggcagucugacucgcagucccucaagugacuuccaaggagcaucuguagaaaagaag\n", + "gapcgcggcgcggcagcagcuccggcggccgagacpcggcggccgcgcpucuggcpaccgguuuggaagacuuugccggccugcag\n", + "gacacaugaugacauuggacccacccuccccagcucggagucuuuaacucagucacaucuacggagucccuuuggccacauaag\n", + "gugapcgcggcgcggcagcagcuccggcggccgagacpcggcggccgcgcpucuggcpaccgguuuggaagacuuugccggccugcag\n", + "gcggcgcggcagcagcuccggcggccgagacpcggcggccgcgcpucuggcpaccgguuuggaagacuuugccggccugcag\n", + "agcuccggcggccgagacpcggcggccgcgcpucuggcpaccgguuuggaagacuuugccggccugcag\n", + "gauaaaaguuggugcuggagaggcagcaugcaaagcgaaaagaapacugcuuugaguucuagacccaacgccuccg\n", + "upcpcgaacgaggccccaccucugccpagcpacgagcgcgcaggcgcagucuccccagguuguagacgcugcggcccggcccggcp\n", + "uuupaaguuggcuggcuggcgaggcagagccucuccucaaagccuggcucccacggaaaauaugcucagugcagccgcgugcaugaaugaaaacgccgccpcgcuucuagucggacaaa\n", + "ucuauuupaaguuggcuggcuggcgaggcagagccucuccucaaagccuggcucccacggaaaauaugcucagugcagccgcgugcaugaaugaaaacgccgccpcgcuucuagucggacaaa\n", + "uauuupaaguuggcuggcuggcgaggcagagccucuccucaaagccuggcucccacggaaaauaugcucagugcagccgcgugcaugaaugaaaacgccgccpcgcuucuagucggacaaa\n", + "auuupaaguuggcuggcuggcgaggcagagccucuccucaaagccuggcucccacggaaaauaugcucagugcagccgcgugcaugaaugaaaacgccgccpcgcuucuagucggacaaa\n", + "aucuauuupaaguuggcuggcuggcgaggcagagccucuccucaaagccuggcucccacggaaaauaugcucagugcagccgcgugcauga\n", + "aucccupacccuggccugacugcccpaccugcuuuuccgcggapugccgguaucggaagcggccccgagucgugcuggaugugacugagcag\n", + "aucagccgguuccucuuggaucauggagacguagccuuugcgccccupaagcugaugcuggagaauuucaagcuggapagcp\n", + "auuuccaagaggucguucugaccccaggugacaauccccaauuccuupaaaccuggacgcauccagcuccapaccuguccggcaaguggugacaugcaccguccapagaaa\n", + "cucugcuggccguccgcucugacuaccacugugccguguggaaguuugguaaacaguggcagccaacccuucugcaggca\n", + "cccgagugccaaagcupuucuacuugagauuucccucguggugccapuccggcgagcaucacgccgaggcccauuuuccagacgaccacgacgaggccpucac\n", + "gaacucuggcgccccuuaccagcuuccagucucucgagguggccaguguggugcuugguccuuguuuccagg\n", + "gauuucccucguggugccapuccggcgagcaucacgccgaggcccauuuuccagacgaccacgacgaggccpucac\n", + "cugacccgucccgagugccaaagcupuucuacuugagauuucccucguggugccapuccggcgagcaucacgccgaggcccauuuuccagacgaccacgacgaggccpucac\n", + "aapaaguggcuaucgccagagucggauucgccgccgcagcagccgccgcccccpagccgccpacccucgcgucgucgccgccgccgccgcccagaucccugcacc\n", + "auucgccgccgcagcagccgccgcccccpagccgccpacccucgcgucgucgccgccgccgccgcccagaucccugcacc\n", + "agagucggauucgccgccgcagcagccgccgcccccpagccgccpacccucgcgucgucgccgccgccgccgcccagaucccugcacc\n", + "ccagagucggauucgccgccgcagcagccgccgcccccpagccgccpacccucgcgucgucgccgccgccgccgcccagaucccugcacc\n", + "acugcugugcapcaggaaagcuccacacacacagcccagcaaacagcagcacgcugcugaaaaaaagacucagaggagagagauaaggaaggaaaguagug\n", + "gagaguupaguaaacagccccgaauggagugcccaggcguguucgccgcggaggcgccguuaucccpcccgccggcccugagcucccggcggcgcag\n", + "pagauuuuaggaaagcaggcgaccugccucugaagaguguggccucuggagccaggcugaccaccugaguucucagcccagcuguucuacuugcugguguuguggccccag\n", + "gagauacccggccagacacccucaccugcggugcccagcugcccaggcugaggcaagagaaggccagaaacc\n", + "gcagcugacuggagccaacagaccagaapccupccuggcuguugcugauugauccaaauucugg\n", + "pagapccgaggcccpcaggagugcapcucugaggcpagaggagaggagagaagagccgcppcccagcccggagccagg\n", + "gcaapcgcggucugguacucgugcgucuuuuaucgccucaguuucccuccgccgacuagcgcgcpcccgguucuccaucgcgcgcacggcagccuagcgcaaugaggcpcagcacugcg\n", + "gcuuugugccuupcaaapcagcuuacuccuggaagaggacugacucaaggaccccagaaccccaagaaacapaaucuuccacauucaugaag\n", + "gcaggucgcgcgcagcuggcgccugaggaacugcggcugcgguuccgagcpucupcuguuaccauugagugaccagaaagg\n", + "auuccuugccuuugaugugagugauaggagcpcgauucugcuucucccuccaucucccggcpauuguacggugagaga\n", + "paaguggccapuapcauggucaucgugagcapuccugcapugaggccpcugcagacgcgacuguacaggucu\n", + "uuaauapupcagaaapacupagcgagacupuucagaaucucaaguaauuuggagugugccuapauupaugauuuggcupcauuaauuugaag\n", + "agaapcapcgaccgugcupcpuccgcaccagcuccupagcagagagcagagccpcaaagagaupuuguccaggcuagg\n", + "aagacuggacuuuaugaguauaaagucuuugguguucuggaggacugcucaccaacucuacuggcagacaucuau\n", + "cuagcgcapcggugccuccaagugacugccgugcagauccapaguuggaaggucacaggaguucagccucag\n", + "uuucccccucacugugcuggapagaagacccupauuucugagcgaggcccguggauguugaagucuuccupuccccgacuccaugcucucgcgccccaguuacu\n", + "gaucagccaagcaggcugcugagaaagaugaccugaauugcapaugcagaaagugcugaagaugcuuugucagcugagaacugguuaagagaaagugg\n", + "gcugcauaaggacugcccpcugcgcgccpaaccucgcpcuggcpcgccgcacccccucccuggccgccugcgccccpaggccgcccgcgcgcgacpaccggcagc\n", + "gcacaaccccccccuucucccugagguupaacaauacaccaaugagccupcugagguucuucugcucccucccacuuugguuggcgccuagccag\n", + "paguuugaagaggaaucaaagcagccapugucugagcagcagcgccaucaacugaagcaccpaacuuuuucuuucucggcaauuugaaucauuaccagccacccacauacg\n", + "gacugcuuuuuuuacucacugguguuugaccccgugcagaagacacuucucgcugaucapcgagauuagaguugguugcaaauaccaagcugagaucccagaucgccuaguagagg\n", + "auuacgucuauuuugagaacucuuccagcaauccuuaccugguuagacggauugaggagcucaacaag\n", + "acugcaaauggaaauguggaggcaaagguugucugucuuuuccggcgcapacauuucuaguagccucaacagccuggcugauaguaaugcca\n", + "gaccaaugaaaacacaggaagccguccgcgcaaccgcguugcgucacuucugccgccccuguuucaapauaagaaacccugcgacaaaaccuccuccuuuuccaagcggcugccgaag\n", + "cacuucugccgccccuguuucaapauaagaaacccugcgacaaaaccuccuccuuuuccaagcggcugccgaagauggcggaggugcag\n", + "gacuuccggccgguugcuuapcuguagcgccggcagcgugcauuguugupcuguguacuaguapuaggaguuuuuguucapaccagcggaacgaggcuuucugucguuaauagg\n", + "ugacccccugugccaucugccugccauccugcupuguccccuguupaagcugcugagugaaauuaaag\n", + "ggccgguugcuuapcuguagcgccggcagcgugcauuguugupcuguguacuaguapuaggaguuuuuguucapaccagcggaacgaggcuuucugucguuaauagg\n", + "cuauggcugugcaguggauggaaauggaaaggacuguuuuucugcgcaugagaccccugaacacacagcuggaacucugguu\n", + "gauuuuccaagaagagaauaaguaaagaugccacaugaggagguucucacugcaaggagaaaaaaaucpcaagcaggcauaucucaggaag\n", + "agauuaaccaucccaguccuucugucagucuccgaugccaucaugcagccugguuaggagcaaaggaaapaaaaagaaaaacgacuaauucaucuuuuccugaucgucaggacccuaaaga\n", + "gagcgcaccuacguggacgaggucaacagcgagcuggucaacaucuacaccuucaaccauacugugacccgcaacagg\n", + "acagapcgugcgugugucugugaacguccugaacaagcagaapcgccguugcuguuugugguccgccagaaggaggcugugguguccuuccag\n", + "apcgugcgugugucugugaacguccugaacaagcagaapcgccguugcuguuugugguccgccagaaggaggcugugguguccuuccaggugccccuaauccugcgap\n", + "gccgcaacccgucccggagguguccugucuccugucgccgccgccgccgccaccaccgcugccacugccgcccugccpcc\n", + "acuuuucaguguucgugcgucpacggcgcguccgcccgcccuuaaapcccgcaccucggaaaacucgcagcccagcacggcgucgg\n", + "uucugguccuggugagaugcuggaagcugcggccgcagccgcaacccgucccggagguguccugucuccugucgccgccgccgccgccaccaccgcugccacugccgcccugccpcc\n", + "caggucagcpacuaugaucuccugguggucggcpaucugguggccuggcuugugccaaggagg\n", + "gacgugcagaucaagcugcacgucaggagcacauggaacgcuuupucccuuuuuagccpauuccaguga\n", + "agacagapcacagugcgaggcugcapcaggaugaccuaacaapcccugcuauggcaacaagaaggacaggcaccugcc\n", + "ucaagcugcacgucaggagcacauggaacgcuuupucccuuuuuagccpauuccagugaaugaaaacgguagcapcucuuuugagcuuggucaupcagcccuccgag\n", + "gcccagaggaagccacpcgcccaggcpcaugaaapcucuuugacggcupuugcupacaguaacacagacggccggccag\n", + "cucccucccggugccggcuucucugagucaccaaccugaggcugccccggccgccugcgcacccggcagcaccaugacag\n", + "auugacagcgauguuacccauguuauaaupcugaagauaauagaagcaaguacaggcggauguugaupccugucaapacaggugccacuguucagagcuuuccuagagu\n", + "uccccgccgugccuccucgcuggccgcgcucccucccggugccggcuucucugagucaccaaccugaggcugccccggccgccugcgcacccggcagcacc\n", + "cucccggugccggcuucucugagucaccaaccugaggcugccccggccgccugcgcacccggcagcacc\n", + "gcuggccgcgcucccucccggugccggcuucucugagucaccaaccugaggcugccccggccgccugcgcacccggcagcacc\n", + "ggaaguaguccuacauucgcggucagcgcpucuccpcgcccugcapcpcaggcugugccaucccgccggacgucp\n", + "gugccgauuuagcugccgccgcgccuuggaguccugaggaacuuggcuaggcuggccccgagcggaaccagagaaugcugagg\n", + "cucuaaccauggaauauucggaaugucccauucuaugaaggagguuugcuggcugcaacaggaauauuc\n", + "guuugcugugccgauuuagcugccgccgcgccuuggaguccugaggaacuuggcuaggcuggccccgagcggaaccagagaaugcugagg\n", + "guggcpaccguuugcugugccgauuuagcugccgccgcgccuuggaguccugaggaacuuggcuaggcuggccccgagcggaaccagagaaugcugagg\n", + "auguucgcagagcacagcccccugcccugaagacuuauuaauaggcuggucgcacccugugcaggagucagucccaaccaggacacagc\n", + "gucacaguuguacuuuuagcuucccccauccugcaaggccacucaaccaugugcuagcuggagugaucuuuauucaca\n", + "guacuuuuagcuucccccauccugcaaggccacucaaccaugugcuagcuggagugaucuuuauucaca\n", + "aaugacuuuugauucaaaagaccgauuggaugaaaucuugaaguuccuaauagaugcacugauuuccggcauacuaaaagg\n", + "gguguuuagapaugcagaugcuuggccacccguggaaguagcuauuggacagacacacucauccgugaggacacaucaagcuagauccugaapagauagaagugucauauaggcaaacp\n", + "agauuggaauuaaaugucacguggaaaaaagccaacauggcauucuguuaagaagauagacaaccuaagugacgucuauccugcuucaaagacaaaacucag\n", + "gaggcuguacauucauuuagagcagaguagacgaaaccuccuauucucuggcuupaaccaggaggaaucacugacugagauuugccaaccagaccucuaug\n", + "aagugagcucuaucacaugguacguuuaugagaagaggaaccagcaauguuuccuuccaucuucaacuauacuaacaagauccaucugaugu\n", + "gcuccugcaacacagcagcaauggcaauuuggcggacuucugcgcupccagcguauagcucuuacuccacacucaccggcagccuuacg\n", + "ucucupcuccccagaagccagccuuucgcucccggacccggcagcccgagcaggagccgupaccpcgccagcacccucugcggcguguc\n", + "accccgcuccggauccpaucugagcgccggccgcggugcccaggcacucccuuggcpccgg\n", + "cucucucgcuccugcguucgcaggcggcggcuggcggccggcuucucgcucpcagcggcggcggcggcggcggcggcuuccggagucccgcugcgaag\n", + "gcggcggcuggcggccggcuucucgcucpcagcggcggcggcggcggcggcggcuuccggagucccgcugcgaag\n", + "ggcggcuggcggccggcuucucgcucpcagcggcggcggcggcggcggcggcuuccggagucccgcugcgaag\n", + "cucucucucgcuccugcguucgcaggcggcggcuggcggccggcuucucgcucpcagcggcggcggcggcggcggcggcuuccggagucccgcugcgaag\n", + "agaggcaccgcaaacaaacccaauuccugguguccccuagucuuggcggaggagccuuuuagaugagccccgaaaggccpcag\n", + "gucgccaucuugccccuucagaggcaccgcaaacaaacccaauuccugguguccccuagucuuggcggaggagccuuuuagaugagccccgaaaggccpcag\n", + "ccugucgccaucuugccccuucagaggcaccgcaaacaaacccaauuccugguguccccuagucuuggcggaggagccuuuuagaugagccccgaaaggccpcag\n", + "guuaccugucgccaucuugccccuucagaggcaccgcaaacaaacccaauuccugguguccccuagucuuggcggaggagccuuuuagaugagccccgaaaggccpcag\n", + "guguuuuupaaaaaaaucacaaucuggacgugagaaaggacaugaggagacuaaagaccupauuuugucaaucaga\n", + "cuucugucuaggcagagcucugcaaggagagguugugucuucguucuuuccgccaucuucguucuuuccaacaucuucguucuuucucacugaccgagacucagccg\n", + "aggcpaccgugcaccgugugugcgcgcggcguugaaaugcccugcacgucpcagcpacagaucccapugcccapagucuccaagugccucacuccucccgccgcaaac\n", + "ccgugcaccgugugugcgcgcggcguugaaaugcccugcacgucpcagcpacagaucccapugcccapagucuccaagugccucacuccucccgccgcaaac\n", + "gcuccggucucgucuucacugcuguuuguccucugcuccuagaggcccagacucuguggcucugugaccugcagguauupagauccacagcuaagacuccaggacccucuggaagccuagaaaug\n", + "guauugcugugucuaauuuagaccugaucaccugucuggagcaaggaaaagagcccuggaauaugaagagacacgagauggcagccaaacccccag\n", + "auggaguuuugcuguuauugcccagacuggagugcaguggccugaucucagcuaacugaaaccuccgccucccpuucaagcgauuucuccugccucagccuuccgaguaacupauuacag\n", + "guugcugaucagcucugugccaaguauagcaaggaauauggcaagcuauguaggaccaaccagauuggaacugugaaugacagg\n", + "ccgcccgcgcuuguugugcugaggccgapagucgccauuuuggauggugaacccugaagucggugucugcugcguucacggcaggauucgguuag\n", + "gugcugaggccgapagucgccauuuuggauggugaacccugaagucggugucugcugcguucacggcaggauucgguuag\n", + "cgcccgcgcuuguugugcugaggccgapagucgccauuuuggauggugaacccugaagucggugucugcugcguucacggcaggauucgguuag\n", + "ppcgcupugupcggcuccpccpauggcggcggccgcgguugcggcggcuccpacgagugaguggauccupaagcgcugugaaaupcug\n", + "uagagacagauuuucgcaauguugaccaggcuggucucgaacuccugaccucaagugaucccccugccuuacccucccaaaaugcupauuacag\n", + "agauacuguuucgaauaauuggcuuguupuacaauucacaguugauauauuacaggaucuaaauagacag\n", + "accaugcguaauuuccucuuuaguagagacpuuccucuguguuggccaggcuggucucgaauuaccgacuucag\n", + "agaaupucuugcuacauuguccaagcuggucucaaacuccuggccucaagugauccucuccccuuggccucccaaagugcuggaauuacag\n", + "agacgaggucuuacuguguuacucaggcuggucccuuggccucaaacgauccuucuaccucagccucucaaguagcugagguuauag\n", + "agcgaugcgguuucacuaugguguccaggcuggucugcaacucccpcucaagcgauccucccgccccgccucucaaagugcupaaggucccuuccaggcuuaagcagcgaua\n", + "acucuagccuugucaccucaucuugcccccuugguuuuggaaguccugaagaguuggucuggaggaggaggaggacauugaugugcuugguguguggccaguggugaagag\n", + "aggaaggapuggcccuaccccagcpcucggcucpccuccgcggcaguucpuccuucacccgccggcuccag\n", + "uugaccauagucggauuaaacuacaucaagaagauaaugacuauaucaacgcuaguuugauaaaa\n", + "aggaagcugcgagcgcgcupagcgcagcugcaggcguupcggcaggagccgcggagccggcgcugagapcugcggccggagcpcggcugagacaaaggcgacg\n", + "cgcupagcgcagcugcaggcguupcggcaggagccgcggagccggcgcugagapcugcggccggagcpcggcugagacaaaggcgacg\n", + "gagcgcagcugcaggcguupcggcaggagccgcggagccggcgcugagapcugcggccggagcpcggcugagacaaaggcgacg\n", + "aucauuugcaugucuagcuggagaauaaaaauaauauaucauuugcaugucuuaguaaugaagucaupugucguggc\n", + "agcuacaaccaaguaagcaagugucapcucaccaaccaugcaaggacapcaggagaagaggaaccugcaaag\n", + "gcugguuuuggagaccccgagucagaacaucuucuucuccccugugagugucuccacuucccuggcc\n", + "uggapagaggagagauuaaagugaggagagagcuacaaccaaguaagcaagugucapcucaccaaccaugcaaggacapcaggagaagaggaaccugcaaag\n", + "uccaugaagcagaaacaucaaaaagcaupauuuggaauuugagaccugacuuugaagcccacacagaacacagacaagucaaccaugcuauuup\n", + "ugauuuguaaaaagaaacuuaacagaauuuuaucaccguacucaucacuguagcucugguuugaaaaggaaacuacccuuuccagccuaggaa\n", + "auuagauauuucaucuuacugcagagcauagaaucaauaggagcuucuccuuapagcugcuuugaaacag\n", + "gguaccgcacccgcuaccuagugugaaugaacuguggcgupcugcuaapcaggcugcggaguacccpccguggcc\n", + "acgaaucccggucpuucupaggcacagccucpuugcpccpugcggcucggcgguggaggacucacuuccugcuccauccccggcupcccupcg\n", + "guguccccacagcccugucacgaaucccggucpuucupaggcacagccucpuugcpccpugcggcucggcgguggaggacucacuuccugcuccauccccggcupcccupcg\n", + "gguugcpccpugcggcucggcgguggaggacucacuuccugcuccauccccggcupcccupcg\n", + "agupcpcucccgguuccaggcgaguucgcagcugcgcgccpuccuggaggccgaggccgcucccgcccguuguccccgcaguccccgacpagcgcc\n", + "agcugcgcgccpuccuggaggccgaggccgcucccgcccguuguccccgcaguccccgacpagcgcc\n", + "ggcgaguucgcagcugcgcgccpuccuggaggccgaggccgcucccgcccguuguccccgcaguccccgacpagcgcc\n", + "gaguucgcagcugcgcgccpuccuggaggccgaggccgcucccgcccguuguccccgcaguccccgacpagcgcc\n", + "gcgaguucgcagcugcgcgccpuccuggaggccgaggccgcucccgcccguuguccccgcaguccccgacpagcgcc\n", + "auuuccaaguaguauaguugcagaucuucgaacgccauuccuguguucugugaauucaagacaacaupuuuuauaacccuuugacucugcucagcaucucccagaucaag\n", + "acgaaggaggacucucggaagccaagaaagguuuaagaagucuuucuggauagagagcagugcccaggcaggaagccuuucgccggcagagcpuccaaggacgagcuggagaggacagaggcgcg\n", + "gugcuggcagcaguaggcgapcgcggcugcpuuccuggugcugaggacggacgccauuggaguucccgagaag\n", + "ucaggacaagacaacuuucuccucaccaugguggcugaguucuggaggcuguaauuucguggauuucuguggagcuggcagag\n", + "cucaugucugcapcucugagaggaggaagccupcaggaccugcgccaguggccgcupcacagc\n", + "guuguaacaaaaccgcucaagucugccuuaaagagccuuacaagccagccagucccugcagcuccacaaacugacccauccupccuuguucuccacaga\n", + "gagccuuacaagccagccagucccugcagcuccacaaacugacccauccupccuuguucuccacaga\n", + "gcuagucccagaggcccagaguggcucgccuggagucucuguggcgcgguuuccuguaccugccuupauccggapaggaagcupacacccpagucaggaa\n", + "gacucgguggcuuuugaggauguagaugugaacuucacccaggaggagupcuuugcuagauccuucccagaagaaucucuacagagaugug\n", + "guggcucgccuggagucucuguggcgcgguuuccuguaccugccuupauccggapaggaagcupacacccpagucaggaaaug\n", + "aaaaaaugacaucacaggucagaaccuuacaucgacuuggugagugguugcuggugagaauuaagacccuggaggapagcauuuccacacugagaapacaguagg\n", + "ggcccuggcugccupcgccgauucccpacgcgccggccgacagcapaggcggcagcapaccgcagcagcccccgcuuccgcacggcccgccpucgcg\n", + "ggcggagcugcgguuggcuuguggcgucuccgccgccgccgcccucccuuccucuuccccaucuucuucucucggucccpagcccccgcccgga\n", + "gaaggcccgaacaagacaggaacguccugugcccuggacuguggagcuggcauupaggaucaccaagcggcugcuccugccgcuguucagagagguggau\n", + "gagcugucgcgucuggucguggucuggcggagcugcgguuggcuuguggcgucuccgccgccgccgcccucccuuccucuuccccaucuucuucucucggucccpagcccccgcccgga\n", + "agcugcgguuggcuuguggcgucuccgccgccgccgcccucccuuccucuuccccaucuucuucucucggucccpagcccccgcccgga\n", + "cgcguccccaagaggucuacpccggaccupcapacuacggagcaguccaupucpuacaggaggaaagucaaggcacucaaagcccag\n", + "gugugaucucagcucacugcagccuugaacuccuaggcucaagugauccuccuaccucaaccuccagaguaacupacuacag\n", + "aggacagcaucuguggccuuccugagccggaccugaggaaucaagagcaggcccpagucuugcccuccuuugcacccuagccpuaucaccugcaaauucaucuuuaag\n", + "ggcuuuaugucucuuucauccuccucugccuuuccccugcccuugaucccuucugcaggucuuggcugguuucaggaaacpucccauccc\n", + "uuaggccccccagaacaaaguccuucupuccucucccuuccaggacccucuaggcagcccggucacccccaggccagacuccapcgaguccccucccaacccagcuggcaguucgcgg\n", + "gugucccaggcgcugauccgcuccuucagcuccaccgcccggaaccgcuuucagaaccgagugcgcgagaaacagaagcucuuccag\n", + "gaggacaaugacaucccguuguaccugaapcggcaucguugacaacauccuguaccgagugaca\n", + "cucucccuguccagccgccugcagcugacccuguaccaguacaagacgugucccuucugcagcaag\n", + "ggacggcagauaugaaaugccuggcacagugcuupucuaguauguagcuuccagaacccacccugccccucuaccupaggccaaaugg\n", + "ggagcuccuguggugguagcagcgguagcpagacggagcgaguccagcggccgcpcagacccggapaacggaggaagcgguc\n", + "cgapupucgcgccpccggcggagcuccuguggugguagcagcgguagcpagacggagcgaguccagcggccgcpcagacccggapaacggaggaagcgguc\n", + "ccuuugccagccuacuuugugaaagaaaacauupuuucuuuggcuguucuugauaagccuauaaaaaaugauauuuuuuaguugcuuauag\n", + "cuuuagguuuaaucacaucucuccaaucgccgapaacuggagauuuaaacaaacauacgugaacug\n", + "gaauaaucgguggagauggauugugaaauggaggugcauaaauauccaguuugccaaccgagcuaagaaaugcuggauaaaaguaaaag\n", + "ggcugaagcagugccuacucgacagaaccggucaucguacaaagaaaugccacgugacucaaaggcaaagccagagugcagcuuggagcaaagaag\n", + "gugacuggauguguugaucagcgcucgcupauuuggcugacguggccccagccccgccucccuccccaccccaca\n", + "ugaguugcuuggaggagcuuggagaaaccagaagugagauccaggagaaguaaggcccuggagugccaggagcccuucucccaaagauggagaaauaaaugaagaaauacag\n", + "gaaaauaagcauupuguuuugcaauggcuacacaaacuagucaugucuuccauggucaagaaaauauguuucuggaaaaccauug\n", + "aggcugcapagugagacccagucuucagauupaggacucugaagacuggcuuucggcucacaguuuaaaaugucagaaacucaccuuggcugaccugauaagccapcacagaagugcu\n", + "ggaggapcaccaaugucgugcagaaaauauguuucuccacccagaucauccgccauuuugagucaaagcuuucuga\n", + "gcauuuggccucaucaaapccagagucagcauccucauagaugugucagccaucagcaguggcccucagaaagaagaguuccaaaaggaccuc\n", + "gaguugcuuggaggagcuuggagaaaccagaagugagauccaggagaaguaaggcccuggagugccaggagcccuucucccaaagauggagaaauaa\n", + "aguugcuuggaggagcuuggagaaaccagaagugagauccaggagaaguaaggcccuggagugccaggagcccuucucccaaagauggagaaauaa\n", + "gugaugugacuuccugcuugacccugcccacauggagcauugugacauauguguggaaccugcacuuag\n", + "ggcccaacaccuggaugauguuacucuucugccuaggucaugcguaaagapaauuapcauauugcuuggcccagucccguaaugauaugacucuccugcuugugccagagccacagaag\n", + "ucuuucuugacacgaaaauauuauuucaacaacccagaggauggauuuuucaaaaaaacuaaacggaagguagugccaccuucuccu\n", + "uccaggcgcugcugccccaacacaggcpcacucucugcpucccgcggcucccgcggcuuccggcccacucagcgccuccagaggccucag\n", + "aggcuccagagapaaggaapcagcagagapucagaaggapagcuuaagccaggcapuuacuugucucugugacuccuuccgccuggcacaugcugcccagcu\n", + "gaguccgccucagacucagagcugcgcuccucgaccucaacgccaggcgguuacuuugcugcuccucccgcucgcu\n", + "ucagcuucuggacgcgaggugcuppapugcugguaauggacgcuapcccuggaguacccapaggagucccag\n", + "agacuucpccuuccpagauacgagucaggaaapaucuggugcupacucggagcuuccggagupcugagagaggacccccag\n", + "auuauuuuagcuuccugagauucagaggccaggaacugugcagagaucugupauucucacaacuuccauuucuggugaacagcugaggucagagaggag\n", + "ggaacgcgccucugupagaagcaggcggcugcggugucccuuuugcccuaggcucucgguucucaggccucggcgugcggcgugcguucggcaguucaguugccaguugguucguug\n", + "ucugupagaagcaggcggcugcggugucccuuuugcccuaggcucucgguucucaggccucggcgugcggcgugcguucggcaguucaguugccaguug\n", + "auucguaacugaggcacacuugccuuuugcaacuaagcucuacugaauuccaaagcuauagaaauauccaucuugaccuggaaagucuguuucuuugcuaguccagaagguuuuuuuuaac\n", + "auaaggcgauccagcaccuaagaucucagcaaaaaaaagcuagguccugaggcagcuaguggaaaaacaagagaapaagucaaaaggcuacuugcugucagcuaaagccag\n", + "acaaccucuccuguuucaucuccuggcaacagaaugcauccuccuuuupaaacugccucuuuccccacuccucagag\n", + "aucauucguaacugaggcacacuugccuuuugcaacuaagcucuacugaauuccaaagcuauagaaauauccaucuugaccuggaaagucuguuucuuugcuaguccagaagguuuuuuuuaac\n", + "ccaaagcuauagaaauauccaucuugaccuggaaagucuguuucuuugcuaguccagaagguuuuuuuuaac\n", + "ggcuucucgcgcgcgagccacgcpacaagucgcggccaccugcuccggagcupagcccpcgccguccgcccgcgcgucgguucgugugccccpcccc\n", + "cpcgccpcgcgcapaccgapaccgagugcuccccaugagcgcacgupccpcgguccgcaagcccggcugagagcgcgcc\n", + "gcaccpagccuggccgcugcaguggagacagccucpacgccaggcccugguggupcaagcccagccccuac\n", + "aggaaaagacaagcauacgaaucuaaccuuaucugucauggccugcaguuagaagcaacaagauca\n", + "guauuggaugacaagcuuguauuuguaaaaguacacgcaccaupagguguuauguacguaugcugagaua\n", + "augaaaaagaugagcaggaauguuuugcuacaaauggaggaggaggaggacgacgacgaupauaucg\n", + "aucauccagaaugcccuggcaaguucacuuccauuuagugaagugagauaauuuggcaauucacgcaagagacugagaaccaagccucaagcccugccucugauucugcagguaug\n", + "ggcgaacuuugcguugcaaggcuuucuacagugucaauggcucuguguacugugaggaagauuaucug\n", + "aaagagaaccggccgccgagacgccgcapugccaggcpapcgagaggccccaggcccgapc\n", + "acucgugucucgcuaccagcuccccgcugcccugcgcucggcpcuggcauccggcccpaaagcggaccag\n", + "cccuucugcaggucugcpccaagugucccggcggcgcaccucguggcgagaaucpagaaggaggagacuacaaggauaggcccag\n", + "gccpccgccgccucugcgcucagccccgcaggccpcaupupcgccpccgucacg\n", + "ggugugauccuggucuaugacauugcgaaccgcuggucuuuugacggcauugaucgauggauuaaggagaucgaugag\n", + "gagcaaggacucpcccgcgcggcgccucucpccpccgccgccucugcgcucagccccgcaggccpcaupupcgccpccgucacg\n", + "gcuuuugcaaggcuguggucgguggucaucagugcucuugacccagguccagcgagccuuuucccugguguugcagcuguuguuguaccgccgccgucgccgccgucgccgccugcucugcpuc\n", + "gcuuugaccpucguggcagccggagucgucuucpacgcgccugcucuucgccuuucgcugcaguccgucg\n", + "uuugaccpucguggcagccggagucgucuucpacgcgccugcucuucgccuuucgcugcaguccgucg\n", + "agagucgcgugacuucaacccccucuucpaggcupucgucaugauccggaccccauugucggccucugcccaucgccugcuccucccaggcucccgcggccgacccccgcgcaac\n", + "gcuupcggaaaagccguggcgcccccuugcguggcgcgucggucucagagucgcgugacuucaacccccucuucpaggcupucguc\n", + "gacuuuagccgguugagaaggaucaagcaggcauuuggagcacaggugucuagaaacuuuuaapccgguucaagaaggaaaaguucccuucugcugugaaacuauuuggcaagaggcuggag\n", + "guaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcag\n", + "ggcccaauggcugcaaaaucgcaacccaacauucccaaagccaagagucuagauggcgucaccaaugacagaaccgcaucucaapcagupccgugccug\n", + "aupccccagugugacugccugcauccguccucgcapagguggacugguuuucacuggcgagcgucaucuuccuacugcuguucgcccccuucaucgucuacuacuucauc\n", + "gacuccgaccccuggcuagapuaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcag\n", + "pcpcgccccugcccugcpugacuccgaccccuggcuagapuaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcag\n", + "aucupccaagacuccaccuauaacgaggaaagccgcccagcucuauaccuugupucaccuuccag\n", + "gugcuucuguacacgucucucccugacuucugccauaaguuucuacccggcuacguaggaggcauccaggapccgugacuccugcag\n", + "gcpugacuccgaccccuggcuagapuaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcag\n", + "gcpugacuccgaccccuggcuagapuaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcag\n", + "guggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcag\n", + "ccgguugagaaggaucaagcaggcauuuggagcacaggugucuagaaacuuuuaapccgguucaagaaggaaaaguucccuucugcugugaaacuauuuggcaagaggcuggag\n", + "gguaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcaggugaguggccaag\n", + "pugacuccgaccccuggcuagapuaggcggcguggagcagcgcgcgcaagcgaggccapaaggupcgcaggugapccgaggugugcgcag\n", + "gagccaugucugaccaggacguuuggaagaucauauccaugccagaggcucuugugaggagaugaguugguaaagagagaggcup\n", + "ccagugcucgcagugcgcaggcgupcucucuccuugucagucggcgccgcgugcpcugguggcucuguggcagcggcggcggcaggacuccggcacu\n", + "ccgguccagugcucgcagugcgcaggcgupcucucuccuugucagucggcgccgcgugcpcugguggcucuguggcagcggcggcggcaggacuccggcacu\n", + "agcucgaugcugccuccccggcccgguugcgcuguagccgcugccgccucugccupucccuucggccguaccucugcgupcugccuccccggcucccggugcagacaccaug\n", + "uacggauuugugaaucacgcccuggaguugcuggugauccgcaauuacggccccgaggugupaagacaucaa\n", + "gcuccagcucgaugcugccuccccggcccgguugcgcuguagccgcugccgccucugccupucccuucggccguaccucugcgupcugccuccccggcucccggugcagacacc\n", + "aaaagaggcacaguuagaugaagaaggacaguuucuugucagaauaauauaugaugacuccaaaacuuaugauuugguugcugcugcaagcaaaguccuca\n", + "gaugcugccuccccggcccgguugcgcuguagccgcugccgccucugccupucccuucggccguaccucugcgupcugccuccccggcucccggugcagacaccaug\n", + "gcugagcgccagcggaapaaggcuccpuucgcguccccgcgcugcccccgaugcccagccucucccggagcggugacag\n", + "cuggacuccupcgaccccaaagccgccuaucgccuggaacaaccuguuggcaggccgcuguccuccugcuccuacccaccuagugucaaggaggagaaugucugcugc\n", + "ccccuucuuuuuccucccuccccuccaaccgcgcccccccucccggaupaaaaaaaaagaugucagcuccuccgcuguaguauugcuccuuaaaaaccccucucucugaaa\n", + "auggcggccgccuaagucccacagagacpagucpupaucccaggcupccccgcggcgg\n", + "ccugcgcagaccgccuguuauggcggccgccuaagucccacagagacpagucpupaucccaggcupccccgcggcgg\n", + "pccgcgccugcgcagaccgccuguuauggcggccgccuaagucccacagagacpagucpupaucccaggcupccccgcggcgg\n", + "agaccgccuguuauggcggccgccuaagucccacagagacpagucpupaucccaggcupccccgcggcgg\n", + "gcuaccacaccagauucugaapaggaguugucuggaaagaccagagcupugcupaucuggagcagcucpacccgcgcugcapagcupaupagag\n", + "gcgcagguugguguuguugccgcugcugccgccacugcgaggcggucapcaapugapupcgcggaapccupcucpauccugcugccaccaauuccuggugccccaggag\n", + "gaguucgcggccgguggcggcgguggcgacagcggcgaccuapaucgaucuggapacuupagcgugcagagaccucuagcucgagcgcgapaccucccgccp\n", + "cagcggcgaccuapaucgaucuggapacuupagcgugcagagaccucuagcucgagcgcgapaccucccgccp\n", + "gcuggagugcaguggcacaaccuuggcucgcuccagugucuaccugccagguucaagugauucuccugccucagccucccgaguagcupauuacag\n", + "cuagcuaggcggcupagcguuuucguggcpaacggagguugaauugcccugccupcucauapaaggaggaugugaaggagcuugugaaggcagaggaag\n", + "gaagcagcugaagcggcgguagcggcggcggcucpcagapcpagcugaggcpagcggacaggcuggupcgagcgagaggcggcgga\n", + "agcggcgguagcggcggcggcucpcagapcpagcugaggcpagcggacaggcuggupcgagcgagaggcggcgga\n", + "agacgcgcggcggcggcggcgagcgguggcgcucggcucpcgaccgcggcpapcgcggcgcaccg\n", + "gagugguuauuauugagucgagaauuuuupaaaaguaacacguggagagucaauuuuugaguggaaggagucugaagagapuaggaaccaaccuccuacuacccaccag\n", + "gagcpaggcgcgaucgguccggucgguggcuccccgcggcpccpcccgaucucpcpaaccgagcgcagagccg\n", + "gcgaucgguccggucgguggcuccccgcggcpccpcccgaucucpcpaaccgagcgcagagccg\n", + "cagacaaaggcpcgcagcccagcagccgugcpcaccpcgaggcaggcccacuccucccg\n", + "paggcgcgaucgguccggucgguggcuccccgcggcpccpcccgaucucpcpaaccgagcgcagagccg\n", + "accgagcggcgccgaggccccpuugagcpaggcgcgaucgguccggucgguggcuccccgcggcpccpcccgaucucpcpaaccgagcgcagagccg\n", + "ccggucuggcuupcaggcugcccpccguggcaggaagccggaagcagccgcggccccaguucpagacauggcpcguuaaag\n", + "cucucguggcauuauccuucagupcuauuggacugacuuuucuuaugcupaugugccuuagaggauuaugg\n", + "aggcugcccpccguggcaggaagccggaagcagccgcggccccaguucpagacauggcpcguuaaag\n", + "auuccccgccuccuccugucccgcagucggcguccagcggcucugcuuguucgugugugugucguugcaggccuuauuc\n", + "gacccucgucccgcccccgccauuccccgccuccuccugucccgcagucggcguccagcggcucugcuuguucgugugugugucguugcaggccuuauuc\n", + "ggcgcagcuggcugcucuuuucpccggcauacgcgcgcagccgcagcugaggucaccccgcugagguggupapa\n", + "auauaauccacagaguucauuugcpuucauuccaagugacacpcagcaupaacacaugaagaaacagaaguauggaag\n", + "guaacaacupuaaaaaagaagcugagaaagauaggauuugcuggcaaapccuauguuggugcuuuucuuggugcugcaacpacugag\n", + "cuccugucccgcagucggcguccagcggcucugcuuguucgugugugugucguugcaggccuuauuc\n", + "ggcaagucacugacccucgucccgcccccgccauuccccgccuccuccugucccgcagucggcguccagcggcucugcuuguucgugugugugucguugcaggccuuauuc\n", + "ggaagauggugugagccacpcugccpccupcucggcgucgguccccpauguggagagcuggcagcaugucggccgagcupagucgg\n", + "ugcuaccagagccpagagcugcucggagacgccuccpugcpcuggacaugagcagcggcugccgguccupacuaggccccgccauuuuggauccgcugacag\n", + "guuccagcgauucuucugccucagccacucgaguagcupauuacaggcgcccuccaccacaccugcccaauuuuuguauuuugaguggagaupuuucaccauguuggccag\n", + "gcggcppcggcupccgcgcppcccpcuucgugcucacgccggcccgccgcccccaggacguguuccuc\n", + "gugccpccccpcgccgapcaccguggcaugcaaccccugcaacgguaucgcccgcgccgugcaguugacgaaauugagguucggcuuggucgcuuaaccagccaaag\n", + "pcuauuguccccgguaaacugcaguuucugguucgagacuccaauccuguuucgaauugcugcuugcugccccuupcupaua\n", + "agucagcagaggagagcgccaggacgcuacagcggcugaagaggcaguggcgcccgcggccgcagcgucpcuggagcg\n", + "agcagaggagagcgccaggacgcuacagcggcugaagaggcaguggcgcccgcggccgcagcgucpcuggagcg\n", + "gcagucagcagaggagagcgccaggacgcuacagcggcugaagaggcaguggcgcccgcggccgcagcgucpcuggagcg\n", + "cauaaucaaccugaaagaagaaaauaaauacuguauacuuuuaaauuuuaucgauucuuaaaaacuggacacucaaag\n", + "acaguugucaaagugcuuuugccagagcggucacauaaucaaccugaaagaagaaaauaaauacuguauacuuuuaaauuuuaucgauucuuaaaaacuggacacucaaag\n", + "auuccgcgcccgcucugccuacuugaggapugucacuccugcccgcaauggaauguucagaacgcpaccuccuupuuaggauuucuagaccccpaucgucgug\n", + "gacugugccugugcugaagcccuuuccuccuccuagcucccaggcagcuagaaaauugccugucugaaagaaaguagcuguuuuccuuapacugug\n", + "guggccggccgcggccaccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "aaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "gcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "uaagaagagcguggccggccgcggccaccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "gccggccgcggccaccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "cggccaccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "accgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "gcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "caccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "capaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "uggccggccgcggccaccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "gcccguuaagaagagcguggccggccgcggccaccgcuggccccapaaagccgagcggccaccgagccggcagagacccaccgagcggcggcggapagcagcgccpcgcacgapcacc\n", + "cggaagucgucuggccuccccgcggccgcucgcagcuugcuggccucucccgcgccucacgucggacuccgucuccgcggcapaagcagc\n", + "gucuuucaccgucuggacucaucucupuaacucauggugugaguggccacguggcuggcucag\n", + "guguuuggacagugaacgccagguccccuccuccccacccccggccucucaaacacgcccagccccacg\n", + "ggucuuucccagaugugaaggucccucccaggcucuacugaggucagaccaauucccaguggcuupuacccucguucacuccagcaccagccccugcccuccuucuucccpccaggcugccag\n", + "guugagaggcccgcgaacugacpccagugagcpcgucpagupcggaugcguupuucpucgupuguugaggcggagaggaaggcgugguguggcgucuccag\n", + "agagcaccgcagccapagaugcuggcgagacgacagcgagauccucuccaggcccugcggcgccgcaaucaggagcugaagcaacag\n", + "gcugaugaaucugcaccuguugcaaacuauaaucagagaaaagaagaggagcauacucuuuuggacaagcuuacccaacaacugcapccuugcugugacaauaagcagagaaaauauaacuga\n", + "aaapaaauucuccuuguaauugaaaaaaaaccugaugguugguggauagcuaaggaugccaaaggaaaugaaggucuuguucccagaaccuaccuagag\n", + "ccuuauagugaagaagaagaaggccaagagucaagugaagapcagugaagaagauguagaggcgguggaugaaacagcagauggagcagaaguuaagcaaag\n", + "pcupaggcpcgcacaucgauggcgucaccuucuggcgccgccgguugguuucccuggcaacuggagcaaucagagcaccgcagccapag\n", + "gauggcgucaccuucuggcgccgccgguugguuucccuggcaacuggagcaaucagagcaccgcagccapag\n", + "gugcggagcgcgcgcgcgcgcggcucggaggcgcaccugugaggugucccugaggagapaggupugcgcggcgcccgcggccupcgcugacuccccucacuugga\n", + "uucuguggugguuccaaccugugauaacugagaacaauacaaauagagauuugaaauucauguugaauc\n", + "aggagaugcucugcugapcaguugcuaugguuacapccuggaccuuccuccggaaggugagaaacag\n", + "guuggucucgaacuccuggacucaagugauccuccugccuuggccucccaaauugcupaucacag\n", + "gugcapacugaggcucaggccaaaucgcaacucagacccagugaacccaaggccugaagagaauuuggauucauuuaccuuguuuugupacuggagagacaa\n", + "ggucucacccaggcuagagugaaguggagcaaucucggcucacugcaaccuccgccuccugaguucaagugauucucacaccucagccuccccaauagcupauuacag\n", + "gagcagccuuccccucgcuuccaccuuugugguuauggagccccaaaccucuuaggacucugcaccaggagaagguugcuaag\n", + "gcugagugcaguggcaugaucauggcucacuggcucaagccauccccccaccucagcauccugaguggcupaccauag\n", + "uguuuguuuugagacapucucacccaggcuagagugaaguggagcaaucucggcucacugcaaccuccgccuccugaguucaagugauucucacaccucagccuccccaauagcupauuacag\n", + "acugcgaguuuccggucupcuuuggcpucugguuugaagcucuccuguuugacgaaaguaugucucaggaag\n", + "guuuguucugaguaaugaauacccuauuacuaugauacuaguaucuuccuuaauuauccuacucauugucucaacauucugacaguuggauugagcauauuc\n", + "aaauuuugaaaauuauuguagaaauguuuuuaccucauaugaaccaccugacauuggaacagacuuucuuuucacaaguguuaccaaag\n", + "acugugaaauuauucgaugacaugauguaugaauuaaccagucaagccagaggacugucaagccaaaauuuggaaauccagaccacucuaaggaauauuuuacaa\n", + "uuauucauucuuuauuggauaucugcucuguuauuuccaguauggaccaugcauuucaugccaauacuuggaaguuuauaauuaa\n", + "gauaaugcugacuacagauuauuucagaaaacacucaaauugugucguuuuuuugccaacucccuuuugcacuacgcuaag\n", + "gaauuucuuccuuuccucucugauucuugcuguacuuugcaccaacuguaucuucagauacacag\n", + "caaguuuccuccaagccuuuaugcuaccaggauuucuaaagcacaccaagaggaaauagcaggugcuuuccuagugacacuggauccacuuaucagucagcugcucacauuucagccuuuc\n", + "acucccagcgcgaguggcggcggcggcggagccuucpcgagcgcgcgugugugugagugcgcgccggccagc\n", + "ugcugccacaccagauccagaggcacagagccpcacguuccugucaapugcuggcccugccauucuccccaggag\n", + "guuacaggaucccuccuugaggaaacgacucggaagupcucaguacaaacaggcaugucugagagacuuacucaaggaaccuucug\n", + "gcauauuuuguaacpacauuugaucaguacguguguuggccucauucuucuccuggaaaugucucuguacccugcccuucauacuuaccuugguggagugaag\n", + "agagcucaggaapccuacagacacugcuuggcucapacuuggcagacgauagagaacgccacggauauuuggcaggaugacuccgaaugcuccgagaaccacagcuucaagcaaaac\n", + "ccaagauucuacauugcucaucupcaucugagccuccuucgaaguuuccugucacaacuguccucuugacagc\n", + "augguaacggcucggaagccuaggaggcupccggapaggcggaggaaccgguguucgccgccgccgcugcuucagcuuauuccuuguggccucugcpuccugccucagcc\n", + "gucuugaccccugaauuuaagaaauucuuaaagacaaugucaaauaugauccaagagaaaaugugauuugagacuggagacaauugugcau\n", + "gguccuacgaugauacaccaaccacuugugcuaccaucugucaaaacuuuggauggcccuacuuucag\n", + "aguggucaaggccgcgcucgcgccgapcugcgagagugaccgcggcugcuccagcgcugacgccgagcc\n", + "gcggcuucucaaacauggcggcggcggugugaagcucggugccggcucgcgcgaucggupacagaauuucguuguuuucaccgacgagacuggag\n", + "paccupccuuuuaacccugguuuacccguggaagugccccuguggcuggcgauuaaccugaaacaaagacagaaaugucgccugcucccuccagagugg\n", + "cugagcguguacaccacgacgaggucccaccupugcugagaacaacaucgaccuggucuugaauguggaagacuuugauguggaguccaaauuugaaag\n", + "agupccguugccuuacaguugcugagaggaggcgagaggcpcgcuapccgagaucaugucugacupagagguuuccuuggcagcagaggacgcuagguuup\n", + "acaguugcugagaggaggcgagaggcpcgcuapccgagaucaugucugacupagagguuuccuuggcagcagaggacgcuagguuup\n", + "gagccaauggaguuacucguagucgagaggccggcaucacuggagugguggcgcagcuguuuccuccg\n", + "aagcuguggugaucagugacuuuggugaaagcuaagaagguucaaacaaauuugcaaaugauauacaacuucuaag\n", + "gcacuguagcugagccaauggaguuacucguagucgagaggccggcaucacuggagugguggcgcagcuguuuccuccg\n", + "ugcauugaucacaacauaugguaaugauagcgugauugugaugaccuuuguuuuauaccuccuuuua\n", + "gaguauaucuaaguguuucagaauacacucaaauuccagaauacgucugcaauagugccaggcacauaguagaucuucaguggauauugaaugaaucgugacaaaug\n", + "aaacagagugaagacacuggcccuggcaggcagcagcupucuaagagagcugcagcccapucacagaccugupcccc\n", + "cguccgagucaccgucgccpcucccgcgcuccccagaacggupacgcpcucggcagccgccagcggaac\n", + "auauggauguaaugaggcccuugauaaaugagcagaauuuugaupacaucagaugaagaacaugagcaagagcuucugccuguucagaagcauuaccaacuugaugaucaagapcauuuc\n", + "auuuguacaaacucuuaugcaccuucuuaaaggaaauauuggaacuggccuuuuaggacuuccauuggcaauaaaaaaugcaggcauagug\n", + "gcuauuacgucccagcgucugagagaacgaguaagcacagaauucaaagcauucugcagccugaauuuugaag\n", + "auuacgucccagcgucugagagaacgaguaagcacagaauucaaagcauucugcagccugaauuuugaag\n", + "gcccaggcugccagaccggaagcgcuccgcuguaccuggauccugcuccucupuugaaacccpcgccgccaag\n", + "guccgcccgcgcgucccgccccgcpcucccgguggcugcuucccguccgcuguccucugcugccaguccccugccccpcaaagcccaucugguccgccgagcag\n", + "pcucccgguggcugcuucccguccgcuguccucugcugccaguccccugccccpcaaagcccaucugguccgccgagcag\n", + "acuuucuacuaaccggcpuuaagaupuuucucaggccpcgcgguggcucaugcccguaaucccagcacuuupaggcccaggcpccgaucgcuugagccuaggaguucgag\n", + "aacacuuugcgccuucccgaccucagagacguccgucucucuccaggccggagcuauupaguggcggauccucccaccccagccggaucupcc\n", + "gcgcgucccgccccgcpcucccgguggcugcuucccguccgcuguccucugcugccaguccccugccccpcaaagcccaucugguccgccgagcag\n", + "cuagcccgagccgccccguccgcccgcgcgucccgccccgcpcucccgguggcugcuucccguccgcuguccucugcugccaguccccugccccpcaaagcccaucugguccgccgagcag\n", + "gucccgccccgcpcucccgguggcugcuucccguccgcuguccucugcugccaguccccugccccpcaaagcccaucugguccgccgagcag\n", + "caccgacpacgagagcgcagaggauggcgcuuuuagauacuuccagucuuccgauguugugaucgcag\n", + "agucuucucgagcacaucgucgcaaacpccggaaagcguggcagcgcaggcgcaagcgcagagagcggaggcgguggugguggcggccgcuggccagu\n", + "uccuucagugaaucuacagaccuauuuucucaggagcucagccuggccuuacuucagugauaaaaggaggaaag\n", + "aaagcguggcagcgcaggcgcaagcgcagagagcggaggcgguggugguggcggccgcuggccagu\n", + "gucgcaaacpccggaaagcguggcagcgcaggcgcaagcgcagagagcggaggcgguggugguggcggccgcuggccagu\n", + "gcaaacpccggaaagcguggcagcgcaggcgcaagcgcagagagcggaggcgguggugguggcggccgcuggccagu\n", + "ugaaucuacagaccuauuuucucaggagcucagccuggccuuacuucagugauaaaaggaggaaag\n", + "aggacacgupupaagcugagcgcugagaccaapcuaaagcupaggugagucugucaccuugagccpcgagcgcugupccaagcapuugcapuaguaggagugcag\n", + "cggacpugaapacgaccaaaggucgucauuauaagcaaacaaccapucucagupauuauuauuacuauuuuuucccccucugcagacugaaaaa\n", + "ccaaugagaauggagaagguccaggacacgupupaagcugagcgcugagaccaapcuaaagcupag\n", + "gucucuaucugcggccggagcuccaggucucguccucacuacucugugucuucugcuuuuapcgcagccucuguggcccugugaccugcccccuggaagccuagaa\n", + "cpccuuugucucuaucugcggccggagcuccaggucucguccucacuacucugugucuucugcuuuuapcgcagccucuguggcccugugaccugcccccuggaagccuagaa\n", + "cuuugucucuaucugcggccggagcuccaggucucguccucacuacucugugucuucugcuuuuapcgcagccucuguggcccugugaccugcccccuggaagccuagaa\n", + "ccucacuacucugugucuucugcuuuuapcgcagccucuguggcccugugaccugcccccuggaagccuagaa\n", + "pccuuugucucuaucugcggccggagcuccaggucucguccucacuacucugugucuucugcuuuuapcgcagccucuguggcccugugaccugcccccuggaagccuagaa\n", + "aaccpcggcccgaguacgcguaagcaapacaagccggugaccuacgaggaggcacacgcgccgcacuacaucgcccaccguaaaggcuggcugucgcugcacacag\n", + "guaaccuggauggagaggaccaugccgcagagcgaacgguggaggauguuuuccuucgcaaguuc\n", + "aaacugcaccgcgcaaagccapcgupcpcccpcugcucuaccugcgcucggaaagcuapcuccaaagcguuccugagcgguuuuugaccgcgaaugugauagugcucaug\n", + "ggauacaccagugcacagaauccuccaccaacauccaucccuucaaguggugaaaacagacaauaaugaaaauaaaauaugug\n", + "pcucggcugcaccppaucgcgccuggcagaccccagaccgagcagaggcgacccagcgcgcucpagaggcugcaccgccgcgcccccgccuagcccuuccggauccugcgcgcaga\n", + "cugcgcagagucugcggapcucggcugcaccppaucgcgccuggcagaccccagaccgagcagaggcgacccagc\n", + "guucucpagcugcugccguagcugccgccgccgcuaccaccgcguucpuguagaauuuggaaucccugcgccgcguuaaca\n", + "guccucccaucagaucauuccugaugucucuuuuguuguuagucpagagccugaggucugcugguacugaaggcuagcaacuaagaguaccagaggcgagaccucgcggaccccugcuuccccaaa\n", + "acggccgccagccggccucccgccagccagccccgacccgcggcuccgccgcccagccgcgccccagccagcccugcggcag\n", + "auucgcgagcccagcgcccugcacggccgccagccggccucccgccagccagccccgacccgcggcuccgccgcccagccgcgccccagccagcccugcggcag\n", + "augagaauucuccagccaacuucupauucuaagaacapugugacuggaacacaaaaapcaaauuguauggagaauugagccupcccuauuuc\n", + "agucuacuucagaagcggaggcacupaguccgguuupauugccaggcugugguugugagucugagcuugugagcggcuguggcgccccaacucuucgccagcauaucaucccggcag\n", + "gcgauaaacuacauucaguugagucugcaagacupaggaacupugauaagaaaucuauucacugucaag\n", + "aagaagccapacugcgcgcgugagcgucacgcaugcpucaacggaupugcuuggugcucupcacugcapugcuggcuggacugcgguuacc\n", + "apcguggapcggagcuccagcggccuucagapucgcuaggccacacpcgagapcupaaacacccccgccaguuccpugccuggaguuuaaaag\n", + "ugcgccugcagcucgcgcucccgcgccgaucccgagagcguccpccgccgugcgcgagcgapapcgcgcgcgcppcgcgcuugugagugcpccgcgcucucggcggcgcgc\n", + "gcaccgccaagcggccgccpccgcaucagcccuccuccuguuugcgcuccccagcgugcaauuuauuuppcuaccpauugaacggagcpcgagcgcugccaggag\n", + "auugaacacuggcccagaacaccugcuccaacugaaaccuuauauccaccaucucauacaguauauucaacucaggugcugacuccaguuucag\n", + "auuccucagapcgaaagcgagucucgacaaggacggcgacggcucucuagaagccpuccag\n", + "acuapupcauuguguguggcuccccugugguagagaaggacaucggaugaacaugugaucuguguauccagcuccaacccaaaag\n", + "agacucgcgguuuuuaacuuauuccucagapcgaaagcgagucucgacaaggacggcgacggcucucuagaagccpuccag\n", + "cuaauucuuuucuaaaggapaugucgguuaauauuagauacguguuugacuuuaagaagaccggccuauuguga\n", + "acccggaggccgaccuuccgccgaggcggugcaggaaggaacpagapagaaguuugguapaaggaauupauuaagcg\n", + "gcgaagagagucggcgcccgcaacgcggagccpaagucgucgcuacucugguggaacucagaguugguucuggaggcggcggacgcggag\n", + "cggccugapcggacpcpcgcccpuugcpcucggugccgcuccgcacugcccggccggucucggccccggcgcc\n", + "cauuaugccaguacauacaggcuucuaaagccapauggugccagcccuuucauuucaaguacgacugaag\n", + "gagaaaauuuugagcagacaccauugagaagaacauucaaaucuaagguccuugcacgauauccugagaacguagaauggaaucccuuugaccaagaugcaguagga\n", + "gaguaggcgcgagcuaagcaggaggcggaggcggaggcggapcgapcpagcgccgccuggagcgcggcag\n", + "agacuaagaaagcacugugcaucaccuugacccupaccuuccucgupagcugcgcuggccgcuggccuacucuggaaguuc\n", + "ggaagauggcuggaaauuauuuuauauucugagagcacuuggcgapugagaugcacgauccuaacguguaccacacgagcucuuccggcugagg\n", + "auuuucgagugaaggacccggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "ggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "agacugcaagugaggaacuugauaauagaaguuuagaagagauuuugaacagcauuccuccucccccgccuccagca\n", + "aggcgccauuuucgagugaaggacccggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "uuuucgagugaaggacccggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "auuuuaggcgccauuuucgagugaaggacccggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "caaugaccaaugaagcuggagcuccucggcuuaugauaacucauauuguaaaccagaacuucaaauccuaugcupagaaaauucupaccuuuccauaag\n", + "pcccgagaccccgccucucggcgagcccgcccucuucugaagaggcguuucuggaccacugagccccgccucccacu\n", + "gcgccauuuucgagugaaggacccggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "cccggagccgaaacaccgguaggagcpaggupuacuacacaaccgucuccagccuuggucugaguggacuguccugcag\n", + "gagcagapagauacagaaaccgacapccaggcgcccgguggcuccgaagcpaagupacaag\n", + "ggcpagcagapagauacagaaaccgacapccaggcgcccgguggcuccgaagcpaagupacaag\n", + "cacggcgauccuggacugacggucacgacugccuacccucuaacccuguucugagcugccccuugcccacacaccccaaaccugugugcaggauccgccucc\n", + "agaugcaguagccgaaacugcgcggaggcacagaggccpagagcguucupuccgapuccagguapuugagccaccaucugaccgcaagcugcgucgugucgccgguucugcaggcacc\n", + "ucuucaaagccucugcaguaccagcugccuccaaggccuaacauagugaagugauapagacaggaccuupaguuupauaacugupaguuccugcaag\n", + "gcaggagcggugagaucacugccucacggcgauccuggacugacggucacgacugccuacccucuaacccuguucugagcugccccuugcccacacaccccaaaccugugugcaggauccgccucc\n", + "aggcucpuggucupccccuccgcugcagucugcccgaucccugccpccccgcccccugccucaagcacuucccgcucgaccugcgcacgucu\n", + "guuggauguggcagagccaggccccagccggugccgcucagacucccccgcugucgccgccguggucccagcc\n", + "pcpcggaggaapuuggauguggcagagccaggccccagccggugccgcucagacucccccgcugucgccgccguggucccagcc\n", + "gcuggagccagacauccugcuucpccaagcaagauuuccugaagacggacagugacucggaccuaca\n", + "gcucuacaaggaacapugapcapugaccggagccugcpagcgugaugugcuggaacpaguuucagcpucaccaucucupaggagaagugup\n", + "gugccguucacagaccugcuggaugcagccaagaguguggugcpcgcucuucauccpagaaguac\n", + "cucccgcupcpcggaggaapuuggauguggcagagccaggccccagccggugccgcucagacucccccgcugucgccgccguggucccagcc\n", + "ggucccaagcccugcagugcuacagcuuugagcacaccuacuuuggccccuuugaccucapcc\n", + "gauucuupuuccgcguguaguuucggaaggagacaucgaagcapcgaggcgcagapcguugcggacucaugccccagucggcagugcgg\n", + "aucgaagcapcgaggcgcagapcguugcggacucaugccccagucggcagugcpuaapupagaagcaaugaggcgaaugcgagcagccgaagaaggcgacaguguggcugg\n", + "aguaaggagaaccagccaggcagcacaucacagcpaggagcugucccagguggcccagcucagca\n", + "ccupcagagagugaggagcacccaagupccagaggaacguuguguguggcagcaaggagcccgcagag\n", + "agagagugaggagcacccaagupccagaggaacguuguguguggcagcaaggagcccgcagag\n", + "auggaggucucaacauguugcccagacuggucucgaacuccugagcucaagcaaucccccugccucggccucccaaaguacuuggauuacag\n", + "gaguguaaaguccagcagguggaaggacuaggccupacuccupuccccggcagugucuggaggc\n", + "gccaccccuggagaaacugccacaugaaaaacaccacaaucaaccuuauuguggcauugcgccguacauucgagaguuugag\n", + "gugaccagcaauggcagcaucpapacccgccagcggagacccagccucagaacccaccggcccagccggcacccaaugccuggcaggucaucaaaggugugcuguuuag\n", + "gaucuucaucaucupccaucagcaguugguuccgccgapccggccccucaggaccaggcpccccggaggagcuccacgcgucgccagccgcaaccuguuccccaaagacacuuua\n", + "aaacuaapucucucagcagauggccpuuuagagcuguacgaagacacacagcuaaugaaaaauuguggaauucucagagcccgugaagccuagcccacggaugcgag\n", + "gapcgcgcggaggacccgccgccgccggugugaggcggcccguccuggcucccuuguccpaagcccgcccag\n", + "gagccgccgccpucccgcucgucugccgccucagccucagccccaaccucagccgccgccguugcgcuugcucccpcgguccuggccugugccgccgccgcccccagcgucggagcc\n", + "gucugccgccucagccucagccccaaccucagccgccgccguugcgcuugcucccpcgguccuggccugugccgccgccgcccccagcgucggagcc\n", + "cgcgcagccccpcgccgcgcguccugcccggccugcggccccagcccuugcgccgcucguccgacccgcgaucguccaccagaccgugccucccggccgcccggccggcccgcgugc\n", + "gcagccccpcgccgcgcguccugcccggccugcggccccagcccuugcgccgcucguccgacccgcgaucguccaccagaccgugccucccggccgcccggccggcccgcgugc\n", + "agugccguagacapccggcccacaggcgugaggccagaguuaguggugagcuccugupucugcacugcaccccaacc\n", + "gcggccuucucggcuucuccagcuucgguaggagaggauccggcgccgaaucacugacuggcacagguguup\n", + "agcugcpuccucgcggccuucucggcuucuccagcuucgguaggagaggauccggcgccgaaucacugacuggcacagguguup\n", + "auagugucucacuuggucacccaggcuggagugcaguggcgcaaucuuagcucucuacagcgucgaucuuccuccupcucaagcaauucuccugcuucauccuccugaguaccuaggacuacag\n", + "gugugccugaaccagugccagccugcccugucugcagcaucggccugaupuggugacugaucccucapcuccggagcc\n", + "pagcgcpcugcggagaggcpccpccaagcggagccgagcgagcpagcgcggcguccpaggcggcggagacgcpcucggagg\n", + "agugagcuggccgcggccuuggcugagaggccuuaaccccgccpcggccgcgcccugcaugcgaguupccgcpcpuuggagccuacucpcgacugcg\n", + "cacapccucagaaaucgucagguggugacuggagcugagagguggccacucuguuaccaug\n", + "gaggccuagaaggagagccagagugcgaucagaaaaccagccgugcgcuggaagacaggaacagcgugacaagucaagaggagagaaaugaggaugaugaagac\n", + "auggugaugacgacccacaacucuccupuggccucgucucccuccagcaaggauguugcgucacccacgcag\n", + "auccuucccgucugccgagcccgucaugugaggcccccpagaaggugcuggugcucupapuguuccaggaggccccuugagcupcupagcupcuucagag\n", + "aucgaagccagacagcupcuccagaguucaugcuguuagccacuacccaugcucugcupauggucaggcccauccugccgugupaacagccugacag\n", + "gugcupcugcuggugupcgcugauugcggacaccccguaccaccuguauccggccuauggcupug\n", + "cagcgccuggagccacacapauccggagccupaaaagcggcgcpagccggcacccaccgcuggapcggcgacggcggccguagcgaccucpaggcaagcggagccgcc\n", + "agcgcugcpcccuccucggcucucggcpaccggcggugacaccggagcucgccgugcgcucccggccgcucucg\n", + "ccuccucuauuggcccaggaagcccacccagccccgccacgcagagcccagaaggaaagaaagccucaugccugagccgapagcacc\n", + "agcucuccuucuuucaggagucuagcuccucpaaaaguugcuuccccaaguuugcugaagucgucuccaagucucg\n", + "uccggaggcuuuguaccgccapcuggcggagcaacagagcccgupugcucuuauguaugcggaccggugcgcpcgcaagauaag\n", + "auaucuucauaauuaucugaaggucacagupagaacaaaauuaaaagaacugagaagacuuacaagagaaccuccuaagagucacccaaacaaucggcugagaaugagaagag\n", + "aaaacugugagagagagaauuuuuaaaaagcagcupccugagguuucucccccaguacccupucaccucagcccagagcuggcg\n", + "guucaagugauucuugugccucaggcucccaaguagcupacuacaguagcupccagcacacccag\n", + "aaggugguppucgccagcagguucccucuccccggccccagcucuggacgcucaccccagugcaacgcccugagugacggaaagag\n", + "gcgcccugaucugguuguggaaguggcccaucccaaaauaauccaugaaucupcacaaauccugcgccaugccaaucuccug\n", + "agauguccaaagagcagcggcugcccaggccuugugcagcpcagcgagcagcccapagccaggccccagacaccgcacucapcc\n", + "agcccupacagcagcucagcaacuccaccccaucuuccaggugaggcacaacauacagugaggacuaacpaaacauccuccgagaagauacaaucucaapupccugg\n", + "aauauagauccggcaagagcuuagcugugaucacuccuagcugcucagcaaaccacugagguuccupaaaaaaaaaaaaauaucucaagg\n", + "gauuugcagauuuacagaauggcugcacauuaauggaaagagaagcauaaaccuaucuucuuucauu\n", + "gauuugcagauuuacagaauggcugcacauuaauggaaagagaagcauaaaccuaucuucuuucauuauggapagguuuggcagauggagaaccugaucgaacuucg\n", + "gagaaguupucugacuagacgcuuacpccucggaccccggcgccgcggcgaccucggaggaaccggcuccuugcgucccgccucccupagcuccgcacgg\n", + "gaagaaaaupuguggaaauucuuggcuuaugaagaaggcuguugucacauugauuuaaaugaaaaacgg\n", + "ggcaagcacuuuaaccuuuuaagcccaaccagaugaguugccugcaguuuuggaggccuucagagcauuucacuagaccucugucugugucgguccagugucuuuagccaag\n", + "aacgcguuucupccgccguaagcccggccuapcagcuuugacucgagagccggcuauaggcgc\n", + "aaagaucapcagccuccugcuggcpucacaccccggaguguuggucaagagcggagguagapaag\n", + "gcauccggucgccgcpcguccgcggagcagcuuccccccgcgccucucuucgccucgccucpacccgcgguccccgcucuugcug\n", + "cuuuucpcgucccgaggccgcuccccaaccgacaaccaagaccccgcaggccacgcagcccuggagccgaggccccccgacggcggaggcgcccgcpuccccuacagccaag\n", + "agugcgcpuggcaucacugugcccggagccccugcgcgccccggccauccccaccccgapacccccuacggaggcgaccupcugag\n", + "ggacugacgccgagacgcgcgcpucagcggcgcpacgcpcgcupcgcpcupcgcag\n", + "gccccgaggccgcaggagcgcgcggagcggcgaugagcaggcggccgguggcccgcpcgcggagcccgugacagccucggccaggcpcgcugcg\n", + "gagcggacugacgccgagacgcgcgcpucagcggcgcpacgcpcgcupcgcpcupcgcag\n", + "gcugauagaacguuacggcuguaaaaagcucuagcauuuaucuagucaacucucccauuuugccgaugagaaaacaggcucagcaagguugcaucacccaggucacagaauuaacua\n", + "guuacuaaauggcuguuuguauuccaggcauaccagguucugaaugcuuaggauucgguuuuuaccuuuuguuuaaauaaccucuaaaaggagca\n", + "agacgcagcgccaggcccgcupcaggugucccguggaaaucgacggapcugccgupcg\n", + "paccgcuaugccgugcpcccgcpcugucccacucgapcuggagccggcaucgcgcaucgaguccgcuugauac\n", + "agcapcucccgcpcgucacuccggccaucguccccaccuccaccupccgcccggcaggcaggcg\n", + "guagaacpcguggcagaccucccugcaggcuuguugcupcgaacgagaaggaugccaugcugacacacugacgugcucugucuccuugcagacggaggcccpagcc\n", + "guugcuccgagcccucgccuggcagcucacucuggaucugcpuucugaggagccucpacccaccupugcaguugccuucapacagaccaucuuacag\n", + "gaguaaugugaggauucuugcuuuucuggaagcuaacacauagucagugccaaaguagugacagaagaaaucuugagaggaagcauuuuugucuuguacuugaaacagcugcupcccacc\n", + "gaauuggcpagaauagguuuggugguccgagauccgaggcaacgguggcuccucgagguccacggucccgg\n", + "gaagccaagaaggaggcgcgcuggaguuacuuccgcccgguucuccuucccgcagucugcagccggaguaag\n", + "ccugccagcuuccaagapcggcuucacugugcgaauaggugagaagccaagaaggaggcgcgcuggaguuacuuccgcccgguucuccuucccgcagucugcagccggaguaag\n", + "pcggcuucacugugcgaauaggugagaagccaagaaggaggcgcgcuggaguuacuuccgcccgguucuccuucccgcagucugcagccggaguaag\n", + "ggagaccaggagupapaggaaaggauggagccucaggcagccucgcaguccggccacagugugugaapauugaccagaaggag\n", + "gugagaagccaagaaggaggcgcgcuggaguuacuuccgcccgguucuccuucccgcagucugcagccggaguaag\n", + "ggaggaaaggauggagccucaggcagccucgcaguccggccacagugugugaapauugaccagaaggag\n", + "gaccgcggucacuguuaucuaaacgcaagugaagccgagucacaggacccggauguugucaguucgacg\n", + "ggapaggapaapaagaapagaccaggagupapaggaaaggauggagccucaggcagccucgcaguccggccacagugugugaapauugaccagaaggag\n", + "acaguggaagacupugagugaagcaggauggugccuupcuccagcgucuccccaaccccuccaugccaupuccccacgcag\n", + "pcugccuccuccgccuagagcgcugccgccgccgcuuucgcccpagccpccpcgccauc\n", + "gccccccucgucgcgccpccgccpccacpcugccuccuccgccuagagcgcugccgccgccgcuuucgcccpagccpccpcgccauc\n", + "ccgagugagaggaaggcggcggcggcggcggcggcggcgugaagucacugcugcucupuucpuuggcgacugaaggcg\n", + "guccgcggucgcgccagcuguuccccpcapucgccucuaggugcucaccuccgccacuucgcc\n", + "agugcaaucupcgaucgcuuccugguccucgccuccuccgcugucucccuggaguucuugcaagucggccagg\n", + "ugcccaccccgcaacugccggaaaguugcccaupuggacuucgcuguguagcpagapupagucgapugcuug\n", + "gcgaucgcuuccugguccucgccuccuccgcugucucccuggaguucuugcaagucggccaggaugucucag\n", + "gcucgcccgagcapuupcgaguggaccgcgccucuaaaggcgcuugccagugcaaucupcgaucgcuuccugguccucgccuccuccgcugucucccuggaguucuugcaagucggccagg\n", + "agguucugaaggaapagguucpuauccccuggauppcaucucuapcgccgccccgcuggc\n", + "ggccgccaacuuccagcugcagcggcgacuuucaguuucauuuccacggacccuccugccupccgcagccgccgccgcg\n", + "cugcagcggcgacuuucaguuucauuuccacggacccuccugccupccgcagccgccgccgcg\n", + "agacgcuuuaggaaagaguuaaugcgaagapapauaggacgaagaaaccgaapaaagcucag\n", + "ccuugacuucaucucagcuccagagcccgcccucucuuccugcagccupaacuucagccggcuggag\n", + "cccagacucuagcccccucccccuucccaacagccuugacuucaucucagcuccagagcccgcccucucuuccugcagccupaacuucagccggcuggag\n", + "ggcaaggugaacuaauggagupuggaggaguuggaagaaaucccagcgucagucaccpauagaauucccaaggaacccucuuuuuggagg\n", + "ccuugacuucaucucagcuccagagcccgcccucucuuccugcagccupaacuucagccggcuggaggucaguuccccuccccapaaggaggaagugapaagcugcgaag\n", + "gcuggaggapcpcpcccupucagucugagccuccggcaccggccgcgcagcuggaggcggcggagcggaag\n", + "ggucaucaaugcuggcaagagucggcacaaugaggaccaggcuugcugugaagugguguauguggaaggucggaggaguguuacaggaguaccuapagccuagccgaggccag\n", + "gcuucuccggcugcuaccuaccgcgccggacgcucpcugcggaacapcggcacuggcccgccacagcgacgccggcgccgapacaccgcaguaugaggcagag\n", + "auuaacgugacagugucagguggacccacagccaucccaccucccccucupagugcugagagugaggcagc\n", + "gcuuauaacccugcguccggccggcpcgcgaggaagcccccgccucgcguucccguguggucaccucccgccggaggaugcguggccag\n", + "gaaaugaggaccggccggacgaugcccugcagacugcucugaagagaaggapaccuucugcagagacuccgg\n", + "aaauagagcgaaggcugcucugugucagccccgucaccgccpcggcccgcgcggagucugapag\n", + "aagcgcpapaguguaaauagagcgaaggcugcucugugucagccccgucaccgccpcggcccgcgcggagucugapag\n", + "aguguaaauagagcgaaggcugcucugugucagccccgucaccgccpcggcccgcgcggagucugapag\n", + "ccggaggacugugauggagagaagagagaggacuuggaacagcugcagcagaagcaagucaaugaccauccuccagagcagugup\n", + "ppapcgagcccaagcgcpapaguguaaauagagcgaaggcugcucugugucagccccgucaccgccpcggcccgcgcggagucugapag\n", + "acacagugucugagaacauuuacauuauagauaaguaguacaugguggauaacuucuacuuuuaggaggacuacucucuucugacag\n", + "cgccgugaagaaccugguggacagcagcgucuacuuccgcagcguggapucugcucaaacaggccaucagcauccpaccauauga\n", + "aupcggcugguucugcugupagcugccgucuuucugcupaggcuggauggcuuupcaaggaggagcag\n", + "aaaaucgauggugaccucugcuuaugagucaugagugaucuguucguuguaggucccugaggaccucacucuccacuccuguuucaggc\n", + "puucgcggugcucgcugaggcggcgguggcuacggcuggaggagccpccgaggccgcggcggaggccgcggcugguacupapuggcapapacpaaggaag\n", + "gccpuucgcggugcucgcugaggcggcgguggcuacggcuggaggagccpccgaggccgcggcggaggccgcggcugguacupapuggcapapacpaaggaag\n", + "gcuggaggagccpccgaggccgcggcggaggccgcggcugguacupapuggcapapacpaaggaag\n", + "uagagaupuuucaccauguuggccaggauggucucaaucuucugaccucaugauccgcccaccucggccucccaaggugcupauuacag\n", + "ggcccgccccccgcaccgagcacucuuucgcccggccuccgguucucgccggcucucggacccgccuccgaagacguggagcgcugcggcggcug\n", + "acuggccuggcccgccccccgcaccgagcacucuuucgcccggccuccgguucucgccggcucucggacccgccuccgaagacguggagcgcugcggcggcug\n", + "gcagcugcccuagguacaaggapaggcucccacaauugcucucaccauuaacugccugccuguag\n", + "auccccuccaaggaagcgccgccccuuccuacggcuacpaaggaucguccaguggcugaggcuggacagagcacag\n", + "apcaccucggaccccccagcuguccgcagcagagcccggccccuugcagccacagagccccggccgcugcaggcuccaggagcuccgccuggucgccgcccugcguucccpccgccucccg\n", + "agaupuuucaccauguuggccaggauggucucaaucuucugaccucaugauccgcccaccucggccucccaaggugcupauuacag\n", + "gcacucuuucgcccggccuccgguucucgccggcucucggacccgccuccgaagacguggagcgcugcggcggcug\n", + "cuuucucuucuuggacuuuuaaauuguggcuaccuaaauugaguaucuggcaagaguaagauuaagcaguaauuuguuccaaagaagaaucuucuaccaag\n", + "gauguugguguaagccaccuccuaaggugguuguggagauuaggugacaugaugcagauaaaaccuaacacauaaagaagugcucgaagaacgcuggccacguau\n", + "auucugacagagaagauggaaauuacugcccuccugucaagcgagaaagaacauccucuuuaacccaguucccacccucacagucag\n", + "aggaaaggagcaguggcuuccgguugaagccaccaacgcugauccacggccaagcccccagcgcag\n", + "gucugccaagccagaagcccaaggagcagcagcggagcgugcuucgcccggcaguguuacaagcuccgcagccaaaggcgcugucccagacug\n", + "uccccagcaguggcaccaacpucagccucccagcagacugcacpcagugcccgcagcauccccugacacugcugcauggagaaguccuuccgaagcugccgaugag\n", + "gagaaagagccccagaaaaaugaguccagcaaugccucugaagaggaagccugugagaaaaaagaccccgccacacagcaagccuuuguauuupcagaacuugapacagaguuaag\n", + "gcagaaagcaggcgagccupccggcgcpccuugupapcuuaaggaaguaaaauggcggaccuggcgaacgaag\n", + "gguuaucagcuaacacccgcgagcaucuauaacauaggccaacugacgccauccuucaaaaacaacu\n", + "aaaggaugauaugaugaaccuagccuguuaauuucgucuucucaauuuuaaacuuugguugcuuaagacugaagcaauc\n", + "gucupaaaaaaagaauaaaaaguagugugagagcagaaaacgugauugaaacacgaccaaucuuucuucagugccaaapuggaaaag\n", + "gaaacacgaguccaagcugcagcuggcapauugcpugccggccgucugaguuuuuuuaaaacugcucgccgcgaagucugucugcagccaaa\n", + "aaacacgaguccaagcugcagcuggcapauugcpugccggccgucugaguuuuuuuaaaacugcucgccgcgaagucugucugcagccaaa\n", + "auacccggaaacacgaguccaagcugcagcuggcapauugcpugccggccgucugaguuuuuuuaaaacugcucgccgcgaagucugucugcagccaaa\n", + "gaguccaagcugcagcuggcapauugcpugccggccgucugaguuuuuuuaaaacugcucgccgcgaagucugucugcagccaaa\n", + "agucacacagcugccugguaggugacuggaggccuugaucgguucucauugagauuuugcugcugugaccccaacccugccucccuccccacccugcg\n", + "guaagcaaggcuugaggcuugcucucgccuucgucagcagcccuccucaaucuucuccaaacucccguccccaggccacacagauucuccucaagagagcccuauaaggacauugguaaa\n", + "gccapccagcpcuucaggapacgcgccugucccpcuccaggcuacpcaagaccacapcuccugaccuuuuucggcauac\n", + "aggupaggaaaccgccuggagccgccpaguggacgccgccgaggcccggagucgcgccugcag\n", + "acacagcaucuacucagcgupucaccucugugaacaucacugacugcaagccucccucaauuucug\n", + "gagugaacaaccaaggcgaupcuguaggauguugauacaucugapccagauggccaccauaucapaaagccaauguguuuugaaaaauaugcaaauguucaauaag\n", + "aggcgcgguucucgucuccucccggccggcggagcgaguggaggcugcagcccagcucgucucggcgcccgcgucgccgucgcgaagccccccgccccgcuuccgccgcgucgga\n", + "ggcggagcgaguggaggcugcagcccagcucgucucggcgcccgcgucgccgucgcgaagccccccgccccgcuuccgccgcgucggaaugagcucccggaaag\n", + "ggccggcggagcgaguggaggcugcagcccagcucgucucggcgcccgcgucgccgucgcgaagccccccgccccgcuuccgccgcgucgga\n", + "cgcuuggccccucccpccgcaguacuccucgugugacacggacaucauuaagccagcugagaaucgugcgguuacagcugcugcaguuucuuugcaga\n", + "cacuggcuucucuggacuuugcacaccuccaggagaagaacccagaaaauugaucaguucuaaaaaacc\n", + "agguuccuuggaucgaccggucagcccaguaacugacuacuuuucucccuucucuapuccuagcacagugucugauggagcuuuccuaccagacccugaaauucacgcaucaggcgcpaagcg\n", + "gguuuauugccguaggagcaguguuauuuuuuguugucauccuaccuaaauuuuccucuguuccagugcgag\n", + "gguccuagcacagugucugauggagcuuuccuaccagacccugaaauucacgcaucaggcgcpaagcg\n", + "guauaucgauacagcaaaugcuuuggagcaagaaacuaaacupuuacgacgguuugaaguuugugacaacauugaucuugaaacuauuuug\n", + "ccuuuacccuaauccapaggagaagacpacgucaaaauauagucuupuauagaagcauupucgcaaagaccugaacaacggcugaaaucaaggacaaauauuaug\n", + "aagugcagcugcuucaggcugagguggcagauagugagcgcugguggcggaguuaaagucaaagcaggagaguaauu\n", + "gucupugacuuggcuggcpaucaagugcagcugcuucaggcugagguggcagauagugagcgcugguggcggaguuaaagucaaagcaggagaguaauu\n", + "acuugaguggccggaacccuugagaccagaggcuuaccaugcugcucccuaggapccaggaacugcugacgugaccacuggacaguuauucgugucucuuacaauuaccaaacaga\n", + "agacuugaguggccggaacccuugagaccagaggcuuaccaugcugcucccuaggapccaggaacugcugacgugaccacuggacaguuauucgugucucuuacaauuaccaaacaga\n", + "cgcgccgaaugugaccgccucccgcucccucacccgccgcpaggaggagcpcgagaagcugccgccgaacgacaggacguupcggccuggcucccucag\n", + "ccgccgcpaggaggagcpcgagaagcugccgccgaacgacaggacguupcggccuggcucccucag\n", + "acpucuugguauguuucccagagcugguguuaaacuccupcucaaguaguccucccaucucagccuuccagaguccupauuugcag\n", + "aaaupucuugcuguguugaccaggcuggucuugaacucuuggccucaagcuguccucccaucupccucccaaagugcupauuacag\n", + "agaguaggcugccacaagguugaaaucugucaccucaucuuaggaaccgccucucccaugaaugcacggaucuuaacauaugugauggugugaugaaacccug\n", + "aguuguaguccggccgugguupagccgcggcucaugcgcggugcacagaggcuuguuucacaucuguaacaacag\n", + "gaggaggcccagccucgugaugaggaauagcaaggagagaauucagcuccaguucaaaagccuacaaaaucugagacugucauugcuuuuauaag\n", + "guaguccggccgugguupagccgcggcucaugcgcggugcacagaggcuuguuucacaucuguaacaacag\n", + "ggaapccgcgccgccgcugcupaguuguaguccggccgugguupagccgcggcucaugcgcggugcacagaggcuuguuucacaucuguaacaacag\n", + "ugccggcgucuccgagcccgcgcucccagcugcagagcgccuggcuugccucccgcgcggucaccgccggcccgccgcccccgcucccgcccgcgcccggagccccugccucgcgcccg\n", + "gcagagcgccuggcuugccucccgcgcggucaccgccggcccgccgcccccgcucccgcccgcgcccggagccccugccucgcgcccg\n", + "aaaauuguacaagcuggagauaaggaccuugaupcagcuagacuuugaagaauuuguccauuaucuccaagaucaugagaagaagcugaggcugguguuuaagaguuuggacaaaaagaaugaug\n", + "ccpcgcapcuggacuggcggagcaggupuccgcggccgccggagcguuccggucggcgucupcaucucggccucggcagaaagcgcgacggcccugcugcgcpcccgcggcg\n", + "cugugcucuugcggagacgcgcgcgucpuuuaacgcguuucupccgccguaagcccggccuapcagcuuugacucgagagccggcuauaggcgc\n", + "aauuuagauuugcuuuucccagcpaapaccggaucugaaaggagaugcucucugauuccuaaaapupcuggcupcgcgguggcgc\n", + "uugcggagacgcgcgcgucpuuuaacgcguuucupccgccguaagcccggccuapcagcuuugacucgagagccggcuauaggcgc\n", + "guuuaacgcguuucupccgccguaagcccggccuapcagcuuugacucgagagccggcuauaggcgc\n", + "guucccuacuuccugugcucuugcggagacgcgcgcgucpuuuaacgcguuucupccgccguaagcccggccuapcagcuuugacucgagagccggcuauaggcgc\n", + "agauuugcuuuucccagcpaapaccggaucugaaaggagaugcucucugauuccuaaaapupcuggcupcgcgguggcgc\n", + "gaggaacuccccaccuccagccgcagcagcacucucugccagccucccucugaacaggacaccgagccaguuaugucuucuuacuuagcgaugugauucucuggccuucuca\n", + "ggcccgguggcccuggcggcgcggagacuggcgcagcgcpagcacgcagcgccgcpagcccpccag\n", + "pcugucuacagcggcccpagaggcugugguggccccgagcgcgaguguguaggugacaggacagcggccaggcccgccccuccccucg\n", + "cgcgcccgcgcccuccucguacccgugcgcccccggagaccgaucccgccccgcggcccaggccpccug\n", + "gcucpaccacugguagcggcagcagcucgcgcccgcgcccuccucguacccgugcgcccccggagaccgaucccgccccgcggcccaggccpccug\n", + "aacccagcpugccgcuucuccacccgaggcuuccaccuccaacgagccauguuccaggcugcaggagccgcccaggccacccccucucau\n", + "ggccucccggagcugccccugcccugaccgccccucucccucaggacgccaaaggcggcggcagcagcacggugcagcgcuccaag\n", + "gaccacugguagcggcagcagcucgcgcccgcgcccuccucguacccgugcgcccccggagaccgaucccgccccgcggcccaggccpccug\n", + "cggcagcagcucgcgcccgcgcccuccucguacccgugcgcccccggagaccgaucccgccccgcggcccaggccpccug\n", + "gcupccpcuggcpcccucccgacugacuuccccuugcagaacccagcpugccgcuucuccacccgaggcuuccaccuccaacgagcc\n", + "gagagccccpagagugaapccpaggacaaggcgccccpcccaaagcgcgccggcucccgcucpcggccgcggac\n", + "gauugacuucuaaagacucuugguaugugaggaagaaaccuggaagaggaagaggaaagcaaaggagucap\n", + "gauugacuucuaaagacucuugguaugugaggaagaaaccuggaagaggaagaggaaagcaaaggagucapauggcucuuccucag\n", + "aagacaacgucacuagcaguuucuggagcuacuugccaaggcugagugugagcugagccugccccaccaccaag\n", + "cccucuauuggagauucugccuccccupacagauggcuucuugagcacacucccacgaupuggcugcucugg\n", + "uacaucucauccacuucuucaucugugaagcugucacccaugguggugagcagcuccuggaggugguccucaugaaugaaaccugaggauuccucguugaagcag\n", + "gaagcaguaccuugaagagaaauuggagapagucaauuccuaggauagcagagagauggacaacagacagaau\n", + "aggucaccccagcucugaucuuugccaucacaguugcuacaaucggcucuuuccaguuuggcuacaacacupucauca\n", + "ggcpcgcagcggcccpaggugcgugguugagcgaagccgcpcccaaccgcagucgcpucupag\n", + "gcagcggcccpaggugcgugguugagcgaagccgcpcccaaccgcagucgcpucupag\n", + "gucaccccagcucugaucuuugccaucacaguugcuacaaucggcucuuuccaguuuggcuacaacacupucauca\n", + "guuagupucccaacggcugcaggcpccggcpcgcagcggcccpaggugcgugguugagcgaagccgcpcccaaccgcagucgcpucupag\n", + "guguucuauuacucaacaggaaucuucaaggaugcagguguucaacagcccaucuaugccaccaucagcgcpugugguuaauacuaucuucacuuuacuuucu\n", + "gugcgccgcgccgucccugcggccppugcpaaugaggaccugagcupuagagguggccgagcuagaguagag\n", + "agcagccgccpcuggaccgugcggugcgcaggugagaagccpapccggacaaccccgaccgcgagccggaccccugcucugaccgcag\n", + "caagcccgcagcucgcapagauccagcuccguccugccugcagcagcacaacccugcacacccacc\n", + "gacagccgcugcggcagcacucgagccagcucaagcccgcagcucgcapagauccagcuccguccugccugcagcagcacaacccugcacacccacc\n", + "guuguuccggcugccuuucacugapacccgccaguuucuaacucaguggcguuugcccugauucccpccuggcuuucagcguagcaauucugccggcgaagaag\n", + "ggugcgcagaagupcauuaacagcagccgcgugucupucuuagauuuggcccagcuguguugagcuuuucauggauuaucuuacguagauaagacacugcaaca\n", + "acugapacccgccaguuucuaacucaguggcguuugcccugauucccpccuggcuuucagcguagcaauucugccggcgaagaag\n", + "caguuucuaacucaguggcguuugcccugauucccpccuggcuuucagcguagcaauucugccggcgaagaag\n", + "agcgcccgcagcccgcpcuupauucaaacugcugcuccuccggcuggcpaucagcgcuggcgcggcugcggccgcugcugccuacgcgcc\n", + "gauucaaacugcugcuccuccggcuggcpaucagcgcuggcgcggcugcggccgcugcugccuacgcgcc\n", + "agaagccagagcagacagcaauuucpacauugcagagcuguaguagaucuguacuggucugcagacagacaauaauuugcacu\n", + "aagaccaggaagacguucugugaggaagacauagguggaaauacggaaagcagaaaagacaacuucpuggccpagauaacagaag\n", + "gcagagccggcgccggaggagacgcacgcagcugacuuugucuucuccgcacgacuguuacagaggucuccagagccuucucucuccug\n", + "cuugcagagccggcgccggaggagacgcacgcagcugacuuugucuucuccgcacgacuguuacagaggucuccagagccuucucucuccug\n", + "uuggaggcuccpcccgagugauggcugcgagcucagcaaccccagcgccagcagagucagcugugccpcag\n", + "cuppagccpugcaagapcaggcuggaucaggccpcagaagcggaccpcuccgagugucaacgagagcuag\n", + "ggagaapuuuaagccgaagcugcauuucupagaccuagugaaucuauagcuucauacupag\n", + "gupcuggccaggugagagcugcuggcaggupccuggcuguggaggauagcccagcucupagcaccgcpupagcccucccugacguggugccggapacacuacucaac\n", + "ggauccccuuaucaaagcugaupucgcupaccccccagccuuuugcuagagccugcacggcugugcgagcuugaaaagaaac\n", + "guuagucapcugaggaggagaggagaapuuuaagccgaagcugcauuucupagaccuagugaaucuauagcuucauacupag\n", + "agcuccggccgccgcgccgccuggcuuucguauucguuguucucggcpcugupccuccgcgccgcggccguuaguc\n", + "aguacagcuccggccgccgcgccgccuggcuuucguauucguuguucucggcpcugupccuccgcgccgcggccguuaguc\n", + "guacagcuccggccgccgcgccgccuggcuuucguauucguuguucucggcpcugupccuccgcgccgcggccguuaguc\n", + "auuguguaucuauagaaaccapcacapagcaugcagacagcccagaguuacaaagccaugagguggapcuaggaucugaacccag\n", + "ggaaucuggagacapaccagugaagaggauaguacagcugucuaugcaagguggcauggcccaaggcagaagagagaaggagagaacuguuuccugguuguupcauagag\n", + "gcucccggcccaugcggcccccgcpcucccggccccggcuucagaacucagcccugcaccugagcgcpcccggcpcguggcggcggcg\n", + "gagccaccgccgcgccgccguuupccpaagcgauguaguagcugccaggcugucccccgcccugcccggcccgagccccgcpccgccgccgccaccgccgcc\n", + "guaguagcugccaggcugucccccgcccugcccggcccgagccccgcpccgccgccgccaccgccgcc\n", + "auugagagacgccuggacacggugcggucaauaugccaccauucccauaagcgcuugguggcauguuuccapccagcauggcaccgaugccgagaggagacac\n", + "agcgauguaguagcugccaggcugucccccgcccugcccggcccgagccccgcpccgccgccgccaccgccgcc\n", + "aaggaagaggcccagcagaapacucgcugagccaccccccgccccacuccauguuggcugugcucucag\n", + "auuuccupapagapugcgaccaagcccuggcuccagcucuagcpuaucugcccacc\n", + "aucuuuccuuggugccaaccaugccugcauaucapcagcauucuaugaucccauggcucucacaucgacagaccacaacacuaag\n", + "caaccaugccugcauaucapcagcauucuaugaucccauggcucucacaucgacagaccacaacacuaag\n", + "aucuuggagacaucucagcuuuaaugaggacuuuccaacauuccagacugccguccugcaaugaagcucugagucacggucugugaggcuaag\n", + "cuuuaggcccuuucaagcuaauuggaacagaagagagcuaauuaacuauaaaccagaaugaagcuuuugucuaauaaguuuuuauuag\n", + "gcaaaacucacagupaagagcauaaucagaaaaacacaugapcaggauauucucaucuuuucaaauucugcauguguaucuauuag\n", + "gcucuapcuggacucapcgguuugaaagaucggcgcgcaccgcaggagcaacgguugguccugcggcugug\n", + "aauuucuagaauuuggaaucgagugcauuuucugacauuugaguacaguacccapuucuuggagaagaaccuggucccagaggagcuugacugaccauaaaa\n", + "aaacggacgccguucucucccgcggaauucagguuuacggcccugcpuucucagaggcaaguucagaccguguuguuuucuuuucacggauccugcccuuucuucccgaaaagaagacagccuugg\n", + "uugaagcaucuacguuauccaugaagugucgcgagagaaacggacgccguucucucccgcggaauucagguuuacggcccugcpuucucagag\n", + "aauuuggaaucgagugcauuuucugacauuugaguacaguacccapuucuuggagaagaaccuggucccagaggagcuugacugaccauaaaa\n", + "ucuucacgcgccgcauucguagcccgagaguccgcgccgcpaggcuuggaggcaagcgcugcccgcgagcugagccgccggaggaggagccgcpcaacgag\n", + "gcgcucpccuccgcucuucacgcgccgcauucguagcccgagaguccgcgccgcpaggcuuggaggcaagcgcugcccgcgagcugagccgccggaggaggagccgcpcaacgag\n", + "gccgccccgcgagccuccagccccucgccuguugccgcgcgagucccpcccggagcgcuaggagcgcgcg\n", + "cpaccccgccpacccgapcgcggcpapaacpagucagcccgcgcugugucucpccggccggcag\n", + "cuuuaccuccagucaacucuugauuaugguaauaguuauaucucauuupcucaagaggauccuaaaacaaaa\n", + "guuucccaguaauguuaaugaacaaaagguuaucugccuagcgaguuccuuuuccaagcguuugagacaauucgacaagauuaugagacugcgaacuggagucuuuuaucuuuaaaag\n", + "cagccgaggaaccggacgcggacaccgccgccccgcgagccuccagccccucgccuguugccgcgcgagucccpcccggagcgcuaggagcgcgcg\n", + "ggcacugcgapcgugugacacaggccgugacacugcgcggccucgcpcapacccggugacuguauaau\n", + "gcugccccccgguguggaccccacccaaguuuccuccucccuguccccugapcacacugaccguggaggccccc\n", + "uauuuuuauuuacauguuuuguucaacuaggcaacuuaaaauaguuuugcuuuauguauaaaauauuguaaugguagagua\n", + "acccccpucgccaggcgcugucucugccgcggaguuggaaacggcacugcugagugagguugapugucucg\n", + "puacccacuccaaggaaaagcuuuccacguugacagacaacugcugcguuuugagacucuuucuuugacuug\n", + "gagcgaggaggcggcgcggccgagaaggaggacgaggccgcpugcggcggcccapagcuccucccccgucccuucgcccccuccgcucggcuccgcpccccpcpcp\n", + "ggupaucuacccccpucgccaggcgcugucucugccgcggaguuggaaacggcacugcugagugagguugapugucucg\n", + "gcugcggccccgcccccuggccgcguggcugcgcguccuggcuguugccgauaaaguuguuugacgccggcccggcggcpucacgugagcggaaa\n", + "acgugagcggaaaauggcggccccggcaggcggcggaggcuccgcggugucggugcuggccccgaacggccggcgccacacggugaaggugacgccgagcaccgugcugcuucag\n", + "guuucagaggagcgugcucgaccuuucucuccaguggagauuugccaaccugcccaacaaugccaagcuggag\n", + "cuguccugaggcuguggcccucapacccuuacacccuuuggcuuuugugcupccauugacugugcccucgcuagaggcagcuucuccaccccuuccucacag\n", + "gugacpugaagcugcccugcpcacgacgcugcagucgcupccugaccpcagcgccaccaucag\n", + "gcugcgagucaggapcagcuccuucuggaagccuggagcuggugaggccaggugcuuucccugcugcgguggcuggcg\n", + "gugaaaaaaaaaaaagaucccugaguaauugcaaaugcupacaguuuaccacuccapugaagaguccauaccaac\n", + "ggagaapucpagauauuuccguuaggacaucgcugaaacacagacupaucaaacugugcucauaguccuaagg\n", + "aucuccagcacccugccgguggcacuacugagagacgaggugccapugguuccugaaagugccugagccccaacuuaucagcaaggagcucauc\n", + "agagcagcguguagcaguucccuguggaggauuaacacaguggcugaacaccpaaggaacuggcacuuggaguccggacaucugaaacuug\n", + "uapcuggagaapucpagauauuuccguuaggacaucgcugaaacacagacupaucaaacugugcucauaguccuaagg\n", + "aaggagcuguuuauggagccgccuccccguggacuggccuuaagugucccuaucuauucucccuacgaccaaagcuccugcggccuucccucuapuugucacccuagcuggaccug\n", + "aaugcuuauucauucuucaagauucagcucaaaauucacuuuucucugugaauucguaugucacuccaucuaccacacagccucucucagcuuccucag\n", + "aaaacagccauaugaaagccaagaagagaguccucaccaggcaccuugaacuugcacuucccagacuccagaaau\n", + "aguccupuuguacccggcgcagcupagcggcugcuuccuccpucguaucuccgcccggc\n", + "agugucuagcpagcuccgcguguagcuacgccggccgccuggcuuugagacaacgugauucuccgcagcuggucgccuacccgugauguucugcccacgucgagaccugagcugaa\n", + "guguagcuacgccggccgccuggcuuugagacaacgugauucuccgcagcuggucgccuacccgugauguucugcccacgucgagaccugagcugaa\n", + "agauacuguggugcugagacgguuaucagacuaguagcaaagacauucauuuuguagucauuauagcaaaggcauuug\n", + "guuuuuaaaacucauuuggacacccaccucaauauaugcugugcaauuagaauaauccagaagacugaaagagua\n", + "gccgagcccagcuccccgcggcggccgcuagcccccggccccgagccaccacuccgaccuagcggccgccgcccccggugcpaugaggagauccgcggccgccacupcccc\n", + "cggcucaguacugcgcgcgcccugcggcuguccpccgcgcgguggccaaagcacagcgcpagagucugcg\n", + "pagcgagagcgccagagagagaagaucppcugaaauccaucuucauccuaccgcuccgccc\n", + "agupccgccauguugucggagugaaagguaapagcgagagcgccagagagagaagaucppcugaaauccaucuucauccuaccgcuccgccc\n", + "guugucggagugaaagguaapagcgagagcgccagagagagaagaucppcugaaauccaucuucauccuaccgcuccgccc\n", + "gugaaagguaapagcgagagcgccagagagagaagaucppcugaaauccaucuucauccuaccgcuccgccc\n", + "pagcgagagcgccagagagagaagaucppcugaaauccaucuucauccuaccgcuccgccc\n", + "ggagugaaagguaapagcgagagcgccagagagagaagaucppcugaaauccaucuucauccuaccgcuccgccc\n", + "agagcgcpuagaucuupccpcagcagcagucgcagagcggcgcggcggcgguggcggcagcaggcagcaggc\n", + "aaccacgccguuccucccccuucuggaacgcggagccgcugagcpccgacggccauuuugugaagcggcgaaggag\n", + "cggcgaaggaggugguggcugcguupcuccpaagccguucpcupcugucggccgcpcggaggcacucgcgcp\n", + "ggapcgcgguaccpapaacpcpucpcuucgaggucagcugguccgcapaagccuuuggcuuccccaccggca\n", + "auuccuggucagguccggacagapacaacpugcuagagaaggagagcpcpugaggaapcugapcugugccggcc\n", + "gucuucugcucagccgcuuuacccacguggagaacgccapagcugugapuguguggucucguuccugucgucuggaauauuuuuccucuacugagauucaucug\n", + "puuccuucaggagucacaaguacuauupuuggaaaaucupagaauaauaguuuacuuacugaugaaacugcuguauuaucauucauuaagcuggagcagaucacaguuugagg\n", + "guacuaccauuaaagauaccuucuucucagcaaaucuaugauaaaaaauauaaguaacagaagaagaaauaacuguuauuugucaagugacaagcuuuuaaugucaga\n", + "ccugucccaagccagaugauuuaccauuuuccacaguggucccguuaaaaacauucuaugagccaggagaagagauuacguauuccugcaagccpcuaugugucccgaggap\n", + "ggagucucgcuuugucacucaggcuggagugaaguggcaugaucuugguucacugcaaccacugccucccagguucaagcaauccuccugccucagccuccggaguagcupauuacag\n", + "gugcgagaapcguaacugauuuggaaaccagaggaaaggcgcuguuuucaccgaauuagaaucgcpaaaauagagaagaguuuguuugaaggucucgcgagaucga\n", + "agacacagcaacuauucagcugcgapacpagagguggugagcacucucgcgagauuugaaggagcggcggaggccagapaggagag\n", + "ccuucccgcuuccugugguuguggccgcugugcugupagcggccccgacccpcucauucgagcg\n", + "ggcgucuccauggcgaccgcguuggcupuggccuccauugucpcugcugcucucagcggcpcucgccagcgcuucagupcpacgcggcag\n", + "cggcgucuccauggcgaccgcguuggcupuggccuccauugucpcugcugcucucagcggcpcucgccagcgcuucagupcpacgcggcag\n", + "puaggcggcucuuugucgaagcuagaggaccggcaggcggcagcagcaacuacggcggcggcggcag\n", + "acaugcugcccaggcugcgcpugauuggcuuggcuggaccugaaugaugcggcugugauugcugaauugucupcag\n", + "gagaagaggucagugcuggucaucuuguggauccuggccuuucuggcpaacacccucuaugugcuuuauacauucagcucccagcagcuguacaacag\n", + "pcupccuupcugcuggaugaaugagacccagccucugcccupagugcagagacucaagacagauaugaccacgugaagagacaacuguaaaacaagug\n", + "gucuccuccpcupcugagcaagcccucggagugaccgupugacagcggcuccapacucuupcgcagupaaagugccggaccacc\n", + "ucagagagauagagcggucucucccgaaagcaagauuccguuugaaaacucuccuagcgcggugcccgcgccgugacuccgcag\n", + "aaccagcagaaccuuuupauuuugccuuccucccuccugcaucugagcuuugucuccaccagcaac\n", + "augcacuugagcapaagaaauccacaaggacucaccagucuccuggucugcagagaagacagaaucaac\n", + "gcggccgucccpccgugacuccuccuuucccccgccccgccuccguucggagagccggcpcpcgccucucggccag\n", + "pccgugacuccuccuuucccccgccccgccuccguucggagagccggcpcpcgccucucggccag\n", + "acagagcccugcgupugagaagcagacugcggaacaggauuuggcuugauggccaccagcucuuccacaaaaag\n", + "ggcpucaugaggaggcuguagccaaggacgaggugugugcggcuguugccuggacguuuguccaauccacguugacauuugapaucacagcgugug\n", + "aaaaugaacucagaggagaauuggugaauuccuauccagupcaucuucaaacccuggucgacggcggaagaauaucagguccugagaucacccacccggcgcggcaacagugcag\n", + "ccuuucagguugcccaagagcaaagaaaagugguaucaggauagcacagagcaaagaagauaaagaagaucaagaacccaucag\n", + "agcggaagcgccuggaagcggaagcuggacagacgaggagaggccuupugugacaucaacggaaccugapaagcaaaacucagcaaggacgcacccggucugcuggacupcuuugg\n", + "aaacacagapaacugugaccagcacgugcgauggucucuccacggcagacagagcccugcgupugagaagcagacugcggaacaggauuuggcuugauggccaccagcucuuccacaaaaag\n", + "uuaaugaccagccacggcgucccugcugugagcucuggccgcugccuuccapcucccgagccacacgcupugcuggcugapaac\n", + "ugucagcugcugcuggaaguggccuggccucuauuuaucuuccugauccugaucucuguucggcugagcuacccacccuaugaacaacaugaau\n", + "agaggcugagcucccpacccggagcggaucgacuggcpcgccgcgccgaggcaccaccpcgccgaguuccuggcggcucgcacg\n", + "ggaaaacuuuucugucugugauaugaaacagaaaggaaaaacggcpcuuacupaaaugcagugucgaaag\n", + "aguccgaaagauccggaagagcuggucaaucucagaaucuccapaauapcccggcgagucaccugaaa\n", + "cuuucugguaaggagaggagguuacpaacgacgcgcugcuuucaugcccuuucuuguucuaccuucaucggccgag\n", + "gaggaagagccgcpcccggcggcugaggccaccccggcggcggcuggagagcgaggaggagcpuggccccgcgcugcgcccgcccucgccucaccuggcgcag\n", + "accccggcggcggcuggagagcgaggaggagcpuggccccgcgcugcgcccgcccucgccucaccuggcgcag\n", + "uccucucagauuugugugcuucuucccuucccacauucuauacugcccagcgccupauuccagaucugcguuugaauccaggaaapag\n", + "agugcgcugcgccugccuccpaggagccgcauccacacacccugcgcugcccuguccugcgcgaguggagcucugaagaagcucugagcggaguuguguucuuccccag\n", + "acacccugcgcugcccuguccugcgcgaguggagcucugaagaagcucugagcggaguuguguucuuccccag\n", + "agucucgugcugucacccaggcuggaguauaguggcacaaucucggcucacugcaaccucugccuccupuucaagcgauucuccugccucagccuccagaguagcupauuacag\n", + "gaucucucaccccgucacucapuggcgcaaucacgacucauuggcucacugcagccuagaccucccagcuggagcaauucuccugccucagccuucugaguagcupacuacag\n", + "uuacagaaauaugacacugacccuuugcauuuacaaguugguucuaaagaguggugagucagaagagacgucaggcagcaagcgacuupcc\n", + "gupaupagauacuguuguggucaccucuggaaaauacauucugcuacucuuaaaaacuagugacgcucauacaaaucaacagaaagagcuucugaaggaagacuuuaaagcugcuucu\n", + "gucuggcgguuugaacgagacgaagacggaaccggagccgguugcpcaguggacgcgguucugccgagagccg\n", + "guagacgcacccucugaagauggugacucccuccugagaagcuggaccccuugguaaaagacaaggccuucuccaag\n", + "acuuaaaacacacuucacgcagucacagaaagagcucauagaccagacugcpcuucaaagccuucuaucuuauuuaaucaucuguaaauaguuuaaag\n", + "gaaacauuuaccagauguguggcuugaguguccauucccgcaacaaaaacgcucugcaguaaagcuccgagauggcuguguuuguguuggacugcucuagaug\n", + "acccucugaagauggugacucccuccugagaagcuggaccccuugguaaaagacaaggccuucuccaag\n", + "aauguucuuuuggccacugugaagccucaggaapcucggauugcucaaggacccaupagagaggaggcuuugacupcugccugccugugaggucucuggacuagag\n", + "guccaacgcaguccagcugacaaggauggaauacgccaugaagucccuuagccuucucuaccccaagucccucuccag\n", + "agugugaccagagccapaugagaaacauggagugagupacupcaggagcagcagcugcuga\n", + "agucuuuggucpuuucggcggcuucagugcucpaggaggcagugacggccggugagauuggaaguggcggcggcggcaggcggcagapag\n", + "ucpuuucggcggcuucagugcucpaggaggcagugacggccggugagauuggaaguggcggcggcggcaggcggcagapag\n", + "cggcuucagugcucpaggaggcagugacggccggugagauuggaaguggcggcggcggcaggcggcagapag\n", + "cpuuucggcggcuucagugcucpaggaggcagugacggccggugagauuggaaguggcggcggcggcaggcggcagapag\n", + "cucaacpucucggcugagccaccpugagcucaccgcccagcccaaaccaggagauugcgapagcgaugcggugcagcgcg\n", + "uguucuupaagaucccgacuaagccauuuuccaguggcaccucuuccaucaugaguuccugaggcaguccgaupcuacuuuauuccagaacaaucaca\n", + "caccgcucgacccpcgcagcgcgcaggcgguggcgaagagacgccgagcpccgagugcggccgagcaaagccggagccggagcpccgcaggagacpccpuccggacpccgag\n", + "accgcucgacccpcgcagcgcgcaggcgguggcgaagagacgccgagcpccgagugcggccgagcaaagccggagccggagcpccgcaggagacpccpuccggacpccgag\n", + "gagcpccgagugcggccgagcaaagccggagccggagcpccgcaggagacpccpuccggacpccgag\n", + "gcagcgcgcaggcgguggcgaagagacgccgagcpccgagugcggccgagcaaagccggagccggagcpccgcaggagacpccpuccggacpccgag\n", + "aaaacaaaagaagaccugcuucaaaguagaaugaaguaggugcugaaauagagcuaccaggaggaggcapcagg\n", + "gcagagcacgcagaguccuucugucgguugguccuggagcggcgcagccggagupccgugag\n", + "cacgaguacacgagacaggauugagaaaggagagauucaaauugugacuucagauucaaaggcaauuaaaggaauuaaac\n", + "aguccucccaaaguacuuguguccpugguggacuggauuagcugcggagcccuggaagcugccuguccuucucccugugcuuaaccagag\n", + "accccccccucccuguccgguccpuucgcuugccucgucagcguccgcguuuuucccggccccccccaacccccccggacaggacccccuugagcuugucccucagcugccacc\n", + "ggcucacucggugccgcugccuapcuguagaggucgcgccgcuccugcupccugcccacgccaaggaccugccucugucgccuccucuucuauugcccag\n", + "guaggcggugcuugaacuuapcugcuuguggcupcacucgcgcagaggccggcccgacgagcc\n", + "agccagacuggauuaggaugccucgcgacuapuccagagacagaggccuccaguucccaggcacuucpaagaggaggcugaa\n", + "agacuggauuaggaugccucgcgacuapuccagagacagaggccuccaguucccaggcacuucpaagaggaggcugaa\n", + "gagccagacuggauuaggaugccucgcgacuapuccagagacagaggccuccaguucccaggcacuucpaagaggaggcugaa\n", + "auugcugacuuupcuuuccaaccuguaccagaaggauaaguucuuacaaacguuuugupaguccacucuaugcaucuccugagauugucaaupagaccuuaccgapccagag\n", + "gcauucucuguagcauaagugagcuuguuggcuaaacpuguuuguguauugcuguuuucccucugcaguguuugagaacaaagauaagauugugaucauc\n", + "ucugcugagcucagccucucuugguggaugupcpcgcucgaguaggacccgacgccaapapcugaccugugcuugguccaccccag\n", + "uuucccacuucugacucugugccugcuguucccugcupaagaaggaaagccagugaugcuggcuugaggcuguagupaggcccagcggauugugagaagccag\n", + "auaugacugaggcgcccaupuggcpcggcuguaggagcapccuagcaagcgcccagcggagcgaccccugccuggccguggcuagc\n", + "uaugacugaggcgcccaupuggcpcggcuguaggagcapccuagcaagcgcccagcggagcgaccccugccuggccguggcuagc\n", + "guuccacuuccaaacaugaguuccaggccgagacaaagaagcuuuuggacauuguugcccggucccuguacucagaaaaagag\n", + "guguuuauacpagcugaucuccaaugccagcgaugccuuggaaaaacugcgucacaaacuggugucugacggccaagcacugccagaa\n", + "gccucccucgcuccacgcgcgcccggacucggcggccaggcuugcgcgcgguuccccucccggug\n", + "gcagccaccucucaacaacccaugaagugucuggagcuccacccucugcucaagaggaacggcacaugacccaggccuaugccaaucagcauuucacauuccucaugguugguucaaag\n", + "gaaacpauuaugaagguuauuuaugcucccugcugcucccugcagaaucccgaagcucuguuuuugcacugapccuuua\n", + "cuccccagucccgguccgcgaccacccggagcccgcuccgccggccuugcgcggcgcgcccapaaggcauuuccagcccgcccacccag\n", + "gaaacpauuaugaagguuauuuaugcucccugcugcucccugcagaaucccgaagcucuguuuuugcacugapccuuuaauguggaacuggcucaggcug\n", + "gauuacucuugcugcugucuugcuguacuguaugccacupaucugaacacuaaacauugcuaagaaacccacccaccaccaggauauuuggaaguaacuucacauauggaaaa\n", + "cgccuggccaagugcggcucugcucuccccagucccgguccgcgaccacccggagcccgcuccgccggccuugcgcggcgcgcccapaaggcauuuccagcccgcccacccag\n", + "guggagguupagaaaagagauaaugguauggugagaugucuacugaacugcuccugccaaggccccuccccauguacucucaacgaaaguugcag\n", + "ccaccucucaacaacccaugaagugucuggagcuccacccucugcucaagaggaacggcacaugacccaggccuaugccaaucagcauuucacauuccucaugguugguucaaag\n", + "agugaccucgcpupcpccupuccguuccccaacuuccucggcgcuccggacucccaagucuccgccggacccuccuuuggauauuccucgugucuccgauucugag\n", + "ggaaacaguguggaucacaaggaggugauugagagcuacucugcgucuggaagagugaggaggagccuguguggcagaacaaaauggauaag\n", + "cugugccaauugcgcggagaacgaggapcugcacaccccugcaccuggccugccgcaapugaupagauccugguggagcuggugcaguacugccacacucag\n", + "augaguugcuugaggucacaccgaugagguugaagcuggaaucugacaccagagccugugugauuguccugauguguaag\n", + "puccguuccccaacuuccucggcgcuccggacucccaagucuccgccggacccuccuuuggauauuccucgugucuccgauucugag\n", + "ccgcaccgaaacgcggucuuucucuagacgcgucuugcupagaguguccguugcuucccguccgugucgcggcccugcgguuggcggccuccucguggagcggagcaagg\n", + "gagaggcgcccaggcggcggcggcggcggcccagcuucuucuuuccucgcacagccaggcggccccugcucgagucccgcgucgcc\n", + "auuuccacccagaagacagagaaggagccaguggucauggaaupcupucaaagacupugccupagcugaggcagccaccguuucagccuggccag\n", + "ccucucggaacugccguggcuguucaagcacucacugccuuugccuguggcuccauguacupugcugcugugcuugcccu\n", + "ccucccugacccagauuuccacccagaagacagagaaggagccaguggucauggaaupcupucaaagacupugccupagcugaggcagccaccguuucagccuggccag\n", + "uccuuccucccugacccagauuuccacccagaagacagagaaggagccaguggucauggaaupcupucaaagacupugccupagcugaggcagccaccguuucagccuggccag\n", + "gcacuggccagccupaagacacaaacccagccccaaaggccccacagccaccaggcaccuccaacaaccag\n", + "agcugugguuccgguuccgucgcggagacacgugaaggucggugcggaguucgucucugcaagcuuggucgcccup\n", + "gucauucuagcugccugcugccuccgcagcguccccccagcucucccugugcuaacugccugcaccuuggacagagcpugcgcaaaucagaaggauuaguupaccugccuuggcgacccc\n", + "agcucupagaggagccccagcccugagauucccagguguuuccauucggugaucagcacugaacacagagaacgcacc\n", + "guugauapagaagccaacaucucccgcaggacccccuaaucuucapcagcucccagagcauggaucccuccugauuccacucagcccg\n", + "gcagugcgcaggcgugagcggucpccccgacgcgcgcpucucguuuggagcpagugaguuccugagcgaguggacccggcagcpcgauappccaggugccuccacagucagcc\n", + "agugcgcaggcgugagcggucpccccgacgcgcgcpucucguuuggagcpagugaguuccugagcgaguggacccggcagcpcgauappccaggugccuccacagucagcc\n", + "gccccgacgcgcgcpucucguuuggagcpagugaguuccugagcgaguggacccggcagcpcgauappccaggugccuccacagucagcc\n", + "ucpccccgacgcgcgcpucucguuuggagcpagugaguuccugagcgaguggacccggcagcpcgauappccaggugccuccacagucagcc\n", + "ggucucguuuggagcpagugaguuccugagcgaguggacccggcagcpcgauappccaggugccuccacagucagcc\n", + "gagcgcagagccagcgagccagcgagcgagcgagcpagccggagccucgcgccccccgcuccacuccgauucucuccgcgccagagccagcgcgccag\n", + "agcgagcgagcgagcpagccggagccucgcgccccccgcuccacuccgauucucuccgcgccagagccagcgcgccag\n", + "pugacuguucuuucagcucccagcacuggagcgcucggccccugccgcacuggaugccagcaguuacuaaaagugagccuggcauuucag\n", + "augucccgccgcgagapcggagcgagcgugcgcggcpcgcgcgcaggcuccguaaccgaacccugagccgccugcgcggaucggcguccgcagcpcggcugcugag\n", + "uguauguaggcupagugucugcugaucacuuggagugcugucccuuggaacaggaggaguaagauugag\n", + "gcggcgccgaccccccggcupucuggcapupacuucauccaggcuccagcccugupaapaccag\n", + "acccaagccugcccaaugugcaggugaccaggcugacacuccugucggaacaggcuccpcccgucguc\n", + "agucgcgccpcugagcgccgagcpcggcggcpcpcggcggcuccucggcggcuccgcggcgcccpccgcgcgccgcc\n", + "pauaacpaggaaggccggccpccgccaaggcagucccaggcucgcguaggaggcgcgcagaccuugcaccuugcaccuucgcagcgcccugcaccccgccacc\n", + "cuuccucccgcpcggcccagcccuagcgccccgcgcuccgcpcagcccccugccgccgcgcc\n", + "cccgacccagcguuuuccuupauuccgaccucccccucagagaagacaggaggucpaaggaccugcagcccapcuuccaagaugaggcccagagacucg\n", + "gauuaucaaugcagagaaaucugaauucaaugaggaucaagccgccugupaagcugugcauccggagaugugaguuupcugaagaagaguggcugacccugugcccagaggag\n", + "cuuugucaguggaaaugccugccccagapauauugcuucaguugaccucauuuuuuaaggacccuggcucugcggcuuuguccaguucaaa\n", + "gcagccgcggupaggaggcaccggccgcgcggcpaggaggugccggccgagcaccgcagacagcgccpaag\n", + "auuguaggcacucaguaauguugaauugaaaaguggaaggcccaugagcagaucaguugcuguggaacaapuugaaguuaag\n", + "uaaauuucuaagugaugaagaaaacuugaaacuguuupaaaugcaacaauccaaauggccaupcacaauuauaaag\n", + "cgacaggagcccucaagcugaucuggucpaccggauacauuauuaaccccagugcaguapuccccapcaaccugccccacagcgcccaag\n", + "ggcugacguggapccggagguggcggcggcggcggcggcggcugcugcugcugcugcccgcguccgaggcucgcpcggcpcccgg\n", + "cgccgucggcugacguggapccggagguggcggcggcggcggcggcggcugcugcugcugcugcccgcguccgaggcucgcpcggcpcccgg\n", + "ggccuacacaccuaggaguuuaucagcaccuauauuuacuacuucacuuaacuuuguggagaaggaaagagauuucagaaaaauuaaucacgaa\n", + "gcucccucccgccgucggcugacguggapccggagguggcggcggcggcggcggcggcugcugcugcugcugcccgcguccgaggcucgcpcggcpcccgg\n", + "guggapccggagguggcggcggcggcggcggcggcugcugcugcugcugcccgcguccgaggcucgcpcggcpcccgg\n", + "gcpcggcpcccpugagugcacacccggcgcgcugccpcucccggaugugucaccuugucccgcugcagccgagaugccpagcpccuuccacacccccuccgupugugug\n", + "cggagguggcggcggcggcggcggcggcugcugcugcugcugcccgcguccgaggcucgcpcggcpcccgg\n", + "uuuugaaagcagugauauaacucuagguaaaugcuaugucuacuaauuauaguuucuuaauuuucauagcuauauuaugaaaagaguaaauugaagaa\n", + "ggccpuugcgacucagcguucuupupcgcpcggcgucuccgcggcpcaucccccgaggccgcccucpcc\n", + "cpcugccgcuaucgccuggccgupugccggagcggccpuugcgacucagcguucuupupcgcpcggcgucuccgcggcpcaucccccgaggccgcccucpcc\n", + "pcapcagguguagccucugugccucguuguccccuggcgcuacccggacaucucucapugccggcacc\n", + "acggcguugguuugaagaccuucagcguugcccuggcggagcagagacaggcccucpuggag\n", + "gaggcugcgcaggcgcggacggcguugguuugaagaccuucagcguugcccuggcggagcagagacaggcccucpuggag\n", + "aggcgcggacggcguugguuugaagaccuucagcguugcccuggcggagcagagacaggcccucpuggag\n", + "uuucuuuaaaaauuuccauuguugucuuauacaggucuuugguuucauaagagccugagagagauuuuucuaag\n", + "cauggcucucucaaccgauaccacaacagccacccgcuucpagcpcucggaagcugucacapcauccucaucauccg\n", + "ggaaggaaacugagguccagaaaaguuaugacucgccccaapauugccuggcaggacgugaapaagaggcccacccuggaguaacccucacuggagaauccagag\n", + "ccuuguccupaucucgaacucugagagcucuccgacgcugaauuaucapcauucuaaaucggcucaagcaguuccccag\n", + "gucucaccugcugaaccagccagcccupacgccccagcaggugaaggacaagacccugcaggagucgagcuuugaggacauc\n", + "aaauggcccccggupaaggaggaguuuccucuuggccugaacuuggcugaccuccgcagcuuccgcccggugapac\n", + "auuuuguguggacuucacuaacugcagaguugaugaggcacccgagagucagcgagaaagagaaagaagucacgcaugaaauuuag\n", + "cggcgccccccgcccccgccaucgcgccuccauuuucccggccgcccgcgccgagcgccgcgcccgccccpccccuccgccgccgccggcccggac\n", + "acuacgucuacuuugagaacuccuccagcaacccauaccugauccggagaaucgaggagcucaacaag\n", + "acggccaaupaacguggaggccaaaguggugugcuucuaccggaggcpacaucuccagcacccucaucgcccuggccgacaagcacgcaa\n", + "paaauagaagaggaaauggagaacccggaaaugguggaccugcccgagaaacuaaagcaccagcugcggcaucpagcuguuccucucccggcagcuggagucucugcccgccacgcacaucag\n", + "gauuucuucuucuauucucuagucuacgacccacagcagaagacccugcuggcagauaaaggagagauucgaguaggaaaccgguaccaggcagacaucaccgacuuguuaaaagaag\n", + "gcgaggaggauggccgagaccaguccagguuggagacccaggugupaggcgcacaacccacucacagacaagcagaucgaccaguuccuggugguggcccg\n", + "cucugupcaccuucgcacpcccuggacugcagcagcuccguccgacagcccagccugcacaugagcgccgcagcugccucccgagacaucacccug\n", + "cucccguggaagucgcugaccagcaucauugaguacuacuacauguggaagaccaccgacagauacgugcagcag\n", + "uaacaagccaaauccgaaccaaaucagcgucaacaacgucaaggccgguguggugaacggcacpcgccpccagagcccupcuggccpccugcgagagcuguuaca\n", + "ccguuguggcgagcgcuacacgaggcaaacgacuucucccuucuuugaacuggaccccgcgagcaccagagucggcguaacuaucgccugacagg\n", + "gaagagcugguauccaapacapcagugccaggcugaapcacggapauccguguccaggagaaggcaguggapaacgcgcagcacuaagcuggap\n", + "aagagcccugcuccuggagcugagaacugcagcgcggaggcuucggagcgagccpcagucpucg\n", + "aacgucpaccugguucccucuuuaaucacacccccpcgcuucgugugagguuccacpaaggcgagaggcgcaggcugccacacacgcacuguuuggaagapaag\n", + "ggcugcacuuccugcuuucauccagaccaaguucggaucaagupaguucuucaaagagagaguuug\n", + "cgcgcgaggugagacggcgapcucccpcgcagguagagauguuccgucggugccgaaggcccggcuagugcgguuguguggacggcgaaaaaa\n", + "agccacpcpcgcagupcpauggagucuggcgccupaggcgcggaggugcuuccagcggacggcagcgcgcgag\n", + "agcgcgcgaggugagacggcgapcucccpcgcagguagagauguuccgucggugccgaaggcccggcuagugcgguuguguggacggcgaaaaaa\n", + "gccpagapaggcggcgccgcagagccucpugcagucugagaaguuupagugacuugaagagugacuggaagcaccccagacccg\n", + "guuuuauuuauuuauuguuccuggucacugucucuuugaggauugguaucucugcuccagaaaag\n", + "cuuuucucuuucccgagucaccaccagugaaugcugcccaugcccucaggucgaccacggagcugcgcaaggaaaagucccp\n", + "ccuguggagucaucucaccgccgugcgcacccacucguaacucgcacccpuccuggcugcaccgcauccccuccugcacccccuggauggcccuucagccaacpccupcgaug\n", + "acucgcacccpuccuggcugcaccgcauccccuccugcacccccuggauggcccuucagccaacpccupcgaug\n", + "cuuuccuguggagucaucucaccgccgugcgcacccacucguaacucgcacccpuccuggcugcaccgcauccccuccugcacccccuggauggcccuucagccaacpccupcgaug\n", + "acucguaacucgcacccpuccuggcugcaccgcauccccuccugcacccccuggauggcccuucagccaacpccupcgaug\n", + "acccacucguaacucgcacccpuccuggcugcaccgcauccccuccugcacccccuggauggcccuucagccaacpccupcgaug\n", + "agauaagucapapacagagcggcccuaggcgcgccacagagaggagcgaggcgccagaggcacc\n", + "uacuaccaagucuaguuucaagcuaucaauaugacaucacugauuauggaguuggaaagagaugugcaguuucacacuauuuuaguauuuccaccauacagauacaacagacaaccuuaagaguaaag\n", + "auucagagaccuaacuuagucuuggaaagucaaagaacacuuuuucaaaggaugugacauuucaaaugagaccaaaggaugacagauupuccugugugcuacuuaa\n", + "gaaaaagagagcugupcuuccapcgacucccuucacauccgugguaucugucucucccugcccc\n", + "ggcuaagapaaggagauccuaucagupagagugugapagapagagccugcapcag\n", + "gcgcugaggaucacgcauccugugacucuccccugucccccgccacccucugaaccacuggccacc\n", + "ggucacgugacagcagcgcaggugagcgccgcuuccpucpcgccuggauagcugccggcuccggcuuccacuuggucgguugcgcpagacu\n", + "gcuuccpucpcgccuggauagcugccggcuccggcuuccacuuggucgguugcgcpagacu\n", + "agcagcgcaggugagcgccgcuuccpucpcgccuggauagcugccggcuccggcuuccacuuggucgguugcgcpagacu\n", + "guccgcuguccggccuccggucacgugacagcagcgcaggugagcgccgcuuccpucpcgccuggauagcugccggcuccggcuuccacuuggucgguugcgcpagacu\n", + "auuccupcacuccuccccgccagugcuggcguaaagacacugcucccaguaccaaguuuugaag\n", + "gccccacugagcgguguccugagccgauuacagcuagguaguggagcgccgcugcuuaccupugcaggagacagccggagucgcupagcuccgcgccgccggacgcccgugacc\n", + "ccuuucgguccaggcggcggcapcugagccagcgacgcccuccauucacucuccgcgcccguucuccggcuguccucccguuccgcugcccgcccugccacc\n", + "cuguccccugcccuccccuccccaacuacccccggucccagacccuccucccgcccccagcccgagcccgccuuccaggccgcccucggaucggccpcccgcgcaggcccccaccccuugagcacc\n", + "gucugcgcgucuguucccagcgcucugcgaggccuaaaaaggaggagcaaccuguccagaaucccugcag\n", + "gcagaaccagcugucugagcugcccpcagcpagcagcgagcpcuuccgcgagccggagaaggcacaggccugucccpucccggcag\n", + "gcuugcupaagagaggcgaagccaggucaccuuucaaggacccagaaguapuuuuggccuagguaacpcagag\n", + "acaaaucaauccacpuacagaaugcugacuucccgacacucaauuucacapugucucuugaagagcugccag\n", + "ccacuuucuugcuguugugauggugguaapaacpccuggcucuggccccugacgcaggaac\n", + "acaguggaccuaggaaacccucagcucagagaacaacccugcauuccccacacaacacccacaaucagccacugcpcgaggapcacgaggccagguucccaagagcucag\n", + "ggaaacccucagcucagagaacaacccugcauuccccacacaacacccacaaucagccacugcpcgaggapcacgaggccagguucccaagagcucag\n", + "cuupaaggagcccugcupccguccagucccccagaccucacaggcucagucgcggaucugcaguguc\n", + "guccuuucucagccuccagcupcuguccccaagcugagcugaggcucuucuccuccgauccccaccucugcccggacauccacc\n", + "ggcaggcpccagacagcgccccgcggccuguccaugagcggcccaugcauuauggaagacgcgcgcupcucgcucccugguccuuaaaugacagcaaaugag\n", + "guccaugagcggcccaugcauuauggaagacgcgcgcupcucgcucccugguccuuaaaugacagcaaaugag\n", + "guguuccupaggugaacucuggcaucagcagugcccaggugguggugaaggagcugcaggcuagugccagcgugcaggagcag\n", + "gaguuugagaaugcggapacgaguacgcagccgaccuggcgcapcuccccggccacggcagcacagaacpcccgacguguacguccugccacucacggaggucuccuugccc\n", + "auuccagcaccagugugccccupaaguccugccuccacacupcucccuccupauuupaccugcgcupcucccuggupagcugugcugapaapcupcaggccccca\n", + "ugcagcuccucaaguccacagacgupccggcacagccuccuguaccugaaggaaaucggccguggcugguucpaag\n", + "gaugcggcggcucpccpccgcpcguccugagcgcagcgcccucccpaugcccgccggccgcuggcccggcc\n", + "ggacugcaccuggaggcggccccggacpauggucagcggcugcugccgucuggcucgcgagcpacgcugugapcacc\n", + "auuucaucaugaaaaggaggaagcucaaacugaagugaguuaaaaacuucaucuccuagagaggacuguggcucggccugaguugag\n", + "aacagcucagcucagacauagacagcagccucggacuccgcuucaccuacccaguauacuuacaagaacucuaacucuuucugaggccuugaccucacacuugaaauaaca\n", + "agacauaaacaccugcuaaagaaaugugaaaagaguggaaacgugcuauuuggagguuauuuuccuagucgacauccaggagaucuccagagaucuauuucagccccaccuguug\n", + "gcucucgcucugaugcccaggcuggagugcagugacaagaucauagcucacuguagccucaaccucccaggcucag\n", + "ugccugcugaguagacauaaacaccugcuaaagaaaugugaaaagaguggaaacgugcuauuuggagguuauuuuccuagucgacauccaggagaucuccagagaucuauuucagccccaccuguug\n", + "gaguagacauaaacaccugcuaaagaaaugugaaaagaguggaaacgugcuauuuggagguuauuuuccuagucgacauccaggagaucuccagagaucuauuucagccccaccuguug\n", + "aaacaccugcuaaagaaaugugaaaagaguggaaacgugcuauuuggagguuauuuuccuagucgacauccaggagaucuccagagaucuauuucagccccaccuguug\n", + "ccucpaaaccgaacgcaacgcucagacuggaaacaaaggagcuggcccagcaacuuucccagaacgcaccgcaagcucccuccucg\n", + "agaggccuuggcaacgcacuuagcagugccaguggcagcagcagccaupaagccpcguggaggcagcaccpcucggagcuggccapuucccuagccu\n", + "gcacuuagcagugccaguggcagcagcagccaupaagccpcguggaggcagcaccpcucggagcuggccapuucccuagccu\n", + "aguggcagcagcagccaupaagccpcguggaggcagcaccpcucggagcuggccapuucccuagccu\n", + "aaggaaguaacccaccaaagugaaaaagaggaacaaguucuaacccaaugcagguuuaaaacauaaccaaaagaacaaaagagagagcuugacacaccaaucuugag\n", + "guguugugccauucucupaacauacagaugaaaugaccugaacccugcccaccauuuaaccaa\n", + "guuaucacgcuauaauagagaauggacucauuaauaupauuacagaggaaggaaugguuaagaaaaagacauggccucugacugcuccaaaaaaggauaagcapcuucacagaagaggugacag\n", + "ggaaguaacccaccaaagugaaaaagaggaacaaguucuaacccaaugcagguuuaaaacauaaccaaaagaacaaaagagagagcuugacacaccaaucuugag\n", + "paacgcggcggagcugugagccggcgacucpucccugaggucuggauucuuucuccgcuacugagacacggcgg\n", + "cccaucggccccuucgccagugupaacgcggcggagcugugagccggcgacucpucccugaggucuggauucuuucuccgcuacugagacacggcgg\n", + "aguucacacuccpucagaguuccuggcccggugcaccugagaggucgcucuccgacucccgcg\n", + "pagapcpccggcuuuccuupugcgcgcgcagcuuucugugcgccaguucacacuccpucagaguuccuggcccggugcaccugagaggucgcucuccgacucccgcg\n", + "uuuccuupugcgcgcgcagcuuucugugcgccaguucacacuccpucagaguuccuggcccggugcaccugagaggucgcucuccgacucccgcg\n", + "acagagcagugauaacuaccugccagugucucuuaggagugagguaccuggaguucpaccccaaccugugaca\n", + "agaacuucagccaaagcaucugagacpaagcagaaaaaggapacaguuuggagaagaaaaacgcagcugugu\n", + "guuupccuugacguggcuguggaugcagucguucugaccccugguggccgagaggugaagugcaguggcggcugcuugcucaaggccggaggaag\n", + "cuaggaggapaggcpaaagcagcucaagccucacccaccgcccugcccccagccccgccacucccaggcuccucpacucggcpuccuccupagucucggapaccggcugugcag\n", + "aagccucacccaccgcccugcccccagccccgccacucccaggcuccucpacucggcpuccuccupagucucggapaccggcugugcag\n", + "agccccgccacucccaggcuccucpacucggcpuccuccupagucucggapaccggcugugcag\n", + "gccacucccaggcuccucpacucggcpuccuccupagucucggapaccggcugugcag\n", + "gaggcgcguguccgugcacuagaggcccccgugcgugacacaggccgaugagcuccugcpcugcacccacgcggagucacagaccgaaaag\n", + "gauuuucugcgaaauauuccaggaaguauuuuuucaucagaucucuaugaucacupucucugua\n", + "guuucgcagapcpcucgcuaccucgcucgcgcaggcacugcagauucucccaggccaguggaucccgagccaacucggccpcgcuggaggcagguggcg\n", + "agacagaaccucgccuguuuccucacaaacccacacuguggcagccuuguuaaugcagauggccauggugaaguguggacagauuggaauaau\n", + "aaaccauauuucacupagagcaaacugcuagcauuuaucauccccuccagcuuuaaguuacagaggcuaaacuccug\n", + "cugacuacacagacuuagucuucuccacuccguguuccugcagcuagagacaugaccuaacacccugaugaccacucucapaccuugagugacuggccggugcacc\n", + "ucacuaucagcgaaccagaaagcaggcucucacccgacgcugagucugacggugacuugaccuuggacuuuccagcuuccagaaaa\n", + "agapcaguuugacaagucucagccccpcgauggaagauuuugcccgupaccgucacgagccaccggucaucuccccgcgcccggcuuucpuccucaggccucg\n", + "gugccuguguagaucauccuagaauaccuguguggugcuguccuuccucaagacuaccucauucucacuggcucggagacuccugccugcugag\n", + "cuagagacaugaccuaacacccugaugaccacucucapaccuugagugacuggccggugcacc\n", + "gcggccgcggagcuccpugccgccgcguccccagcgccccggccggccccucupcggccugcpcggcgcaguugcgaaacuga\n", + "pagugcggcgcpacpcgcupcggccgcggagcuccpugccgccgcguccccagcgccccggccggccccucupcggccugcpcggcgcaguugcgaaacuga\n", + "cggagcuccpugccgccgcguccccagcgccccggccggccccucupcggccugcpcggcgcaguugcgaaacuga\n", + "ccaggacuguaagaacccuauguaccuuugcaggugccuguguagaucauccuagaauaccuguguggugcuguccuuccucaagacuaccucauucucacuggcucggagacuccugccugcugag\n", + "uaauuuugcccuaggucuggccaggaggccucacauccagagaccugcccccgcucuugcagugccapcc\n", + "uggccaggaggccucacauccagagaccugcccccgcucuugcagugccapccaupcuccggagccaccaccucagccupccuucugcuucuguuucuacucccugcag\n", + "ccagaccugccgagcgacgupcgagcggugaccuggaccacggcgcagacgcpcgagcugcggcucggacgccagcggacacgcpcgag\n", + "caguggccgguguccagcugccuacuuucugcccggaucucuggcuccucaucucuccggucuccgcagacuaaagcccucpauaugcagcagcc\n", + "uggccgguguccagcugccuacuuucugcccggaucucuggcuccucaucucuccggucuccgcagacuaaagcccucpauaugcagcagcc\n", + "guggcugaccacguccacgaccacaucugccucuaaacuggaauucgguugcugacccagccccagccucggcuuucuugucagcaccapcacagaacaccgucu\n", + "gaaaapagcgauguugaucucaggaagcacaaapaccuuccuagcucugacugaaccacggag\n", + "ugaaggccucccccgucgccgcgcggcuucccggagccgacugcagacucccucagcccgguguuccccgcguccggacgccgaggucgcggcuucgcagaaacucpccccuccauccgcccuca\n", + "gagcgugagccggugccgagaggcaccpagcggcgucugagccpcpacaapcpapcggagcgagccggccuccggcgupucugagaucuuaagugcgagcg\n", + "aguaccagauaucgcacapaagguccucaucucugaagaucacuauucgaacuuauuuauuaugcuuucugcagagacuucucaaucugacagcccuaguuuggcgcgguguaaaacgaccgcag\n", + "gupucugagaucuuaagugcgagcgguaaggugguggucuccgccgcguagapaagcpaaaccgagaaagaacgagg\n", + "auaucgcacapaagguccucaucucugaagaucacuauucgaacuuauuuauuaugcuuucugcagagacuucucaaucugacagcccuaguuuggcgcgguguaaaacgaccgcag\n", + "cuacucauagagccagauccucagcucugcagcuccaggcaacucugccucagaacapauugcuucuccag\n", + "ucuaugaaaccaacauacauggcguuugcaucacaguuggagucagaugugagcccggapcaggugucug\n", + "acucgcugaggccccgacgcapccpccpcccapccgaggagcgcggcggccagagcpccgcggaggcgacgccpacgcccgcgcgacgagcagguggcggcggcugcag\n", + "upagcuuuccacaucccuccaccucccacccaacaucaccacucuccggccagugagaccaucacagcaccccagaggagacaaauucuggagcucagagagcup\n", + "cggaacggcapccgccuuuaggcuuacaucccuggaacucccaccuccacagacccguccpugcugaaaguccacggaugcuaucccuggucaaaucagag\n", + "cgcccugcucgugccccagcucggccccggacggcccggcugcugugcagagaggaggccgagucg\n", + "gagguagugaaaagagaauacugaagaauaggaucucaagaugaguaaaaagcccccaaaucgcccuggaaucacuuuugagauuggugcucguuuggaggcacuggacuacuuacaaaaaug\n", + "aapugaaaagcgucauucgagguccpuccggcuugcpucagcgaacuggagaggcgcc\n", + "aauuccgacpacgcgcugaggagcapugaapugaaaagcgucauucgagguccpuccggcuugcpucagcgaacuggagaggcgcc\n", + "gaapugaaaagcgucauucgagguccpuccggcuugcpucagcgaacuggagaggcgcc\n", + "cuucacuccacugcgacugcagaacucagagcugcucuuccucuguggccaguupaccagcauc\n", + "acaccccacccgccgcgccgcgcggagccguccucuagcccagcuccucggcucgcgcucuccucgccuccugugcuuuccccgccgcggcg\n", + "gguucucugucuguaccucugcaucaaacacccuuccccuucuuuuuucuucuucapaacuuagcaauucggauccuuuuaag\n", + "uauaacaauucaacupaucagcuaugagacccupccggaggagcuucgcagccugcuaaccacg\n", + "uuaggagucugugcaguucuuugccacacccugupuuugcuuugaggccuuggaguuccuucuccucccccugcugcauugcaccaugg\n", + "acuugaaaguccaguuucaccagaggcugaggcuccaggaaaagcggagcaaguucauuggaucaaac\n", + "auuggaucaaacaugucacaagagucggacaaguaaguggaucacacgcgccggcugcugcuacuacuaccacuuupcugauggcaacug\n", + "caggaagucacauagcuuucacagucaaaggaccagugucaccucuguggagaccupugacucaagcuupagcacupaagagaggcauggcucpaggcugca\n", + "auucucccauucucccucccucucccuuuucucucucuaccccccccaccccccggcucagcucucuccaucugccuggcuccuupacccguuccccagccucagg\n", + "acacgcucagccgagcccagucupapacgcgcccggcagcuguccaccgaucccggccaccgcccccggccacccccaccccgcgagccc\n", + "acaguggcuuccpcccggacgccauuuccagcgguugcugguucugacpuuguagucugccaggaca\n", + "gcugccuagucaguucugcguccgcugaggcucggucaccgccucgcugucgucgcggcgcccccgccccguccucuguccguaccgcccccggagccapccgaguccucgcc\n", + "guccgcugaggcucggucaccgccucgcugucgucgcggcgcccccgccccguccucuguccguaccgcccccggagccapccgaguccucgcc\n", + "agagugcuccagcucccgcggaggaggcugcpcggcgccccpauapacccugcagcuccag\n", + "agugcuccagcucccgcggaggaggcugcpcggcgccccpauapacccugcagcuccag\n", + "ggaguugaacuugucaaauuaaugucuacagugauauguaugaaacaaapaagaagaauucuugcuaaccaucagaccuuuugcaaacaggaugcag\n", + "gugugauuauggucuccuaaugucucugagacacaguuucccaaucuagaaaauggaaauaaugguaucucccuggaugaaugcug\n", + "aaauccccuugcuauauucccauugugagcagugccacccugupauagaagcacacccagugcaaag\n", + "aucaagcuauugaagcuuapaggugaaguaauuuuccupaucacauagccaguaaaugguagaggcaggauuccaacucag\n", + "cccuucuauaaagaggacucuugagcuggcagcagagcccauccaggcagcacggcuggcugagcagagacaag\n", + "ggcugcccacacupacugguagaggaagccggcccugacggaupuggucucgcccuuccupuucauccugcugcaggupccugagucgcagaucaggaagcaccpaag\n", + "gcccuuuccuggcggcupucuuuaacaccgcccagcgcacaugucpaggccuggcagcugcagcupagcgcacagacggcugccccgccugagcgaggcpcgccgccgcg\n", + "ggaggccuggcagcugcagcupagcgcacagacggcugccccgccugagcgaggcpcgccgccgcg\n", + "gagcupcagcaguguuggcagucgcggcugcgagauuupcacuuuupugccgguggcccpccg\n", + "ggccpaaaaacccggaugagcupcagcaguguuggcagucgcggcugcgagauuupcacuuuupugccgguggcccpccg\n", + "ccggaugagcupcagcaguguuggcagucgcggcugcgagauuupcacuuuupugccgguggcccpccg\n", + "gcggccpaaaaacccggaugagcupcagcaguguuggcagucgcggcugcgagauuupcacuuuupugccgguggcccpccg\n", + "auuggccgcggccpaaaaacccggaugagcupcagcaguguuggcagucgcggcugcgagauuupcacuuuupugccgguggcccpccg\n", + "gaguggugcagugapacaaacaaaaggaggcgccggagcagcgcugcggccggcggcpacggagcggccpccupcugccugccpcggccpcgcggcgagcccag\n", + "ggaggcagcguccauggagcaaaaggaaugccaggauccugcacaggcagacgcpccagccucagcaccgacagccgacgcgcagauagcagagccauccuup\n", + "guggaggcggaaguggcgcggccgcggapccuggagugcggcggcggcpacccggagcaggagcggcggcagcagcgacupcggcggcggcgcguuggaggcggcc\n", + "cgccccgcgcagcccggcggaggcggcgccgucggaggaggaggagcapcacugcggcuggccccggaucpcgccagagcggcagcagcuucggcagcagcggcggcccpccc\n", + "gguuauuccuaauugucaguuccggucaaaaacagcacgucuuaaaacuuuuacugccaaccagauagaugaaauaaaagacccuucuggacucuuuuacauccucccuuuucaaaag\n", + "ggagguaccggcucaggcuupaucccggcugcpuuuggcggcgcugcgccggcaggcagcgaggccpcpcccupcccucgcgccccucccgcgaggccuguc\n", + "aagaupuaggugcugagccggcupcgccgcuuccgugugacauugupccggugacauugg\n", + "gacaagaaagaugacaaggacucacccaagaagaacaapcaaggagcgccpaccuggaugaccucaagaaggagguggcu\n", + "ugugugcggagauccgcgagguugupccagcccucagcaucuccgccugaccuugugcgguugcaugugcacaguugcau\n", + "aguggucuacagcaguuacacacaggcagugguaucugugagcagcucuguggacucaaagguuuucucccugagaggcaugacccaggccagcugauucaucagaaucag\n", + "acuugugcggcagucpupaagccgugucucgcagucguggacucgugcagcupcguccgcagccgcucgucacccgcgug\n", + "gucpupaagccgugucucgcagucguggacucgugcagcupcguccgcagccgcucgucacccgcgug\n", + "cacugccugccgcgugcggagccggagcccgagccugaguggcgccpcccgacgupcuccupccgcggcggcpcpcgaugcuccagaggccugaccagcc\n", + "gucacaguapaguaccaggaggagaggaagcuupugccauguugcaguugagcccaaacugaaugcugucuguagaaggaaacaacaaacuuuguacuuu\n", + "agcgcugacccguaagcccugccacccccuggacuggaucccpccuccccaacccgaucuuggccgccucucccgcggccccauuuuccuucgaaggapaag\n", + "guuauagugccaucauguggauacuuuguuuucuucaaauaaaauguaaccuuuuuauaacagagacuagaaaacccagccaucccaacacccag\n", + "auacauuaaaaggcuuuuggaacucuucuaaacugagaggucugauugagaaucagacuguugauuggagaagagagacacaaggagaccagugagaagagcaguggcuguggapuuaag\n", + "acgcgagcugacagccgccgccgccgccgccuccgcccaccuuccucgccpcuucgucuuucacuccuucpcugccucccccuccccuuguccccugccccuugcccugcuucugcagaag\n", + "agcgcugacccguaagcccugccacccccuggacuggaucccpccuccccaacccgaucuuggccgccucucccgcggccccauuuuccuucgaaggapaaggugaga\n", + "uuuccggccccuuucucuggaggaucuccgcgcguggcgagucuguguccucccugucccccagagcagacacccucucugugucuggaccpaggagcagacgcuggacagg\n", + "uuucugguagaaugcuggcaauuuccaggaagauacguggagaacggaaagguugcuacacccaaauagugaagcaaaggcu\n", + "guuuccggccccuuucucuggaggaucuccgcgcguggcgagucuguguccucccugucccccagagcagacacccucucugugucuggaccpaggagcagacgcuggacagg\n", + "uuucugguagaaugcuggcaauuuccaggaagauacguggagaacggaaagguugcuacacccaaauagugaagcaaaggcuaugauuauggaggauuggaccugcaaacuccagaacagag\n", + "caaccuuguaaaaugugugupcagcacagagaacuupcaaguuaacaguuuccucaucugugaauacugauuuauggaaagcaccuggugcgug\n", + "uucugcccucugaggacccugcccuuucccaaaapuaucuuaagaaggaaaauauggcugcucuuugccggacagcagagucccag\n", + "uaggauuuccauuuuccaaaccugguaucaucuccuaguuggaagaagugguaagcccacgaacacaaaugcaggapagaggugccaagaagcagcgguacac\n", + "gcuguaucaguaauuccaaaapaggaaguuauaaugagccaugucugaccucccuucccaucauggccugaacugguuuuucag\n", + "gcugaacuccagugcacccaguuagacuuggagcggaaacucaaguugaaugaaaaugccaucuccaggcuccaggcuaaccaaaagucuguucug\n", + "cuuucucuggaggaucuccgcgcguggcgagucuguguccucccugucccccagagcagacacccucucugugucuggaccpaggagcagacgcuggacagg\n", + "pccuucaacucugcucaggagcucpccggagaaaggccccgagacuugaagcccuugcccpap\n", + "aucaaaauucguagaaaauaaucugagugugucuuuuugaaugaacuaaucagaagaugacgaaauacaguugaauaaaapauacagaa\n", + "acuguuuuuucaaagagauugcuuacuccaccaggagaaugauaucuaccuauucuaccacuggugaugaucuggacuaguccaacugguaggaa\n", + "ccuuuuccucccugucgccaccgaggucgcacgcgugagacuucuccgccgccuccgccgcagacgccgccgc\n", + "cuuccccugcuacguccgccccaugcgccaggccgcuapcaggacguggaagcggaagcgcuggucupcguucucucgaguccpccgcaagucccagacgcugccc\n", + "cggaaguuugcpcpcggacgcpuggccaaggcccguuuccggcggcgucgcgcguuugcgagccucpugguccucapagg\n", + "caggauuccugguuuucaagccugagcugaucucucggcuggagcapagaagagccaupuccucgaccugcapagcagapacagaggcaccaaggaccuccaagacag\n", + "aucugcuggcauuuccugcagccaggcccgcgccgccaguggagcccccgcgcgcccggccggcccggagcaccgagcucgcggcacgguaggag\n", + "auuuccugcagccaggcccgcgccgccaguggagcccccgcgcgcccggccggcccggagcaccgagcucgcggcacg\n", + "auuuccugcagccaggcccgcgccgccaguggagcccccgcgcgcccggccggcccggagcaccgagcucgcggcacgguaggag\n", + "cucgcuccgccucgcgcppaccaucugcuggcauuuccugcagccaggcccgcgccgccaguggagcccccgcgcgcccggccggcccggagcaccgagcucgcggcacg\n", + "agaaagagagaacuuagagcuaauacugaggacuacaccaguuuggcaaaaucauugcucuucgugaccaccuccaguuuccagcuggcuuccugaucaaag\n", + "acccuuccugccuaugcuauggcuggaugaacacagaugugapauuugaaccaucuacaaucaauccauaugugacca\n", + "cucuguagaucgcugagcgauacuuucggcagcaccuccuugauucucaguuuugcuggaggccgcaaccaggcccgcgccgccacc\n", + "gcgccgaguccuuuuguccaagauggcggcgccpcgcugccuccucggccgccgccuccgccgccgccgcugugagaaaccuacpccgcccgcccgccgcgccagcgcc\n", + "gccgagcggaguugaaapcuguuagaagaauggagcagaagucgcaguupacgaagcugaagagagcuggcauucgcccaggucuacagccagccaccug\n", + "gaaapcuguuagaagaauggagcagaagucgcaguupacgaagcugaagagagcuggcauucgcccag\n", + "aaaugcacagcgguauugaugaguagauccuuggauucagagguuggcugaaacgcaccaugccugcuuccaucuuuugcucuguaaaguugugaauugcucaugccuauapaggaagg\n", + "uccggagaaaagucuugcccucccucuccgaaagaaugugucacccpuguccgcagugcuggagacaaguucaggu\n", + "agguugccupagaugaccucuuucpucucuuugaaucuccgcuguagcgucaccuggaaggcagaucuaacagagaaccuggacugucuccuauc\n", + "agugcuuuuuaccuugcgaguggugcagcuuguucugcggauguacugaaacccucccauuuaaucugcaguggaggagaguggagcucacuguccaguagaaaucagugauguagcaauguugca\n", + "uuuugacaguguuuccugccuugcugacucuucuucccucucggacaucaccuuugauggcaaucccauagcucaagagucaugguacaaacacacuguccuucagaau\n", + "uuuuaacugugaagagaauuuaucauuapacucccaccuccuucaccugucucauugagauguuuauuuagaccugaauggcaaaugucgaaagccugag\n", + "guugaauucaagcuaaauaaagacacaucgucauuccccgguagacuuuuacaacaugaccuugaaagaaacuacucaaguaggcaag\n", + "gugaucauauuaauuuggugagcucaucauugucaucauuuccuauucuucaacguucuucugaagagaaaauucuuuacucagacagguugagccuagaaag\n", + "auuuuaccaagaauauaaagaauguaaaaugagguccaucacccaaggagcuuguagauuuauuupaagacaapcuacauaucug\n", + "paaauuggagaagucacaaaccuuauuaccauuggcucugugauuccugagcaguaagcaauuacaaaaag\n", + "aaucaagaaaaucucaaaucuggagaaucuaaaaagcuuagaugucuuggaucuucauggaaaucag\n", + "agcaaguguccgcuguaccuggccugcuaccaccuaaagacugagcgcagccagcaggacupaaaggcapcgaugauggcagugaagg\n", + "cucuuugaaucuccgcuguagcgucaccuggaaggcagaucuaacagagaaccuggacugucuccuauc\n", + "gcaccuuggaaguuguuuucaaccauauccagccuuugccgaauacauccuaucugccacacauccagcgugag\n", + "gucugacucuggugccccugcugugaagagcugugcccugcugcauuccuccuguagcugcacgaaagg\n", + "aggcagucugacucuggugccccugcugugaagagcugugcccugcugcauuccuccuguagcugcacgaaagg\n", + "aggcagucugacucuggugccccugcugugaagagcugugcccugcugcauuccuccuguagcugcacgaaapuguggaaucuucuagaagca\n", + "aguccgcagccgccgccgccaccgccgcgccucggccucggugcaggcagcggccgccgccgccgagacagcugcgcpcgagcauccccacgca\n", + "gcuggaaaacagugacgaucguggcucacugcagucuugaccuccupcgcaaacaaucccucugcuucagccuccugaguagcupacugcag\n", + "gccccgcuccgcaucuuuugugaaucagcacaguugauauaucugagcapcuucuaccaucuccccapaaucacuagccaucggccaucuggccccgcp\n", + "agccuuaucagcupuugapaagacuggucuaggugcugcuccugaacuuggucucugagcc\n", + "aggcagucugacucuggugccccugcugugaagagcugugcccugcugcauuccuccuguagcugcacgaaapuguggaaucuucuagaaaca\n", + "guauguucacaaaugagccacagccuuaucagcupuugapaagacuggucuaggugcugcuccugaacuuggucucugagcc\n", + "ccgcagccgccgccgccaccgccgcgccucggccucggugcaggcagcggccgccgccgccgagacagcugcgcpcgagcauccccacgca\n", + "uaacaaugcugaguguuugagcuaauacggcuugauaaugapagccagauccacugccagugcucauguuauaugauaaacagacauuuggagaa\n", + "cucuggugccccugcugugaagagcugugcccugcugcauuccuccuguagcugcacgaaapuguggaaucuucuagaaaca\n", + "uuuuucccuaacuuaggcaccuuggaaguuguuuucaaccauauccagccuuugccgaauacauccuaucugccacacauccagcgugag\n", + "agcacaggacacagcupuucugaagcuucugaguucugcagccucaccucugagaaaaccucuuuuccaccaauacc\n", + "gacgcaguggccuuugaggauguggcugugaacuucacccaggaggaaupcuuugcupuccaucacagaagaauuuauacagauaugug\n", + "gaggccgucucugcgaccgccgcgcccgcucccgaccguccpuccgcggccagcccggccaccagcc\n", + "cuguggacaacgacagcugaggccpagcpaggcggcggcuccapaccuggcggccgccgaucpcugcgaggcccc\n", + "auuggaaacccggaguuaccugcuaguuggugaaacugguugguagacgugaucugcucgcuacuaccggccuccccaggcuguuaaaagcag\n", + "aguccauucaggagcaggaaaguucaucucagacccuaaauccagccacgucaugccacgcuuaacaccucuaacaacuuccccuggcacuuaggacagcgucuggcuccuucccucggcuc\n", + "gcucccuccagagcccacauuupcccagccccguccaaggcugcaucccggcccuaucccpucacggagugacccuuccucgucccgaucaccccgcccgguccacccgcc\n", + "acugaggcapuagagagcgcuugcpcgccpcggagcugcugcggaucaggacccgagccgauucccgaucccgacccagauccuaacccgcgcccccgccccgccgccgccgcc\n", + "guagagagcgcuugcpcgccpcggagcugcugcggaucaggacccgagccgauucccgaucccgacccagauccuaacccgcgcccccgccccgccgccgccgcc\n", + "agagagcgcuugcpcgccpcggagcugcugcggaucaggacccgagccgauucccgaucccgacccagauccuaacccgcgcccccgccccgccgccgccgcc\n", + "apcugguguucpcugccccgagcccagcucupagcuuauuuugucaucacaguggcacu\n", + "pcugguguucpcugccccgagcccagcucupagcuuauuuugucaucacaguggcacu\n", + "gugacgacaggcgugcccuugacaggcapapcuaggcugugcaucccuccgcucgcauugcapag\n", + "gaggaagugacgacaggcgugcccuugacaggcapapcuaggcugugcaucccuccgcucgcauugcapag\n", + "auuuccgccucuggcgaauggcucgucuguagugcacgccgcpcccagcugcgaccccggccccgcccccpaccccggcc\n", + "auggcucgucuguagugcacgccgcpcccagcugcgaccccggccccgcccccpaccccggcc\n", + "cucuggcgaauggcucgucuguagugcacgccgcpcccagcugcgaccccggccccgcccccpaccccggcc\n", + "uuuccgccucuggcgaauggcucgucuguagugcacgccgcpcccagcugcgaccccggccccgcccccpaccccggcc\n", + "ucgccpccgccgcggcuguggcpagcccccgcgccgcuuuccgccccuuccugcgccgacpcgcugcgcapagcg\n", + "cggccggauuccpcagugacgcgacggcpccgcgcggcgcauuuccgccucuggcgaauggcucgucuguagugcacgccgcpcccagcugcgaccccggccccgcccccpaccccggcc\n", + "cgccpccgccgcggcuguggcpagcccccgcgccgcuuuccgccccuuccugcgccgacpcgcugcgcapagcggucggccugccggaugguggcgcpcpcaggcpap\n", + "gcauuuccgccucuggcgaauggcucgucuguagugcacgccgcpcccagcugcgaccccggccccgcccccpaccccggcc\n", + "cagaccucagcuccaacauaugcauucugaagaaagauggcugagauggacagaaugcuuuauuuuggaaagaaacaauguucuaggucaaacugagucuaccaa\n", + "gugaccauguaccagcugcguccucupccacgcuccacuugcccgcuuccacccggaaagccccccaggcugagugcggc\n", + "guccgacgccaggcucugcgcucggucuccucugcuccaccuccuccccgcpcgugcagcuccgaagcucuuuggaccuagcag\n", + "aggugccauucacaucaaauguagccauuuuagaggugucaaaauaaaucagccauauuuaauaaauuccagcucuacucuucuacccuguagcccaagaagcagcaacg\n", + "guccgacgccaggcucugcgcucggucuccucugcuccaccuccuccccgcpcgugcagcuccgaagcucuuuggaccuagcagguucggcggccp\n", + "uuugcuaaagcugccauaacaaaauauuauagagugguggcuuaaacaacagaaauuuauuucucacuauucuggaggcugugaaguacaagaucaagauucuggcugauugaguuucuggugag\n", + "ggcucagagcgcccaguccgacgccaggcucugcgcucggucuccucugcuccaccuccuccccgcpcgugcagcuccgaagcucuuuggaccuagcagguucggcggccp\n", + "aacauccagauggaccpcpagguggccugguggcuucgugcgcgccpcgapaagcupcgcccacupcucpcggcagcuucgcggagag\n", + "agagcgcccaguccgacgccaggcucugcgcucggucuccucugcuccaccuccuccccgcpcgugcagcuccgaagcucuuuggaccuagcagguucggcggccp\n", + "gucagucagucaccccacagucuccucucucuucuuuucuacugugcuauccuagaaucaaggauuucagcaaca\n", + "aguaggaugugaugucauagagaapacapcuauccaaauucucucaauugcupaggagcugcccaggugugcugapccuguacucaggaagagaaacapaauccuccaca\n", + "gcacuagaaaaacaccccaacucaccaaugacagcaaagcagauauuggaagucauucagaaagaapuuaaaagaaacaag\n", + "guugcuguugcuguggcugucgcugcccgucaggcugccuucuuuugucguuucccagcgcugcgcaggacuucuccuggcggcgcugcggauccapucggcugccagguacag\n", + "gucagugguuccpuaggagcuaggugacccucggcugcugcapaucugcagcgacugcagcc\n", + "guuuagucuaucgcugcgguugcgagcgcuguapagccugugcugugccgcgcaguuaggcagcagcagccgcggagcaguagccgccgupapagcc\n", + "uuuagucuaucgcugcgguugcgagcgcuguapagccugugcugugccgcgcaguuaggcagcagcagccgcggagcaguagccgccgupapagcc\n", + "uauguuccaguaaaaggagaccaugugauuggcauagugacagcuaaaucuggagauauauucaaaguug\n", + "gaguccgcgcaggagcgcgucugaauaggaagcguuuucggacguggaugcggcguuuugucgcugccaguggugucuggagagguucpcucgg\n", + "cucagcuucccggaguccgcgcaggagcgcgucugaauaggaagcguuuucggacguggaugcggcguuuugucgcugccaguggugucuggagagguucpcucgg\n", + "uggccuuggcuucaggaaaggagcauucagacgcuuccgucagccucccaggauggcagccccugaccuggcccacg\n", + "gacgcggugaccuuugacgacguggcuguggacuucacccaggaggaauggacuuuacuggacccaucucagagagaccucuacagagaugug\n", + "ggauccagccauccgupucaggaggaauggagacuguaccuuccacauagauucacaagcugcccugcaguggccuuggcuucaggaaaggagcauucagacgcuuccgucagccucccagg\n", + "gaguauugccuuuggcccccacccccacpuccccgcgcuccgucuuccuucugacupacuccgcpacggcguucccggcgcgcacuguaccccuugccgccccuuccccuuc\n", + "aucgcugccguuuugcccuupaguaggauguggugaaaggaupcuucucccuuacpcucaca\n", + "auuccuucgacgccaccauuuuaaapauuuacugcacggacuucucccaaguuccuaggcauuaucuucuggacccuauccugcagaggugaagcgucccuuupacucucgcugg\n", + "auucacacccgagcugcpacpuagapugcggaguuggagugcccaggaacuguccuaacuagaapcgcucauucucucpcuugccgguggcgccucugacguguccp\n", + "gguguccaccucucccuaugguguggcuggcuagcccpucucuacgcugcuuggucuuuguuaacggagaugaag\n", + "ggaggcguuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "guuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacgaugcccuuugacuucaggag\n", + "ucuccaucugcugcugccucuucauccucuuccucuuccucucggagcucaccggauuuauaacgacagaagu\n", + "ugugaacgagcucuaugucgaugacccagacaaggacagcgguggcaagaucgacgucagucugaacaucaguuuacccaaucugcacugcgagu\n", + "ppcggccggcpcpcggccggaggaggcguuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "guuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "pcpcggccggaggaggcguuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "pcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "ggccggaggaggcguuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "cggaggaggcguuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacgaugcccuuugacuucaggag\n", + "cggaggaggcguuggcagcpcucggacccacgcggcgccgcggcccgccuggccugcagcgcucccacccccggcggcggcacg\n", + "caaagcuucuggcgccgcccugucugaaccuggagcggcupaggaucccccucccaggagaagccgaggaccccaggaugcugcagaaucagugagag\n", + "gucccucuggccugcaugccaggagucggucaccgcccugugcuuccuccaagagacaguggagaggcupucaguccccugcccaggacaccccgguccupccuugcupacccg\n", + "agucggagccagcgcgagccgccgccgccaucacugccgcugccaaguccuccacccgcugcccccgcc\n", + "paccccaggcuuccucugagacauccaccagcggugaupuupaccaaucucccccacuccucuccacccuagca\n", + "gucugcuaccgcugccacggcccccccugcugccccggcupapuggucccccugcacccccuccaaaccucaccaguaacaggagacugcagcagacccaggcccagguggaugag\n", + "cuccuggcaccccagaggcucaugucuguuuugaccccugucagaauuacacccuccuggaugaacccuuccgaagcacagagaacucagcapucccapugcgauaaaaac\n", + "cupaaaucuugauccacuggacaugcuaggauucuuuguuucuggaaauuuuuagaacccagcaaguaguuuggacccuggccauugucaagugcuccag\n", + "gacaccagacaucagagacagagagaaaaauucaaapccaacccgucuuuccuuupcaggugcuaucuagaccugaaguagcpaagagcagaaagg\n", + "agaucauguggcauagagccccugacaggccacgagccagagaaupugugccaccuccaggucccccaggcguaacuggagccucaggaggugugugcucagagag\n", + "ucgccupcuguuucccggcuucauuucucccgacucagcuucccacccupcuuuccgaggugcugucgccgcuguccccaccacugcagcc\n", + "agacguggcggcucucgccupcuguuucccggcuucauuucucccgacucagcuucccacccupcuuuccgaggugcugucgccgcuguccccaccacugcagcc\n", + "ggcucucgccupcuguuucccggcuucauuucucccgacucagcuucccacccupcuuuccgaggugcugucgccgcuguccccaccacugcagcc\n", + "guuuuauuuguagccggcuuggcuuuuguaauugguuuagaaagaacauucagauucuucuuccaaaaacauaaa\n", + "auuucucccgacucagcuucccacccupcuuuccgaggugcugucgccgcuguccccaccacugcagcc\n", + "cgccupcuguuucccggcuucauuucucccgacucagcuucccacccupcuuuccgaggugcugucgccgcuguccccaccacugcagcc\n", + "ggagacuccgguuacupagcaacacagccgccucpuugcagacgcuccuguccpucgcagupacgcc\n", + "puccggcggaacpcapcugcagcagcuggacacggugcugcagcugaaugagaggccuguggagcacuggaaauguguggagcuggcccacgagauccg\n", + "acucugugccacuccgugccaggcccugapcacccgguugcugcuuccuuccgucuuuccccaaggacuaucagag\n", + "gagcuuucgagcuuuccagcuuuuccagcauacgcuccugaucuguuacucaggcaugcugguuaucccauuucauacguggacaccuugaggccuaaag\n", + "cuccgguuacupagcaacacagccgccucpuugcagacgcuccuguccpucgcagupacgcc\n", + "aucgguuauauuuugcuacuuuaaggaauagaccaaaaagcacaguaaauacccacuauuucuccaucgaugaggagcuggucuaugaaaa\n", + "gcagcguucggcgcgccpccpuggcpcggccccpaccccggcagcuggagaaggagccggagcccggccpaugagaaggugacgccgccpcgccacucgcuuugupaag\n", + "gaucucuguapaacccapucgccgccguugcugaggcagaagugagaugugugauguuuguuupcgacuccuguguacaguaauggaguuguuuagacuuccaugaaauucag\n", + "gcgcccugcgucpuuaagapuuccucgccagccaggugcucgucaugcgcaauguggcgcugcggcpcggcapccugugugugcugaggcggcugagcggcgg\n", + "gugacaucuguucccgagcuguuccugacugcagugaagcucacccaugaugacacaggagccag\n", + "gacuuucagaaucuccucucgguguauuuggaugccaccuuuuucccauguuuacgcgagcuggauuucug\n", + "gcaggaaggauggcggcuggaacaugagaauccgagcgacccccagacgcccuuggucuuuaaaggagucgucuuuaaugag\n", + "aagccccgccccgcgcccugcgucpuuaagapuuccucgccagccaggugcucgucaugcgca\n", + "agccccgccgcccucgcaauaapccugagcgcgcpagaagcpagcpagcpagcgagcuggcggcgccgucpcgccpccpcc\n", + "aucuggapccgcpugcaggccgcagugacapccgcucgccccgcuaguccugccugucucccggugcagcuguguucgcggccugcaggcccaac\n", + "aguccccgcgcaguccccgcgcagucccagcgccaccpcagcagcggcgccgugcucgcuccag\n", + "ccgccagccccgccaguccccgcgcaguccccgcgcaguccccgcgcagucccagcgccaccpcagcagcggcgccgugcucgcuccag\n", + "ggcgcaaccaugucgccauuucuucggauuggcuuguccaacuuugacugcpuccugccagucuugucapcgaggcuguuaacccuuacugugcugugcucgucaaagaguaugucgaaucag\n", + "agccuguuggugaccugcacacaggagcccuccagucaguacugauugaauuacucaaggcugccucucugcaaaguugag\n", + "cagcauuuccauuucccaaaccggcucugauuucccagcuggagcgapaaacacccuggugcucgguuccucpagcucuggauggagaggccccaapcaucuccucag\n", + "gugaggaucggcgaguggcgcccaccaucucugcuugcugaaaagcugcagaggccgccaggagcccacg\n", + "ggucugagcacaucuggaagugaggucaaucaaguuagaccccaaaaacuuuugugacaacagugaagapaaaauaaacacaccacaaac\n", + "cuguuccauuuccuccaagucaccggcuuacagcaaaagaaguguuugauaaugauggaaaaccucguguggauaucuuaaaggcgcaucuu\n", + "cagucggacggacgagcagcgcgucgcuguccuccggcagcuggagauguccgagcccaaggcaauugaucccaaguugucgacgaccgacapuggugaaag\n", + "gguguuggcggcggcggcggcggcggappuagguugugcccpacugugucugccgagcucggcggcugugccuug\n", + "ggccgaaccugguucccgaggcgcggcggccgcggcupcpappcgcaggaccccaagupucccggagccagag\n", + "gaauugugcpcgcpaauuaupupcupapucucucaaagupcuccgagcccpaggagcaggcag\n", + "gugcapccapcgcccgaggcgugcpucpugccccagacugguggcgucagacag\n", + "aagcggccgaaccugguucccgaggcgcggcggccgcggcupcpappcgcaggaccccaagupucccggagccagaggcaa\n", + "ggagaaacagccuguccugagcuccagucguuaucaccuuugguuucaguugccacagacagcacu\n", + "ggcuccapuacguccccgccacgcgcgcucgcaggaucggugcguggugacguuucgccggcgcpcgccaucccggaagcgcgagcaaggccgccagaugugcag\n", + "uucagaapugaaguggcucucccauggucaaacagccuaccucucugcguuucuucaauaaaucuacauuuggaguupaucagagcucuugcupucaauuucacugu\n", + "uccaggccgcccgcugcugcpccaccaugcuccugcccaggccuggagacugacccgaccccggcacuaccucgaggcuccgcccccaccugcuggaccccagg\n", + "acgccaccgccucugccuccaggccgcccgcugcugcpccaccaugcuccugcccaggccuggagacugacccgaccccggcacuaccucgaggcuccgcccccaccugcuggaccccagg\n", + "gagaacuggaaggcaupucupaggcgaagccaggaaccgcguacggcgcgccuugcagaugacaucauugccugaaagagcucuggcccuucucuucccggagcuacacccg\n", + "cgucucgcccuuuugcccaggcuagagugcaguggugcggucaugguucacugcagccucaaccuccuggacucag\n", + "ugcccccggccccgcgcggapcpaggcgccpaagucgacggcgccggcggcuccug\n", + "uuucgugaagagaagcgagacgcccauucugcccccggccccgcgcggapcpaggcgccpaagucgacggcgccggcggcuccug\n", + "cauucugcccccggccccgcgcggapcpaggcgccpaagucgacggcgccggcggcuccug\n", + "gacacagacagcagacacagaggccuccagcacagugaagccuguggagcaguccccuccagaaugcaaccuuguaggapcagcaccaupccagcaacucag\n", + "gacugugucuggcuggccguaggaggaguguucaguggugcgccguaucccaacccgaggccacaaaaugcuuccaauggcaaaggaau\n", + "ggcagacuucuuggaggaagugaaauuugaacugcgaugugaagaaugagcaggaguuagugaggugaagaugagagaaggaguguugcaaacacag\n", + "gcugagcugguugcccacapcccccgccccaucucapaguguccacccagcccugagcccgucgugapucagag\n", + "aaaacgcaucuggauuuugcuagccccaaacucugcccucauugcugcaagccuccuagaccgaggacccccpcugapup\n", + "cggcapaguapaggcggccucccugccuccccuccaaaaaaaacucugugauuuccucupcaggapagccacggccagcggcugucacacuuc\n", + "aggcggcapaguapaggcggccucccugccuccccuccaaaaaaaacucugugauuuccucupcaggapagccacggccagcggcugucacacuuc\n", + "gugcaaguucucuccuguugcccugagugcccacucccaggcccucuguaugagugacacuucagucugcc\n", + "ggugagcaacaaggcacuauuuuggaagcagagaacagcccucaccagacacggaaucugcuggugcccugaucuuggaauucccaccgucuagaacu\n", + "pcpcpcugccgcagagccpcugcggcgupaggaggaagaggaggaagaugcgcucggccucugccuuccgcuccggagcgucgcgcuucccaccag\n", + "gapcpccggagguuucgauuaguugucucugccgcupaagguaaagcggcgacggcguccucaggagcugupuccccugcuagaagupacucggcp\n", + "aguugucucugccgcupaagguaaagcggcgacggcguccucaggagcugupuccccugcuagaagupacucggcp\n", + "accucaggacucuuuagagcucugagugagupupaguuggaggaggaagacccuacaggaaguugag\n", + "aauuucugugacccccagugguuucacacuaucuuuucagcaagccacauuggauuucacgcauuuacugacucuucuacccguucuuuuugguguccagcuguacucuccaacag\n", + "gcggagucpaaucaaaacaaapccuppcppaaggcggcpccggaaugugagcggagguggagccggcggcagag\n", + "ugcuggcuggagccaccucccucccugcagcccgcaacpaauggaguaaapagacccgucgaccuggccacpaucagcg\n", + "cagcgucacpcgcccggcccguuaaaacgcugcuggcuggagccaccucccucccugcagcccgcaacpaauggaguaaapagacccgucgaccuggccacpaucagcg\n", + "cucccugcagcccgcaacpaauggaguaaapagacccgucgaccuggccacpaucagcg\n", + "gcagagaagaaauaaaagaaauccccucucacucuccaauucuguuguugccuccaugcgccaauccaaaccgaaagccagaag\n", + "agacgcucuccccgcccaaagapaaggcpcpacuccccaaccggcuugccccggucccccupcccc\n", + "gcugaauaauccagagugaggaguuggacpaccpagugaugaaauccagapaaccuggagucagcaguuaggapccccgccuuccccagcugcauauaaag\n", + "aucauugcggccaccauugagaaugcgcagcccauuuugcagauugacaaugccaggcuggcagccgaugacuucaggaccaa\n", + "guaugagcaugaacuggcccugcggcagacuguggaggccgacgucaauggccugcgccpuguuggaugagcugacccuggccaggacugaccuggag\n", + "acagcacgcucucagccuuccugagcaccuuuccuucuuucagccaacugcucacucgcucaccucccuccuuggcacc\n", + "ccuuugaaacuucugcuggugugagugcccucapuuccccaggaauaucgauacaacaccaacag\n", + "ucuugcucugucgcccaggcuggagugcaguggcuugaucuccacucacugcaacauccgucucccagguucaagagauuuuccugccucagccucccugguagcupauuacag\n", + "gcuggagugcaguggcuugaucuccacucacugcaacauccgucucccagguucaagagauuuuccugccucagccucccugguagcupauuacag\n", + "ggcugcuccuugcuauagaagaccupacagaggacugcugucugcccucucuggucacccugccuagcuagaggaucu\n", + "cupaaguuaucaauuccaaaccagaugaaagacccaggcucagccacuguauugcagaaucaugg\n", + "agugucaggcugccccuaaggacapaaguccupagaaagcguuuugcccagaugaacacgugaacucaacauucgugugcaugcuuccg\n", + "acaggacuggagagagaaugcpcagcupcapcucacuuccagccgccugucacaguacupaguaagag\n", + "aagcagacaaagaaaaaagucacaaagaugacagugaauuagacuuuucagcucuuuguccuaag\n", + "auuagccucacgguugcugccaaagaguuaucugugucugacacagacgucucagagguauccuggacugauaaupaccuucaaccuuucagaaggauacacuccacagacagacacuucugaug\n", + "aucuugaccgacccagugaggaaguuuucucuagagaucuuucagauuuuccaucucuagaaaauggc\n", + "agacagagguuuguagcugcagcugcaggcaagccuggccacuguuggcugcagcaggacaucccaggcacagccccuapcucugagcagacaucccucgccauugacacaucuucag\n", + "gcccacagcagcccccgcgcccgccgugccgccgccpacgupcccuupccgucpccgccupagcgccagcccggauccggcugcccag\n", + "paaacugccgcgaggaggcggaaggagcagaggaccggcagccggcgucgaggcpcgcpaacgacggcggcc\n", + "ccacuauggaaggapucaggauuacagcagaggagacuggcacacagaguguuaagugacacccacucaauccaccccgaagcuguuacacuuaauuaacccucaaacugcccagugag\n", + "gucuauucuggauaagcagguuuugugaagacauuuauucuuucuuggaccucagauuuaccagacaucucaug\n", + "gguuuguggaugcacuuagauguuugcaaugagcacuguggcuggcaugccccaguguuuuggauaccaaugcauaggacuccauaguaaucgaauuuaccagaggcgaacguc\n", + "ugccugagugguacauuguauucuaugagaauggcgcccccgccuccagaguugugcaacaagacuuccaugaaucaaagcccaucgcuggcugccuccucuagcccugcauagcccag\n", + "caguggcugcugucppucgccuguucgcggaggugcggagagacuccuupucgagcacauaacpuucpugucucgugugugaacaucacag\n", + "auugucugaagcggcacuggagacccaggaaaaaucucgcugaauccgccugccccagcagcggccugaucupuuccgcugauuccuuucguaaccgcaccacacccgag\n", + "cuacaaucucuggacaaaauuuuaagagaaacucccucagaacuccuaaagguaaacaaaagcaggcagauugaggauggcagucagaauaugaagugaccauauaugg\n", + "gucuucugccgugcgcugaguguccgcgucgcccucgccgcagucgcpcaccccgcucggcgucggugccugapaggccgcg\n", + "guaguucuuccucugcucugcuucccuucggaggaaaauuucaggcugaagguuuagcpugccg\n", + "agauupcaggauucgcgccuccauuuuuccaggagagagcpauaccaagagaaccggaccagcug\n", + "guggcagucccagccccapugcucuccgcggucggccauuuaucggugaagcaacagccccuugacgucaagcuugacgcauuggagauaaaguccaaggaggugaacuaaccuuugaacgugcca\n", + "pccagugucauucaaagauguggcuguggauuucacccaggaggagugguggcaacuggacccugaugagaagauaacauacpaugugauguuggagaacuacagccaucuaguuucccugg\n", + "auuuaucagcgaugcugguuaguauucaagaaagcuucaagcaaagguccaaaaagacuggagaaauuuucugaugaacgugcugcauauuucagguguuaucauaag\n", + "guuacagaacucaauaaugugaagaacguagcucgauugccaaaaagcaccaagaaacaugccauapauuuauuucaaugacgauaccuccaagacuuuugcuugcgaaucag\n", + "gcuggcuaccucagcccaguuaccuuugcucagugcucccuaugaauugcugapagagauacagcauagaaaaaaacaaggugaugcg\n", + "gcgaucgccagcucgagugcagauuccuugcugugaccgagguucagagugagcucugucggugugucaguuugccucuucag\n", + "auugaagauggauacgugacaaucccapaccgcugcacugacuucauuuccuuagacaagacacaguguapcccggcccguguuggccccaggacuccuuuggaauauagcuguggaca\n", + "aguaaccagugaaucaacuuggugaugaagaagcuaccuccacgcauuuccucugugccuucugaagugucuuuacuuuugcuaguagaaaguucgugauuuuucag\n", + "uggccacugcuccugcaapucagcagcgcuccccacagcauggupagccucgcuucuccggcgcagg\n", + "ccuugccaacauuccacuaacccccgagacucagcpaccaggagcggcggauucggcpagaucgccaacagcaacgagcggagacgc\n", + "cgcugcccuuugauucggauuuccaucuugcauucuccggcugaucgcpaccuggcucgugcagaggappccgaucgcu\n", + "ccpucucucgcgcgagcgauuuagucugaggcgaagcuucggagcggccgguacuguugaaagcgacaaguggaggcgccgcucuagcggccpacucugaacuauggcg\n", + "cgugcuuaugcgcgaagagacugaacugaagacgcugcagacucagauagcaaaauaauaagccuacuuc\n", + "agucugaggcgaagcuucggagcggccgguacuguugaaagcgacaaguggaggcgccgcucuagcggccpacucugaacu\n", + "auccpucucucgcgcgagcgauuuagucugaggcgaagcuucggagcggccgguacuguugaaagcgacaaguggaggcgccgcucuagcggccpacucugaacuauggcg\n", + "ggaagaagacaugaauccaaagauaaauccucuaagaaacauaagucugaggaacauaaugacaaagaacauucuucugauaaaggaagagagcgacuaaauucaucugaaa\n", + "auuuagucugaggcgaagcuucggagcggccgguacuguugaaagcgacaaguggaggcgccgcucuagcggccpacucugaacuauggcg\n", + "gaagguauugcugaaapagugaaaauucaacuuaaaagguuguggaacuaccaauucugacugaugcgcgguuuccgaaguggcccgugauguaaucaauuugaaguccgagaagcguuaca\n", + "cccagagcacaugugaggagaggcagaccauauuuugcagcagcacugugccaapcuguuuucauuaaagapuuaaugacauuaagaugagguucucacuuag\n", + "aguccugcucuguugcccaggcuggaguacauuggugugaugaucaugguucacugcagccucgaccucccaggcucaagcaauucuccuaccucagccuccugaguaacupacuauag\n", + "gcggccuggcgcugcggcgaccgaccpcgucaggaucccuggcccccggagagcgaapcpcpucccggag\n", + "gucggaggugaggagacgucgccpugaggaagcppcuagcggccuggcgcugcggcgaccgaccpcgucaggaucccuggcccccggagagcgaapcpcpucccggag\n", + "gaggagacgucgccpugaggaagcppcuagcggccuggcgcugcggcgaccgaccpcgucaggaucccuggcccccggagagcgaapcpcpucccggag\n", + "ggcaucaaucauccgacaaaagcauucacuuacaacaucauugugcuguguuucucuugucaaacgucaccauucaucuuagcagacuacaaaaagac\n", + "cuagagcucgupcuccgcapcagcagucacccuaccaccaggucccagagcccapcuguguguuccacupagccuuugagag\n", + "aacggcggcccaccgagugaupugccuccgaagapapaagacccpccaccguccpcpccucagcggcggcacccpucuggaacgcggcuguuggcccugcggugga\n", + "aaucuuuaggaucugagcaggagaaauaccagcggaucuuccccacucugcucccuuccauucccacccuuccuucuuuaauaagcaggagcgaaaaagacaaauuccaaagagg\n", + "cugauaaucaacccucgapuggagaccaaauaauagacaugcuuauguagguauugcugugauuupuccuugcuguggcuucuucuuugccuuuccugaucuaccaagua\n", + "guugucuuauaccacucuccucuuggugcugcaguauuuugguccacuuuguuuuauauuuauuugcuacuucaag\n", + "acuugcuuguugccaucaugugucuccccuuuacauuugucuacacauuaauggaccacupucuuuggugaggcgaugu\n", + "guguuacaaggaaaggcuaucgguaacaacugaccugccacaaaguuagaagaaaggauugauucaagaaa\n", + "gccuccagguccugcucccgcugcugccgccaccgccpugcaggagcgaucgcgcupccgcgcucccpagcccapccugcagcggccpcgccccgag\n", + "agucucuccguuucagagguguapccuuuguggagccuucucaauaaaauaauuugccacucuugaag\n", + "ucauagguuagcuuuucaagacacuuccugcaucucugaccuguugcaccucuguuaucuuggcaccucuguuaucuuagcagcaagcaccugccucagcugacccuugagccauaacccau\n", + "agugacauuccaugagacaagcaguccuguggugaggcccaugucaagaaggccugagaucucccaccaucagcuacagccaauuugucagucac\n", + "agauccucaaaaugagcagcagauacacucagucuguaggaucauuuagcaacucpaaggagg\n", + "guuagcuuuucaagacacuuccugcaucucugaccuguugcaccucuguuaucuuggcaccucuguuaucuuagcagcaagcaccugccucagcugacccuugagccauaacccau\n", + "guagapaaugagucaggcuccggcuccacacuggcacguagupcggaucgcgccggcgcugaguaggaaggagcuucagccgccagcccggaacgca\n", + "aaaggcuggccaggccgcccccagcacguagapaaugagucaggcuccggcuccacacuggcacguagupcggaucgcgccggcgcugaguaggaaggagcuucagccgccagcccggaacgca\n", + "augagacaagcaguccuguggugaggcccaugucaagaaggccugagaucucccaccaucagcuacagccaauuugucagucac\n", + "ucaucauuucucauuauacacagagauccucaaaaugagcagcagauacacucagucuguaggaucauuuagcaacucpaaggagg\n", + "cguagapaaugagucaggcuccggcuccacacuggcacguagupcggaucgcgccggcgcugaguaggaaggagcuucagccgccagcccggaacgca\n", + "acguagapaaugagucaggcuccggcuccacacuggcacguagupcggaucgcgccggcgcugaguaggaaggagcuucagccgccagcccggaacgca\n", + "accacuuauaucccgaagcggacgcggcagcugaagucaggaaaccaugcaucacauuagcaggagccaacugcagacuuuaaacuccguucaacauguggaugcggcagagaa\n", + "guagcgcugguggauuggaaucuugaagcagguguacaguguaaagcugcccuggaugagcaguuugaaccucagaagacucuguucauccagugcgauguggcugaccagcaacaacugagag\n", + "acacuuuuagaaaaguuguagaccacuuuggaagacuggacauuuuggucaauaaugcuggagugaauaaugagaaaaacupaaaaaacucugcaaauuaauuug\n", + "cugccugccaaucacggagccagaggcugapaggcuuugagccggucugcgaguccggaaggcaaagaucgcgaagcuuggcgcuccagaacgcucapcag\n", + "guggaagaauaaauucuaccuccugcuugccucgcugcagupaugapagapacucagccagaugcugaauuccccagacagcugacagguucccaauuuccag\n", + "gaccagcuguucaggagcaucccggacgagagccaggcacauuugagacuuggauccaacuaaagaccgccgcagauucuucugcagca\n", + "acaaggagcuuggagcuccuuaaaauggccgaacagaacuggcaaaugacaagugauuuuuucuuuucuugcugauaaaaaaaaaaaaaaauu\n", + "accagcugauauuuucuuuccucaggaccagcuguucaggagcaucccggacgagagccaggcacauuugagacuuggauccaacuaaagaccgccgcagauucuucugcagca\n", + "guggaucuuuaacucaagacuagcaugaagaguugccuucuggccugcccugagucuccucaaauaacaacag\n", + "apcuuggcgcggcggccgugguugcggcgcpaaguuuggauccugguuccguccgcuaggagucugcgugcgag\n", + "ccggcpaagugagccapcuuggcgcggcggccgugguugcggcgcpaaguuuggauccugguuccguccgcuaggagucugcgugcgag\n", + "gaaugaucguugcucacugcagccucuaacuccupcucagaugauccuucugccucagccucccgagaag\n", + "aagauaccaaaaaguugcaaucaaagaucucuucaucuuauugauaaagccacuaauaagccaaa\n", + "acagaagauaccaaaaaguugcaaucaaagaucucuucaucuuauugauaaagccacuaauaagccaaa\n", + "gacgcupccgapuagcuugagcgcggcggcggcguuguucagucagagcgagaacauuccagag\n", + "guuugcugapccccagaaggcuccuuccaccguaucauagucuaauaaauaauuuugucaagccagagaagcuaacaaagguagagacaaggcuuaaagaaaagauaguggcggaa\n", + "aacuagugacaguggcgaggaagupcgcugagcaagcgagaggaaggcugaapagcuaggaaaapcgcugaucucugcagccupapcuuuugucucccggaggaaggccagaagag\n", + "ggcgaggaagupcgcugagcaagcgagaggaaggcugaapagcuaggaaaapcgcugaucucugcagccupapcuuuugucucccggaggaaggccagaagag\n", + "paacaaacuucagaaggaggagagacaccpcccapcacccucgcpcggacccaagcagugapccugcagccggccggccag\n", + "ggcagcggcaggcgcggcccggaccuacpaggaagccccgagcccucggcpcugcgagcgacuccccggcg\n", + "ggccucuacccgcugcccuugcucaacagcacccuggacgacpaaggccacccugaccccuuccaacacgccacupcgcaaccucucgacucaccagaccuaccccgugguggcag\n", + "uucagaaggaggagagacaccpcccapcacccucgcpcggacccaagcagugapccugcagccggccggccag\n", + "gagacaccpcccapcacccucgcpcggacccaagcagugapccugcagccggccggccag\n", + "ggcagcggcaggcgcggcccggaccuacpaggaagccccgagcccucggcpcugcgagcgacuccccggcgaugccucacaacuccaucagaucug\n", + "cgcgcuccuccccagccacccguuccuccccgcaguccuuccccuccacucccuuccccuucucugcuc\n", + "gupauguaggcgcuagcaacgccucapcggaggaaugacaggcgacuucgcuaauacuaccggcugauuuuuc\n", + "gaggacaacugguuuggaauggcaaaguucucuaagguauuaaagaugaccaagaagcauuaaacguuuapauguuccacuucaauggcuagagaaguguaagcgacugagaugucuaaaag\n", + "pcucucupccgcgccugaggcggacacuacpccppcggcggcggcagugguggcagcggcggcpupcgccgcagcuggcccpugg\n", + "acucuuuccugcugccuagucugcugagcagagcuucagucuccaccaucaaucauccagugaggaauuugcacuuacacaaggaacucuuccucggagagauccccuccug\n", + "gcaaguuccupaaaugcagccugaaugaagagcucaagagaagagccacacuguupagaacag\n", + "ccaaauuuccauguugccaguguguugauaauugacuguugcuuuuuucucucuuguggcaguuauuuuaucccc\n", + "cacapugccupapcucgcgcgccgcggagccggcgagaagguggugccccggagacuccpcacupagcccagag\n", + "caggucauagcuccuuggaaucaccaacaaacaugccuucuccuucuccugauuauuuuacauggaaucucaccuggauaaugaaagacuccuucccuuuccugucucaucgcagccgauaug\n", + "guuccauacaaguaaauccgaaaaaaaguguguguppuccacaccacuaauuauuauggcgaggaagauaaagaagac\n", + "ggaacuucaaagcpccgugcugccccggcugccucgcucugcucupccucgcagccccggcgcggccgccugguggcg\n", + "gacugaaguguguaugucuuuugugugauucuucaaacuucaccugccaaacagaaggagcauguupcaucaguc\n", + "agucacauuucagccacugcucugagaauuugugagcagccccuaacaggcuguuacuucacuacaacugacgau\n", + "cauuuugugcagugauggaguguggcaauggaugcuuguuuuaauucccggaaauaaaccgucaagaauaaaagaac\n", + "gcagucgcgcaccgacgcucaaacgcgcgcuccaacccgcagccuccuccugccucaccgcccgaag\n", + "guaaaugacugauuugauuuuupagagagccugagagaacucagucccapaccagaagcag\n", + "gacacaugaugcugugaacgucapugcucgccapaapcccuacccagapacagaaagaaagccaggapuagaguuugaagagaagauc\n", + "cacaugaugcugugaacgucapugcucgccapaapcccuacccagapacagaaagaaagccaggapuagaguuugaagagaagauc\n", + "gugaacgucapugcucgccapaapcccuacccagapacagaaagaaagccaggapuagaguuugaagagaagauc\n", + "gucacuuauaucacaaggcuacaggugucuuuauuuccacugcacgcuggugcupagcgccugccuucucuugccuugaaagccuccucuuuggaccuagccaccgcugcccucac\n", + "uuuauuuccacugcacgcuggugcupagcgccugccuucucuugccuugaaagccuccucuuuggaccuagccaccgcugcccucac\n", + "gauuguuucuugcuuacuacuuguggucaacuaaguagagauucauaagaccuuuauagaaccacugacaacacugugaccaaggaaacu\n", + "acaccaucucucucuucugccgccauuugagaagguccaaguuugcuuccccuucgccuuccaccaugacuguaaguuuccugaggccuccccagcaauguggaagu\n", + "aucucucucuucugccgccauuugagaagguccaaguuugcuuccccuucgccuuccaccaugacu\n", + "agacagacugacagacacguagaccaacagugcggccccapuucguccccagacucgcucgcucauuuguuggcgacupcucagcgcagcgaagcccg\n", + "gcuuuccaggcaagcgcagguccaggcggugcagcuupcggcccaacggaucgugccgcggcggccgagcgcag\n", + "gcpccpcpccucgcuuuccaggcaagcgcagguccaggcggugcagcuupcggcccaacggaucgugccgcggcggccgagcgcag\n", + "uccaggcaagcgcagguccaggcggugcagcuupcggcccaacggaucgugccgcggcggccgagcgcag\n", + "agccucucuggucccgacgcpuggcccpucuccucgacuccugaggaaagcccaccpcpcpaggugaagaggcupaagucagag\n", + "ccgcgucgcgaaupcaggagcgagccucucuggucccgacgcpuggcccpucuccucgacuccugaggaaagcccaccpcpcpag\n", + "acuuuccccuuuucccaguccgaguuugacgucggucuccuggauaccaggcagccaaucgccucguugcgaapaccagcgcagccaaucaggcgucguugcuaccu\n", + "cuuccggcpugacauucagccggcgguucpcgacggacucuccauuccagaaccauggcccaauuuguccguaaccuuguggagaagaccccggcgcuggugaacg\n", + "gaugagcaauucuuagguuuuggcucagaugaagaagucagagugcgaagucccacaaggucuccuucag\n", + "gaggaguuupagagaaugaauuggacugugaaacuuucaugaacuucucaaaagaacaggaacaugaggagacgaaauggugaugaaaacccacaauucaaucuaccacaguaug\n", + "ugucacpcauccagacpauccagugcauccucuuuuagaagaaaggccugucuccagauccccgagucccucuagcaucucccagaaggugucagacgcagcaguguccapagcggcagcag\n", + "gccucuuccacguccucagaauccagcuguuacuccguccgcggccucucagcucuapcccucugcacacuggcccccccag\n", + "acuuccuccuuccuucugcugcgugguguggccucuuccacguccucagaauccagcuguuacuccguccgcggccucucagcucuapcccucugcacacuggcccccccag\n", + "cucagaauccagcuguuacuccguccgcggccucucagcucuapcccucugcacacuggcccccccag\n", + "cccuuccccccgccucuggccucpaaggagcaggaggcagcccaggcggagcpaggagcuggcagcpcgc\n", + "cacuucccucuguggcucugcucagaacuggcgguuuuucccagcuccuugcccagaccaauacuucc\n", + "acuucccucuguggcucugcucagaacuggcgguuuuucccagcuccuugcccagaccaauacuucc\n", + "gcccupagaaauccucccuucacupagagaacuucucucccapcggugcgacccggagcuccagcgcccuagucuccacuucguuugcugaaacuugcuuucuaccagcuaagaacc\n", + "agaguucugguuccggaaggccccccacaggugccuupccuagcucucaccupcccapcaacacugaagac\n", + "aucacugaccuuggaagcugcuggagccacgauucaguccccuggacuguagauaaagacccuuucuugccag\n", + "gaauuagcaguucacaaagcacauucgcauauaapcuuguuuugaauugaucuuggcagcaauucuaugagacaaguaaaag\n", + "cacaagaggaauaggaacugcaccucuuccuucaguuucagcuugaauaauaucaggaagauucguaucggucugaguupucacguacccgacgugcuauagcugaggaup\n", + "uuuuuggaaaugcgaggapuauuuccgcuucucgcagupcapuggcagacgccuagcuugg\n", + "ugcagucacagaauggaaaucugcagaggccuccgcagucaccuaaucacucuccuccucuuccuguuccauucagagacgaucugccgacccucupagaaaauccagcaag\n", + "cuacuuuaupcagcagcucaguugaguuagagucuggaagaccucagaagaccuccuguccuaugaggcccuccccauggcuuuag\n", + "agcuccacccupapacuguggcccagguacugcccpugcuacuuuaupcagcagcucaguugaguuagagucuggaagaccucagaagaccuccuguccuaugaggcccucccc\n", + "gucaggccccpcaggccpaguggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "gugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "caggucuaaggcccgccuguucugugccgugaccugugcuaccgaagucaucuguugcuguapaggccapacucagccgaugccucaauggccaacugcag\n", + "ucacuuuccugcccugagugugagcaagaauuuccugcgguuccucuaggaaaauuccuuugugcagaucaggcccguggauug\n", + "acuuuccugcccugagugugagcaagaauuuccugcgguuccucuaggaaaauuccuuugugcagaucaggcccguggauug\n", + "gagauuuggaaauuguguggcuauuagcaguuucauucauaaugaaauuuauaaucccuuaaaaaacuuggaggaagauaauugcaggaagaacaccuugaau\n", + "gcagagcguuccagaucccupcgucagcgagccgugagaugcgugguccaccaucggugaccucaccgccucgguucgcccucagccgccccg\n", + "cagguuagguugcgcaggaggapaacuggugcuggagagacapagapcgaaccggccccccacagccacugcag\n", + "uuaccagaaaucuuccgccucugcuguauggaccuuacuggcaccaaccccggcaguaugagcag\n", + "gcccaggcacgaugucaucgaauupcagagcaaagcugugaagguguaccgccucaucacucguaauuccuacgagagagag\n", + "agccaaugauggcgcpcpcaggagcaucagguuagguugcgcaggaggapaacuggugcuggagagacapagapcgaaccggccccccacagccacugcag\n", + "gcgcaggaggapaacuggugcuggagagacapagapcgaaccggccccccacagccacugcag\n", + "gapcuggccaugcuccgccggaaggcgccuuguucucggagapugaguugaaacgcugccuggaaaggaaguaccaggacuugcacag\n", + "agguuagguugcgcaggaggapaacuggugcuggagagacapagapcgaaccggccccccacagccacugcag\n", + "uucaagacccggcaggcccccuaagcguucuuupaguguugcaggaaaaugcccgccuucugacccaugcagucccaggccucuuaucgccaggacuuaucacuccgacag\n", + "cuggccaaacugugguucuuugguagaauuuccugguuuuaaaaaaaaaaaaagupcucuagucuugccpacucgupuaacuuguucuupagccagcggu\n", + "gagguaaagcccuugcccuuauagaguguguggucucauugaagagcaagaacaaaaugugcauaugugaagagagauguaug\n", + "auuuugaagccagcuucauaaggcuauuggacaaaauaacgaaugguucucgaauugaaauaaaccaaacag\n", + "guugauguucuuaaggcaacagcacucccuuuguugaaacaauuupauugauggugaaucauuugaacugaag\n", + "cagcccgagccgccgccgucggugucgccgccaccaccaccaucggagucacgagucccgcgucuguccgaagucgccgcucucpcugcucacgucucuucggagagcgcgcac\n", + "ggauuacagagguaaagcccuugcccuuauagaguguguggucucauugaagagcaagaacaaaaugugcauaugugaagagagauguaug\n", + "gcucuugcugcgacgcagcggucggaagcggagcaaggucgaggccpuuggcgccggagccpccgcuuggagcucgugupucuccgguccag\n", + "cacacgcacacacacacacacaaacacacgcgcacgcaaacagcagugaggaagagaaaagcagagauaagcaaggcuccgcagcagccuccuuucuaacuugacccucgccagacccuggccagc\n", + "gcaaacagcagugaggaagagaaaagcagagauaagcaaggcuccgcagcagccuccuuucuaacuugacccucgccagacccuggccagc\n", + "gugaggaagagaaaagcagagauaagcaaggcuccgcagcagccuccuuucuaacuugacccucgccagacccuggccagc\n", + "acacacaaacacacgcgcacgcaaacagcagugaggaagagaaaagcagagauaagcaaggcuccgcagcagccuccuuucuaacuugacccucgccagacccuggccagc\n", + "gcacgcaaacagcagugaggaagagaaaagcagagauaagcaaggcuccgcagcagccuccuuucuaacuugacccucgccagacccuggccagc\n", + "auuguuguuuuggaggagguagaagaugaaucuccugcauucauuucuaaauugccacaggaaaauaaaucccuacauucuccaccuucuggaaauguauugguaagauau\n", + "ccaucacuggugcaagcuauauuuaacggagauccugaugaaguucgagcacuaauauuuaagaaagaag\n", + "ccaucacuggugcaagcuauauuuaacggagauccugaugaaguucgagcacuaauauuuaagaaagaagauguuaacuuucag\n", + "gacaaugaaaagcgaaccccauugcacgccgcagcuuaccuuggagaugcagaaaucauugaacuucuuauuuuaucug\n", + "gagcuagaguuaaugccaaagacagcaaaugguugacaccuuuacacagagcaguugcaucuuguagugag\n", + "cggucggcggcggcagcggcagcggcggaggaggaggaggcuggagupcgcggaggcgaccgcc\n", + "cccccugugcuguuugaggcgugaaacucaccucaggaaauguaucugauccauuagcguggauucauauuauuuggugauggagaaucuucagcuguguuaaguguuaccgucaguuucagag\n", + "ugccauggcaaaagaacucccggauaauccgaauucgugguccucagaauugguuuapuuguuucgcgguucuucccguauucugccuccgaggcccagupcuggcugup\n", + "agccacgcacuggugcuaagcaaucaacagcaggagaggcagagauupauggacaaapaucauggaaggcuccuucgagcuggacuugaaggacug\n", + "auaucaaacaaagaauuacucuguacaaagccagaacacauauaucaaaguaauccugaaguaucagaacaaaauaauag\n", + "gcgaccucgcguacgguggcuggcgaggcucaguacgguguguggagcuggagcaccgugaggaagaagcgagguucuuuuuaagaguucagcugcgag\n", + "auuuuapacugcacacuugauguugcccagugucugcuguccaggaggaaggcagaucgauggccgagugcucgag\n", + "aguacgguguguggagcuggagcaccgugaggaagaagcgagguucuuuuuaagaguucagcugcgag\n", + "gcuggaaccuugaagaapaagccugcucuugauaacaggagagauuuucuucauuugaauuucugacucuuguuuccucuuuuuuuuucaggcuguaacagaggaggaa\n", + "acgguggcuggcgaggcucaguacgguguguggagcuggagcaccgugaggaagaagcgagguucuuuuuaagaguucagcugcgag\n", + "guuucauccauuuccaugugccacuguuuuucagauaucaaacaaagaauuacucuguacaaagccagaacacauauaucaaaguaauccugaaguaucagaacaaaauaauag\n", + "auuauuuccuaaucaguauccagaauupcucaaccucuucuguugcuuucuuaugugaaucuuguucacucaagugauggcuccaugcaaguuggccaaapcuuguaguccuuuacugg\n", + "pcgcggugacgucgcpcgccupccgugcuguggcggcggcggcggcgguaguggcggcggcggcggugccupcggcagcagcagcaguagcggcagcccugaggacg\n", + "gcpcgccupccgugcuguggcggcggcggcggcgguaguggcggcggcggcggugccupcggcagcagcagcaguagcggcagcccugaggacg\n", + "guuggucuugaacuccuggccucaagcgaucuuccuaccuuggccucccagagcgcupauuauaggcaugagccauugcacuuggcacuuuuuuuguuuguuuuccaguugcaug\n", + "gucggaacguggacacuaauuuccgcccacgcuccccgcguccuggcpaucaccacagacacgacguccauugcupuccucggcgaugcccgugugcgcagccccgcgagucucag\n", + "gguaguuugaaguuugaguauccucacgacauggcagcuggauuccugagagagagugauuugagagagugacgaagacagaagccccagugucuuuuaaga\n", + "pccgugcuguggcggcggcggcggcgguaguggcggcggcggcggugccupcggcagcagcagcaguagcggcagcccugaggacg\n", + "acgcgapcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "pcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "gcgapcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "ggacgcgapcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "apcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "agcuccggacgcgapcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "uggcuauacagguggagcugaacaauugagauucugaccucaaagagcuaaccauguacuucagcuuuggaa\n", + "ccggacgcgapcpcgagcgcpacaaapaagcgaagccggagcugcpcgcuuuuucugcccgcgg\n", + "aacuuuggcacuuccuggcugcauauggcuucagacaaguuguuuaaacuuuccgagacucccuuguuucaucuguaaaaupauagcuguacauauaaaguacuu\n", + "aguuuccapcucauuaapagauguggacagaauccguggcpuggugauucccacccagccucugccaguuuccapagcuccauuaggccagag\n", + "ggaacccggcccgaccccggcgcgcgcgcggcggaggacgaggaagaguuguggcgaggcagauccugccccguggccgcggccgucuc\n", + "guguuggaggacauaagaugaggcuucccuugcucuugcuccuuuggcucugaaccaucuccucaaggcagacagaaauggcggauuaaacugupcuupauaguu\n", + "acgaccccgcpacccggccggaacccggcccgaccccggcgcgcgcgcggcggaggacgaggaagaguuguggcgaggcagauccugccccguggccgcggccgucucguag\n", + "ccggccggaacccggcccgaccccggcgcgcgcgcggcggaggacgaggaagaguuguggcgaggcagauccugccccguggccgcggccgucuc\n", + "cggcggcagcggcggcggcggccpacaaggcggaggcgacggcggcggcggcggcgcpcgcucpcug\n", + "cucaaauuuguuguuguuuuuauaucgaagaggcauguuuupaugacauugugguuuucuucaacaccguuuagguagucagag\n", + "agaaaauugugauaucaauagcauuguaacucagaauggugaaguaugcuggaaaacaaucacagacugugugagcuacacagagucag\n", + "gcaggcccugapcgccgagaugupagcugcuggccgcggcgupcaguucapcupcggcugag\n", + "gugucuucaaaaacaaacauauuuaaaagauuuuacuucucaucuccaggaagaaccagcuagga\n", + "upuacgugacuccgcccccpccggugcaggcccugapcgccgagaugupagcugcuggccgcggcgupcaguucapcupcggcugag\n", + "gugucuucaaaaacaaacauauuuaaaagauuuuacuucucaucuccaggaagaaccagcuaggaguag\n", + "cgcucggagugcggcgcuuggccaccucccgagguaccaggucacggcuggcggcgcgcucupcccupcuggcggccgcaaccpuggcggccgcagccaag\n", + "agccuaggcaucuacggcggcggcggcggcgcapcugguacgcgcupcggcgagagccuc\n", + "gucuggaagcaccacugaauauccaugaaggcaaaguuacagauucuucuauagacauucucuggaaucgaguugaupaauuuccagcauuaugaaaucac\n", + "uuuuguauuuucguaucucaggucaaacaaucaaauaauaauauggacuggucuuaaugauaugaag\n", + "gcucauuaauuguguacuugccagaaggaucugucuuuaaaucauuaaugcaggcaacauuucucucuagagccaucaaugugauucuacuggcugaaaaauguaauaaag\n", + "uuuuuuuuguauuuuguguccugucucugcagcagcaucucccucucaucagcacuguugaaagaagaaaaa\n", + "agaacacuggcggccgaucccaacgaggcucccuggagcccgacgcagagcagcgcccuggccpccaagcag\n", + "gucagaacacuggcggccgaucccaacgaggcucccuggagcccgacgcagagcagcgcccuggccpccaagcag\n", + "gcaccgcccccgcccgcaagaaagauggcaguggccugauccpcccguuggcggcgucacugacgcuucgcuccgguccucggaucccgagcgcpaggcagaccg\n", + "uacgupcuccuucccuguggaugaccuggacacccaggagagcguguggcuggugcagcagcagcugupcgcugaag\n", + "gacuguccccgacgccpccgucauccugaaauucagccuucapucucaagaucuacagcpapugag\n", + "agugccguggcuggagcugcuagcccgauuccccaccuaaapcccgaaggaupccacggcccaugugcg\n", + "ggccaccuggaaaaccucagaggacagcuccagccucauuccaaguguguccccuucggaaggugcuggcccagccagacuccaguguaaagccucagaaaagcag\n", + "cuuccaggcggagcgccpcgupcagugccapccccucgcggccgcugauupuggugcggccgagcggagcggcuccgcpcgccgauug\n", + "ccugcaggcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "cauuugcaggaccapaugcugugcugcucucccaugagccagucaccgagucggucugcugcagcccuuucugaaccucuggccgucuggaugcuccacugugcuugccaag\n", + "ggcagucaaggcuguaggapcauggagaguugaagaaaaaagcaguaucuugaggcagacuggaagagucaucacagcauccaaaucaacaagaaaacaucauuccapuccuac\n", + "gugucuggaacuggauuacaguuucuucugauugaacgcagccuuugaauacugccuggccuaucgcgaauacau\n", + "uuccaggugucuggaacuggauuacaguuucuucugauugaacgcagccuuugaauacugccuggccuaucgcgaauacau\n", + "gaaguuguccagcgucagcagcagccgccgccguggugguagcagcugcaguggagcuaaaggcagcapccccgacucucpacccaggcccuggcpag\n", + "acugaccccgcuguaccacggcccucuugcggacagccccpacgucguupacaucgcupaccccpcucugcagccacaacc\n", + "gugauggugccucaaagcaguaacuuuuugcuuagagcuugagagucaaaguuaaggacccacauguauacuucggcucuagcgagucuaag\n", + "ggaaaacuuucacuuaucucuucuuuaacuuaucguggaaauaaaacagcuguuuugcagauuggacuacaag\n", + "gacaccauugcaguggcuagauuuauuguuuuuuuagcuucuucaucuacaagcagagaugguaaaccuugcauauuuuugaaagcauuugaagaccucaaaucaacuguuuau\n", + "guuccagcaacaaauuauauauauacaccccugaaucaacuuaapugguacaauugucaaugucuaugguguugugaaguucuuuaagcccccauaucuaagcaaaggaacug\n", + "agcgugcgugugacgucaccugcgcgcccgccuaaacucuuccuapuucuuucuagaguacgg\n", + "agagcgccgccgccgccgcugcugcagcagcagcugcucugcagagugguggccpccapccpugcccucccucccaccuucucccgcc\n", + "uccuguucccuugcugacacagaggaguguuccugcuggcaaugaucuaaucauagugcaguaagaaacauggcaguuugauaaaac\n", + "aauccuuacuuuggauauuuuggauaucauggcuuupucgcccuccuuauuauucagaagaa\n", + "paccuuaaaggacuuucauuucucuccccuuccuucaucucuccuccuucacuuaccuucauuuauuauucuaggcaugacaagugucagaugucugauuugaagacuaauaugaauauaucuag\n", + "guugagaacagacugugagcaugapagcagcuacugcaguaguguugauggugucuggucuagagguguggcuguggag\n", + "aguugugugaccuucgaggauguguucguguacuucucucpaggagupaacuccuugaggaggcacagagauuccuguaccgugaugug\n", + "ugaaggcugaguucuagagaucpucggcuuucuacgcggcucucguggaaccuagcaaagaaagacagugaagacugcaggaccuuccuucgcgcuuuuguuacaaucc\n", + "gaaaccuucucupcugcaaggaccugagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "upcugcaaggaccugagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "agagaaaccuucucupcugcaaggaccugagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "gagaacuacaagcagaugaaagcacuaguaaaucagcuccaugaacgaguggagcauauaaaacuag\n", + "gagguggugagaaagcccgagcacuucacauaucaagaggaaaacuauugcccagagaaagaauugacaaucucauagacccagg\n", + "gucuccauuucuggaauuaucccaguuugcagguuaccaguuauaugacaaugaggaggugccaggagguggcauuauuacaggcauuggaagaguaucagg\n", + "gagaaaccuucucupcugcaaggaccugagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "agcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "augcaaacgaagacuggacccccaaucagucugauugguuguggacagcaaccauucagaggcuggaguuaagguucaaacuuggcaaagcaagccuccaccagca\n", + "gaaucagagaaaccuucucupcugcaaggaccugagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "accuucucupcugcaaggaccugagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgcc\n", + "gagcucagcuuccgccccagccapaagcggcapaaagcaccggcuccaggccagcgupccgcucucucgcucggugcccgccgccaugupccguccugag\n", + "apccpcggccgaggcuccaaugagcgcgcgccgcguccpccggcuggugcgcgagacgccgccgagag\n", + "aauguaacaguuugcaaaccgagaggaguugugaapcgcpuppcgcugccggccucgugg\n", + "aguuugcaaaccgagaggaguugugaapcgcpuppcgcugccggccucgupuacguucgugccgcgucugucccagagcupccgcaggagcggaggcaagag\n", + "guaacaguuugcaaaccgagaggaguugugaapcgcpuppcgcugccggccucgupuacguucgugccgcgucugucccagagcupccgcaggagcggaggcaagag\n", + "gcaaaccgagaggaguugugaapcgcpuppcgcugccggccucgupuacguucgugccgcgucugucccagagcupccgcaggagcggaggcaagag\n", + "ggauguggcaaagccgaggacccaugcucuuucacuupccuuugugupcgcugcupaugauuagagaaugguuuguacccaucaggapagaapagaaguaggcugaucugcccugg\n", + "aacaguuugcaaaccgagaggaguugugaapcgcpuppcgcugccggccucgupuacguucgugccgcgucugucccagagcupccgcaggagcggag\n", + "gcacuuuacggcaguguggcuggagccgcggcugacpcccgcggucupcgugagugcapaaguggaguauuugcupccpuacc\n", + "ugacpcccgcggucupcgugagugcapaaguggaguauuugcupccpuaccauggacgupcgaacuucugagcuaccag\n", + "pcauggauggagacacgcacacacacaggcaauaggccucaagauuauuggcgaguaaaggcaucuaucuauuaucgugaagccuacucugagcuuuga\n", + "acuuuacggcaguguggcuggagccgcggcugacpcccgcggucupcgugagugcapaaguggaguauuugcupccpuaccauggacgupcgaacuucugagcuaccag\n", + "gapucauugcgaggagcaguagagcugcacugccgaaugucguagccacuagccacauaggcuguugauugcuugaaaugugacuagucugaauugagaaauacu\n", + "cgugaaaaauuuguccupaaggaagcaagaccccuuaacauuuuucucauuucuccuauuuccccauaggcaaag\n", + "paagagugcuguggugagugapauuuugccauggagaaggagaaggacccauagcaguuugucag\n", + "agucugugapaaggagaugccucuuccuucccuucaauagupuuaaacccagcuggcacccucuggaacuacgg\n", + "gaacaauauucuucaagagaaggucacucuaccaaagccaggagcacaguauucucaggaucucaacaaggaagagcagaccaag\n", + "caugcuggcuccaacccaggccaaapuuacaaccaccuauaaccaguccccagccagcuuccucagcuccauauuaccaucacagccugauuacaauagcaguaaaaucccuuccgcu\n", + "gcacagagccacuagauuagucugugapaaggagaugccucuuccuucccuucaauagupuuaaacccagcuggcacccucuggaacuacgg\n", + "acagagccacuagauuagucugugapaaggagaugccucuuccuucccuucaauagupuuaaacccagcuggcacccucuggaacuacgg\n", + "gcuggacucccgugucccuccgcgcaggcpcggccccggagcgcuggugccggcagaggcggcgacgguggcgccccuccucauc\n", + "gucccuuguggcuucuagaagauaggaaaacaaguggcuccgagaggcgcuucugacacacagcacagcggcpuagagcuggauccuaauugcag\n", + "accgcuggacucccgugucccuccgcgcaggcpcggccccggagcgcuggugccggcagaggcggcgacgguggcgccccuccucauc\n", + "cuccgcgcaggcpcggccccggagcgcuggugccggcagaggcggcgacgguggcgccccuccucaucaug\n", + "gcuauguaaagcggccpcucpucgugccaccgcuggacucccgugucccuccgcgcaggcpcggccccggagcgcuggugccggcagaggcggcgacgguggcgccccuccucauc\n", + "cuucucccguuggcaacgguuacaucaagccuccgguuccaccugcuucuggcacgcacapagaaapccgccaacc\n", + "agagcgacugccggaagugacugcggacgaaucggcguuugccgaggcuggcauagauuuggcugucuccgcucauagcugcuuuuggcgcgaaag\n", + "gccacauucgcuuccugcuuucggugugucuguugugucuuguugcpcaccgcagucgccgugaag\n", + "acucaucucugcgcgucucuucgccacauucgcuuccugcuuucggugugucuguugugucuuguugcpcaccgcagucgccgugaag\n", + "ccaccccuucccuccuccauuuccauccauuccgcgaucgcggcggaccccaccgucaucgcgcgcc\n", + "aagupccaccauaucuggaaacuacagucuaugcuuugaagcgcaaaapaauaaacauuuaaagacucccccpaccuggagg\n", + "gcpupucgguguugcagcpugagupcccuguccuuucuccccagcuccugccccggagccpcccuggcgaggcagga\n", + "gcggccauuguccgaccccggugcggcugaggccccuuupcagccccuccgcagaucagaauuggagauaaccgaggcuucggcpcpaggagcugcccgaggcucugg\n", + "aagagcauuuuaagaaucauaauaguucagugcagauguuccupaggucaaguuaagagucaaaaauaauucauuagauuuaacaauuuagcaug\n", + "aacaaaaacuggcggcgaggaacugcggagaacuguugcccugcaccgcuucauuuugugcagccugaaapcaaucacauaaggucgguuuuguaauauacagguaacauacag\n", + "uuccucuuaggucuuggacugguguggaucgcugcugccuguacuguaauuuuggaaaugcaggagaaa\n", + "acaacaaaaacuggcggcgaggaacugcggagaacuguugcccugcaccgcuucauuuugugcagccugaaapcaaucacauaag\n", + "gucgcgcgaccgccauuacaacaaaaacuggcggcgaggaacugcggagaacuguugcccugcaccgcuucauuuugugcagccugaaapcaaucacauaag\n", + "pucuucuauaaaagcgccugucgcgcgaccgccauuacaacaaaaacuggcggcgaggaacugcggagaacuguugcccugcaccgcuucauuuugugcagccugaaapcaaucacauaag\n", + "gagcauuuuaagaaucauaauaguucagugcagauguuccupaggucaaguuaagagucaaaaauaauucauuagauuuaacaauuuagcaug\n", + "guucacagcaaaacugagcaguaaauaguguucccaucuaccccguuucaacacuaguacagcaccagagug\n", + "auuacaacaaaaacuggcggcgaggaacugcggagaacuguugcccugcaccgcuucauuuugugcagccugaaapcaaucacauaag\n", + "auagcugcuauggcupcgaucucagaggaucgccugagucgcucacgccuguaaucccagcacuuaggaggccgaggcpuggaucaccugag\n", + "gucuuauguucucagcacucpugcuugucaaccagccuuuuggucugcauuugaaaguccccuuccagagccucgag\n", + "gcaaucucupccccuggaucccugcugaggugcccaugguccccuccauccccacapcagccuguguagugcupuapcccaggccugucccacggaagac\n", + "uauaaauguccuapaaggagguuauugccuuuagccccuuuuupaagcgucuggaaguaaguccugagga\n", + "agcuggaaagaupcaaggcagaagcupccucagacacaggcapacaupccgacugcccaccuccuggccccugaccaugguggagupaggucuggauggagcagugagaag\n", + "gugcaugcaugugaguguggauagagaauguccuucauuaagcugcuguggccucaugaccaugacucauaaacuuacaaucaagcucugcuggacagaggagaccuguccccagg\n", + "acccaagccccagcccggccuccgcuccggccgccgccaccgccccuguuuuguuuccauggcgacaggcggcgcapcccgcuccaaacauaacgcgcuguggaaaac\n", + "cagupugcaaggaguuugguuugugucugccggccggcaggcaaacgcaacccacgcggupaggcggcuagcgugguggacccpccgcguggcccuguggcagccgagcc\n", + "ccuacagccuggcucccgcgacgccggaggugaagguggcuugcuccgaagauguggacuugcccugcaccgcccccupauccgcagguucccuacacggucuccupucaag\n", + "gcagaagcugaggaagauugucauucugauacugucagagcagaugaugaugaagaaaaugaaaguccugcugaaacagaucugcag\n", + "augugugcuuuacagugugcccagcauuuuaccauauacuaacugguucaagucugaaaggcaccucugcuuugagucugcuugccagagauaagauaggag\n", + "gaggapuuugcaggacagccpaaaaugucccuucucggcucacugaguauauugaaccagucucgguccucucaapauuuuaucagaagcauugagcauagauugag\n", + "agaagaguauuccuuuccacuuacaacuaaauaagaccugcuuuugcuggagcugugcuaggcugapaauuccacacugaauuuuacaagcpauggauuucucuaag\n", + "ggaaaaaaugguaauccaguggcagagaauuuccgaauggaagaagucuauuuaccagauaauauuaaugaaggacaaguacaaguuagaacucuuuaucuuucuguggauccuuacaug\n", + "cguuguagaaugaaugaagacacuggcacugauuauauaacaccuuggcagcuaucucaagucguugauggaggagguauuggaauuauagaagaaagcaaacacacaaauuugacuaaag\n", + "gcgcgccugcguacugcggucagapccgaggccupcgagcupucgugcaguacagccucuuuccggcaaaucacgcgagauuucguucacccpcuccacagg\n", + "aucgccagaauggcugaacccaggcgcuuucuacggcucucuuuccucuuggucagcuccaaguaugagauuuaugaacguugaagag\n", + "ggcgaacgcuguuggagaagcuguucagccagcaggagaacpccuccagaagaagcagagaaguuuugcucccggaucauugcc\n", + "gaacgcuguuggagaagcuguucagccagcaggagaacpccuccagaagaagcagagaaguuuugcucccggaucauugcc\n", + "gcacuuggcupugupucupcaagaucuupcccapucuaccuguaupccaggcucagccccuugaagaccccuaguc\n", + "ucgcuccggccccgccuccgcccccggcuggcgugagcupuguuuccugccucucucaguccpuuuggagacuccugcguccuccgacuuuuc\n", + "aacaaagauacuuaugagccuuucugcaaggucccugugaucaccucauccaaggaagaacaaaaacuuauagcgacuucaaauaag\n", + "uuuccccaucugcacpcaggagugucuggaccpccugagcugguuaacugcagcgcupcgcccgccuggcugguuaapcggucpuggcag\n", + "aauuacaaauucccaaugcaguuacaggauccupaagcagagugucuggauggaaccugagcupucucugacucacuucugacuuuag\n", + "ggugaagauggapaaucugauaaagacaucuuauaaauucaacagacacaaaagaauuugaucucccauaagcaacugugaaauuacaauaacagauccupaaguucuacaauucuaauucag\n", + "aaugcaguuacaggauccupaagcagagugucuggauggaaccugagcupucucugacucacuucugacuuuag\n", + "uuacaggauccupaagcagagugucuggauggaaccugagcupucucugacucacuucugacuuuag\n", + "guacagaggugcaguuccaugguacaccauaaaucuugacuuaccacccuacaaaagauggcaugaauug\n", + "cgcggcggapcguggccugcccccggcccagccggcucuucuuugccucugcuggaguccpaguggcguuggcugcuagagcg\n", + "ggapcguggccugcccccggcccagccggcucuucuuugccucugcuggaguccpaguggcguuggcugcuagagcg\n", + "cccggcccagccggcucuucuuugccucugcuggaguccpaguggcguuggcugcuagagcg\n", + "augaauauuuucauauggaagauagaugaagacuucacaagaaagaaaaugcuugaacugaaucuuggaaguuagaaccagcaguucaccag\n", + "ggaaagaugaugaapcccugugcugugugcccugaaaaucugguuupaggcaaaucccaggacagguugcaacacacauggcugguaagugcagauaauacauccuaucag\n", + "aauucugacugaguaaagaaggaacagccauucuguuuagcacgagaapauguuugguguuuugugcguugcag\n", + "ggcacgaaagccaagcgagucccccugccgagcuacucgcguccgccuccucccaagcugagcucugcuccgcccaccugaguccuucgccaguuaggaggaaacacagccgcuua\n", + "gcccccggcccagccggcucuucuuugccucugcuggaguccpaguggcguuggcugcuagagcg\n", + "cucuguugccuccupucuupcccpccguuupcucgcgguccpagcggcgcpuagcgcggaucccccug\n", + "ggacucggcuuguuguguugcugccugagugccggagacgguccugcugcugccgcaguccugccagcuguccgaca\n", + "cugucaagaggapcgccugccuugcuccpccucucuguugccuccupucuupcccpccguuupcucgcgguccpagcggcgcgg\n", + "gaaccaaacaggaaauauuccaaguagaauuaaaccuucaaaaugcuucuucggaucaucaapaaugacaagacauaucacugcaaag\n", + "acagaaucccgguacaucgaggcpacggcguggaapcgguggugaugccugcuguccccccucccggcgcgguupuggcgccucagcgg\n", + "agugapcgccgcggcggcgcgcagcacggcpaacauggcgcgcggaaccggcgcgcgcgccuagcuggcpaccguuagcucgaggcggacgcggcccpccccgup\n", + "guugupugaucaupcaagaggcuuuagaaucugcucauguuugccuaauaaaugcaacagccacaggaacugaaauucuuaaaaacuugguacuaccag\n", + "agugcgccugcgcgcuuguggagcugguggcggcgcuccgcapcucggcuguuuuccgcgcggcaggcgcggcc\n", + "cgcgcggcaggcgcggccauggcgcagcupaaagcugcucaaggagcagaaguacgaccggcagcugag\n", + "gugucuucuacgugccauacuuugauggagaaaacaggcguuuacgguccaucugguucuucuaggcgauuccuccauacauuugacagcugucupcccuuauggagcauacaguggaguggaaag\n", + "ugcgcgcuuguggagcugguggcggcgcuccgcapcucggcuguuuuccgcgcggcaggcgcggcc\n", + "agcugguggcggcgcuccgcapcucggcuguuuuccgcgcggcaggcgcggccauggcgcagcupaaagcugcucaaggagcagaaguacgaccggcagcugag\n", + "cagugcgccugcgcgcuuguggagcugguggcggcgcuccgcapcucggcuguuuuccgcgcggcaggcgcggcc\n", + "gcgccugcgcgcuuguggagcugguggcggcgcuccgcapcucggcuguuuuccgcgcggcaggcgcggcc\n", + "gaggcgccgucuggcucaggcupccggcpagcgcgaacgagcgacggcggaacccgupccuguggacugcagccucggcggucagcag\n", + "uuccuguugccgcgauccpccpagcugcpcgcccpcgcccgaggcuucccggugcgcuccgccag\n", + "cuguugccgcgauccpccpagcugcpcgcccpcgcccgaggcuucccggugcgcuccgccag\n", + "agucucccaguugcgapcaagcaaacccgucaugagcaacucccuuccccaucucugcucacc\n", + "agucugucgccaccucacuuggugucugcuguccccgccaggcaagccupugagagcacagaggagupccpacc\n", + "ccuggaguuccggccaggccacugcuupaagcaagaaggugaaggcaccucugcupccaagcacucuuapccgapcacugcagcugacaagag\n", + "ggaguuccggccaggccacugcuupaagcaagaaggugaaggcaccucugcupccaagcacucuuapccgapcacugcagcugacaagag\n", + "ccpccgcgcggcugccupaggcuccpccagccgcgguccagagcgcgcgagguucpagcucggccaggcugcugguaccugcguccgcccggcg\n", + "cagccgcgguccagagcgcgcgagguucpagcucggccaggcugcugguaccugcguccgcccggcg\n", + "ggucucacucuguugcccaggcugcagugcaguggcaugaucauaguucacuucagucuugaacucccuggcucaagagauccucccaccucagccucccaaguagcugaccacag\n", + "gcgcggcgcugcupuucuccgaggcgaccuggccgccggccgcuccuccgcgcgcuguuccgcacuugcugcccucgcccggcccggagcgccgcugcc\n", + "cuggccgccggccgcuccuccgcgcgcuguuccgcacuugcugcccucgcccggcccggagcgccgcugcc\n", + "ccgaggcgaccuggccgccggccgcuccuccgcgcgcuguuccgcacuugcugcccucgcccggcccggagcgccgcugcc\n", + "agcggapaggaggcaggcgcggcugccggcggcupacugaagapacpucccgcggcgagcgagcuccugag\n", + "aauuucaauuugaaaccuagcggapaggaggcaggcgcggcugccggcggcupacugaagapacpucccgcggcgagcgagcuccugagguacggcgucp\n", + "aauuugaaaccuagcggapaggaggcaggcgcggcugccggcggcupacugaagapacpucccgcggcgagcgagcuccugag\n", + "gaggaggcaggcgcggcugccggcggcupacugaagapacpucccgcggcgagcgagcuccugagguacggcgucp\n", + "gucapaauuucaauuugaaaccuagcggapaggaggcaggcgcggcugccggcggcupacugaagapacpucccgcggcgagcgagcuccugagguacggcgucp\n", + "gaacuucggcuucauccugugacuugcucagaugucuuuaugugauccauaguauuguagaaaaaccucagauucaaaugaaagauaug\n", + "aucgagccugcgugcugccgaagcapcgccgaguccaugcgaacugccaucugauccgcucuuauca\n", + "gacagaccugcggauugaagcggcagguuuucccuuccgauuucapaauugcuucuuacugugacaaaugauuagcuguuaucucugacugaauuugauuucuacaagcagcugagucag\n", + "gaaggaaapuccgccuagcccugagucaagcggucuuacuguaccgccgugugcauucccucauacggucaggaguu\n", + "aucauuuaguagagcuuaaaaguauugccguagugguuggacuuucucuuuccuuucuuaapaaaaaaaaaauucuacuggaacuauuuaapaaccagugupagc\n", + "aaccuccaccgaguuuucaggauucuccuccucuccugccugccuccgaggucccccuucuccaaguuuugacaguuucaacugaaaaaaugcagcgccucucucgauuuuuag\n", + "acuucgcggcuucuucaugcuuuuucuucucaccauuucuggccaaaacuacaaacaagacuucgcag\n", + "acacuuaacccaucuguuuucucuaaugcacgacagauuccuuucagacaggacaacugugauauuucaguuccugauuguaaauaccuccuaagccugaag\n", + "ucuaaugcacgacagauuccuuucagacaggacaacugugauauuucaguuccugauuguaaauaccuccuaagccugaag\n", + "gacuguuucuuuuuccaaaagaggagcucaaaagagaaaguucaucuagaaaucucaaagccaugucucag\n", + "agaguggcccaaccpagcgcagccgccagcuccggaaggcgcpaccccaggacccggucccaggcugccuuugacccuggcacacuguccuaacgccuggaaa\n", + "apcagugacccpaggaagucaccaggugcagaggaccgugcccugupaccugccugcaggcugcugaca\n", + "apcagugacccpaggaagucaccaggugcagaggaccgugcccugupaccugccugcaggcugcugacagupuaccag\n", + "gcacugcpccgccpccucapaagagucgcgcccccpapagcagcacuggcccauucugcag\n", + "gugaauaauuuaaapccgugccugcggagccpcggaacgcuagcgguguuggcgcggaguggaccccggcugcggccccugg\n", + "guguuuccacaccgguagccagcugugcccugagguggaagaggaccggccacccaggaauuuuccaa\n", + "acucccagcucgacaaccacugccaccccccaagcucggcuugucaccugcccuaggagacgcagccgccggacccugcccapcacccacgccucggcgaccacc\n", + "gucugcccgcugccucuugucuagcugcugucaggagcugacugccuccapcuggaauccugugcucccucugugcccag\n", + "auauaaguauacaguuaagcucagcccagucucguuguacucuucuagagaagcaacuagaauauacaaagaga\n", + "ugccugguaccuaguacaaacuuaauaaaugugugacgcaagaauaaaggaaugaaugaauggaagaaugauauaaugccacagaacuuucaaag\n", + "guugccugupugcccgcgaaccaacgguuagcgguggcapcugacugagagcgucugcuug\n", + "pccaccgcgacguugccugupugcccgcgaaccaacgguuagcgguggcapcugacugagagcgucugcuug\n", + "gcgacguugccugupugcccgcgaaccaacgguuagcgguggcapcugacugagagcgucugcuug\n", + "auucagguuaugcuuucuggccagaauacugcauaggugauguugcguccuucuccagguuucauauccagaggcacaugguggccuucuaccucucacag\n", + "gacguugccugupugcccgcgaaccaacgguuagcgguggcapcugacugagagcgucugcuug\n", + "aagcgcccccggaggcgcuaagcuugcgcccugaggcgguuuccguucccggacguuuggacucuguccuggagaapaaggaaaaa\n", + "aaacuacaacccccapccaccgcgacguugccugupugcccgcgaaccaacgguuagcgguggcapcugacugagagcgucugcuug\n", + "pucggagcpcggcggcggapcgcggcgcgccpaucgcpagcpcagcpacggcggcggcgcggcccgcgugacccagcgccgcgccccguggccccgccgcagg\n", + "gaguccuucuuucacupcguucggugucacugagccaggcugcuauggugucaucgauguugacacupaagucgacccuguuugugcccaggcuuccugccagccaugccaccugg\n", + "acgugacgccggugccpcgaacauggcggcggccaccpugagugcugcgccucccucgcucuuucccgcuggcguggagapc\n", + "gcacuucacgugacgccggugccpcgaacauggcggcggccaccpugagugcugcgccucccucgcucuuucccgcuggcguggagapcaupugucccggccggaccgcgg\n", + "gcaaggccccacgcagccuccgacucacccacugcccguguguauuucaggaggcugcaucccccaaggcccccaccag\n", + "accggcccaggauuagcgcccupagcgcgcgccccgcugccucgccgccacacuuuccupagcggcggccacggaggcacc\n", + "cccgccuuccuacuaccggcccaggauuagcgcccupagcgcgcgccccgcugccucgccgccacacuuuccupagcggcggccacggaggcacc\n", + "apcuuccgcccucucucccuggccpagugupaagapcuuuauuucaaugcuugagaguapucaauggccagg\n", + "cguuuagacupccagcagacaguucuagagacuucaaguuuguugucguuuuuaaaaguccugccaaugcccagaaacuuagapacaagaag\n", + "cugcaaucuccacugacuacaaccuccgccucccpuucaagugauuauccugccucagccuccugaguagcupauuacag\n", + "gcuggaguacgauggcgcaaucuccgcucacugcaaucuccacugacuacaaccuccgccucccpuucaagugauuauccugccucagccuccugaguagcupauuacag\n", + "ugcacuugcacucuaaggaagcugaggupaggcpaaaguccacagaggaguuuaaagcagccaugccaaaag\n", + "aauauagguguguuguagagucaggcagaacccagaacgucuggagaugaauguapaagaaggaaggaccagcaaguucuuccag\n", + "acugucugaaagacuacucaggcgugcacugcgagguggagaucugacuucucuuguucccgcuuaagacugccuccugu\n", + "aaaagaaaaaaaucaaccaaagaaaaggcuggacccaaapaguaagguguccgaggaacagacucagccucccucuccugcaggagccggc\n", + "uuucugagagcuuuacugacugauuucccuauucaaaacaauccucauuuccuacauuucugaagaucucaagaucuggacuacuguugaagaaauucccaguaag\n", + "uuuguaaggucucccapcgccggagcgcagugucgucucuguggcgcaaucgguuagcgcguucggcuguuaaccgaaag\n", + "agccccacacgcagcguucccagccaggcgagagcagguggccgcggcpcuccgucucugccccgcag\n", + "cucaapuuggauggcggaggcuuugugcuuguguguuacugaacggacguuucupuccucccauuacuccuupaaggagaauupaagagaagucugaggcagcaagaacugaag\n", + "uacuuccgapugaguggcuucaccgccggucccuugcagcgcugccuuucgaucucuccacaucucgguggcgcpaucucaag\n", + "acuuccgapugaguggcuucaccgccggucccuugcagcgcugccuuucgaucucuccacaucucgguggcgcpaucucaag\n", + "pugaguggcuucaccgccggucccuugcagcgcugccuuucgaucucuccacaucucgguggcgcpaucucaag\n", + "agccucggcuacuuccgapugaguggcuucaccgccggucccuugcagcgcugccuuucgaucucuccacaucucgguggcgcpaucucaag\n", + "gaguggcuucaccgccggucccuugcagcgcugccuuucgaucucuccacaucucgguggcgcpaucucaag\n", + "ggacaaacuugaacacaaaggaacacacguuauauguacauuuaauacuggaaccgaaaagcugcuugcagugaaaagcaaaccacuucuaaacucuuugagacuuuuuaaagaag\n", + "aaaapuuguuguuaccaacuugaauggucacaccgcccgagucaauugcauacaguggauuuguaaacaggauggcu\n", + "ccccuucuacugaauuaguuucuggaggaucugauaaucaagugauucacupaaauagaggauaaucag\n", + "cugccagagcaaacacccagcccapccccuggauuugagcagugccucggagcagapauaucugccgcaucag\n", + "agagcaaacacccagcccapccccuggauuugagcagugccucggagcagapauaucugccgcaucag\n", + "pcgcpcgcaggcgaacggcugccggucagguguccuuguccccuugaguugcgcpucguguucgapc\n", + "cggcuugccucgacacgccuaggcgcccuccggcuccgcccuagccgccgcgucccagcuagagcuccagcgcccgcucaggccccacucgaccucucpccucggcuacuuggacugcggcggaau\n", + "uguuccuggaugagccaccuccauguugagccuguaaaacuggccuaauauguucucuaugagucacugcauugcucugcaaaucagauaaaacgucacucguag\n", + "agagauggaguuauuucccuagaaucacacgaucauaauggcuuguauaagupuuccaacuguuugccaaguacuguu\n", + "aaucugccuuaggaagcuguucugaggaucuccauccccccagaaagaacuggccguuguggaaacccaa\n", + "augaugaauccgagacuccugaagaacuggaagaagagauuccuguggugauuugugcugcagcapagg\n", + "pcauggucuaguggcccagucaggacgcggaaacacucccuggagguucugacccacucccucucagccuccgccuggucucug\n", + "cuggagaacuccuggaaccuuuaagcccuggcucagcccucagcucugucccaucccagcugaccucugugcucugcgcccgagcuccugagcccac\n", + "auugucacugcuguuccaapcacacgcagapauuuggaauuccuggagaguugccuuugugagaagcuggaaauauuucuuucaauuccaucucuuaguuuuccau\n", + "ccucaccucgcccggacggcggccuucggaagucggcgccugccagcuacccgccgccuccucagcaaucuuagccgaccpapcucggcccaggucaccggcagcccaggcgcag\n", + "gcpagcauccaaucaacuucgagagcguaggccccaccuaucgupucgaguugcuuggcggucgugguuccggagguuccucp\n", + "aaaagaauguaggaaggaaggaaggaacgaaugaacaupagcgcagapaggaggagagaggcupuggauucaguuucagacuggacaaucug\n", + "agcgccucgcpucuggcccggaguggapcgcgcggucccagcccucccgcucggccggcpugucgaguucag\n", + "cccuapaccucuuucuccuggacauugaagauauggcccuuuggaggugacccaggagagaap\n", + "ggcupcaucpcuggcuggcaucgccpagccgacggcgacpagccccgcpcpapcggcgcapcagcpugcggugacaccugupcacag\n", + "pcuuucucugugguccgacgcugugucaagcucugcaccggccaugaguaugcagccaagaucaucaacaccaagaagcugucagccagag\n", + "ggucacuggupagcucuuugaagacauuguggcgagagaguacuacagcgaggcugaugccag\n", + "aggcuaggupccuucgagagagagagaggaggcugcguucauuaugugcacucuucuguguuaugugagagcgapucggcagcagcaaguggccugcgugcgcgag\n", + "aggupccuucgagagagagagaggaggcugcguucauuaugugcacucuucuguguuaugugagagcgapucggcagcagcaaguggccugcgugcgcgag\n", + "gugcccgcgagcpagccggagucgccgccgcccgagcgcagccgagcgcacgccgagcccguccgccgccgcc\n", + "gugucgccgccgugcccgcgagcpagccggagucgccgccgcccgagcgcagccgagcgcacgccgagcccguccgccgccgcc\n", + "agucuccgccuugcgagcucagagugugcccgcugcgccgccgcuguccguaccugccgccgccgccaccgccacc\n", + "cgcgacugcccauccaaaccgaggccucgcpcgagucccuuguccuccagcucguugaacupccccpcacaggucggcuggaccagcuuggcgaaccggacagcugcgagacccucag\n", + "agagaagaggagguugguguggagcacaggcagcaccgagccugccccgugagcugapccugcagucugcggcuggaaucaggauagacaccaaggcaggacccccagag\n", + "aagugccacagcauccggagcgccgacgcpaccggaagugacgcagagaaguuuccpacug\n", + "gugcuggccugguuugaggaaggugaagagaccaucacugccuuuguugaacccuuugucauccucuugauccucauugccaaugccaucgupuuuggcag\n", + "acapcgaguggauaagaacuacccacuggucacupcacacugccccugugcuggauauugacugguguccacacaaugacaacguuaucgccagugccucagacgacaccaccauc\n", + "acccggagagguggcuccuucgcccugaagccuuccucggcccccuacgcacucpccccuuccgcagaggauucgcagcgugagcgccccgcagcccgcucaggaccag\n", + "pagcggcccpacugcaccpaccagcgccuccccgcuucgcgcugcccucggccucgccccpcccpuggaugagccgcgcgcccpac\n", + "aacaaupacuuccauagcaaupauuuccuuccgcauucaguuugugccuuucccaugagcgagagacuccuaggagagccgcagcccguuaggaagccaugupaacucauccacag\n", + "uuuacggaapcuugacuuaugaguguggucagagguuuuaggupuuaaugaggaggugagcccaggaggaagcaagaccua\n", + "gagucaccggccccgcccuccggagccggacgcugcpaggcccpagcggcaguggaaccgacucccagaacuccggacgugugcggcg\n", + "cccccacgcacacauuacuccaacauugaggccaacgagagugaggagguccggcaguuccggagacucuuugcccagcuggcuggagau\n", + "cugucuuggccucccaaaguguupauuacaggcaugagccaccacacccagccccugcuuuacuucuaaugacgguucuaauucuccacaauaacccuaugagacag\n", + "gaagcugucgcggacgcgcugaccgagcgcagcggccpccggcpcpcpcggcugcgagc\n", + "uuuucacagccaccuuccuugagccccaucuuucccucuuuccccuagucucuccuauacaaaaaagugaaugaggcucaguaucgcagccaccuggccaaugag\n", + "aagaguuggugaggapagcugcagagagapccggcagugcaguugacppauucag\n", + "gaagacauccggcauccguaaaauggaguaaugauucugacccugcagguuuucupaggauuaa\n", + "acucpcggaccaggcgaagcugucgcggacgcgcugaccgagcgcagcggccpccggcpcpcpcggcugcgagc\n", + "aaguuuacagcuuccugagcacuguuuccacaccugugaucucauuuaauccucaccacaaacccaagagacugcuguuuucugg\n", + "aguccuggcccugagcpaaucgcaguggccgaggcugagcggcagguagaapcgucuccpcuucacapaacacapcuucggcccaaccacaa\n", + "auuucccagcgugccucaggaapcgccaggacugcauuuugcuccggagcguccagaguccuggcccugagcpaaucgcaguggccgaggcugagcggcag\n", + "gagugaugaaucuaagcaggaaugccauccaccuucagagccauuggcgugaggaugacggugugaagucuuuucaaagcagga\n", + "ugagguggacaagguccugucaggccuggagauccuguccaagguguuugaccagcagagcucgccc\n", + "auccccauuuuccagagcpaagccgacgcucaaccccgcgccgcgacuugcccgaggucacccagupccagcggcuccpaccgaggcgcpcp\n", + "aupaggaugagaagcccccgcugcccccgcgcucuggcuccaccagcauuucugcccccacupcccagcaguccccugccagcuccugagacucccacagcuccagcugcugagag\n", + "ccauauuaggaaacccacuggcacgcuccgccguuaucuucgcaagacuuccguuguugccucaaguugcagauugccuuuuaacagagaagaaagugacag\n", + "gaaugugcuggcacugaugacacaguaaugaccaagguaaacaaggaccugcucuagccugacaggcug\n", + "gucuucaguguuuuggccaucucccuaccugaucacccugaagcaacacccacaagcagacaagcucugcccag\n", + "ugagacagcacagaaaagccuccccpaugucuggcagcuccuacuugguuccacuggaaagaaaauaagaggucauuauucacaaacaag\n", + "cpcpuguggccapugupucugugapaccggucggaapcgucgcgcggccucpugac\n", + "puguggccapugupucugugapaccggucggaapcgucgcgcggccucpugac\n", + "ucagaguuacugauuuauucuugagauuccucuacucucguuaucugaccucauggaugaacuucaggauguucagcucacagagaucaaaccacuucuaaaugauaag\n", + "gcacucaccgccuuccugguggacpcuccugguggcugugcugcugcugugagcpccccugcuccuccaugcccccagcucuccggcupupcuuggcc\n", + "paggaggcagupapcggapcpccuucpupcgcccapuapcagguggccgcggcguggaggcapaga\n", + "pcggapcpccuucpupcgcccapuapcagguggccgcggcguggaggcapaga\n", + "gcagagapcacupaggaggcagupapcggapcpccuucpupcgcccapuapcagguggccgcggcguggaggcapaga\n", + "auccucupucggcacuguuggagaacgcucapucuggugcucucgugccugccccuuccaggcagccggcucugauugcacaaggcagaccugugacuccuccauccagcu\n", + "cugcagcggcagcagcggcagcagaggcagcagcaguagccaccacuccgccgaggccgcaaccccggcucggccuccccaggccccgccgcugccgcaguc\n", + "ggcagcagaggcagcagcaguagccaccacuccgccgaggccgcaaccccggcucggccuccccaggccccgccgcugccgcaguc\n", + "cggaggcggcagcagcagcagcugcagcggcagcagcggcagcagaggcagcagcaguagccaccacuccgccgaggccgcaaccccggcucggccuccccaggccccgccgcugccgcaguc\n", + "agcagcagcugcagcggcagcagcggcagcagaggcagcagcaguagccaccacuccgccgaggccgcaaccccggcucggccuccccaggccccgccgcugccgcaguc\n", + "aauuucgaggaugucagauguaaauguaucugcccucccuauaaagaaaauucupcauauuuauaauaagaacauaucucagaaagauug\n", + "gcugcaggcuggaccaapaggcacaupagcuccacapaggccacgcccacgapcagcucacagaauuagaaagccgacpugcuguggucaggaggcgcgupcggcag\n", + "gacggcuccpccgccapccgcuguggcgcagccpcuggcccgcgcugucccugacgcggaucacuggccccucuugagcacggccuugccgguuuggcpugaaagguugcgaag\n", + "gacccagacauaggcuugguggcccgucucuugucuuuccugguuuaugacuuucggcuuuguggaauacggcugag\n", + "gaguucuuuccucaucauccauaaaugucauucauugagcaugugaucagcuucuccuagauagaugaaacauuuugccuccaccaggagugccuugauccuggugagauacacuuuag\n", + "uuuguugcauauucuaaggacccagacauaggcuugguggcccgucucuugucuuuccugguuuaugacuuucggcuuuguggaauacggcugag\n", + "gugcuguauagagagcaguucgacuucaacgcugagccaccuupaaccuagcugaugauappuuccaucucccaacuuguccau\n", + "guuggcacguuggaugucuugguuggcuugucagaugaacuggcuaaacuggaugcauuuguagaagg\n", + "gcupcuggcacgugacuuguucuguguucgcuupuagaggaagccgugaggccggagcuuaggucpaapauggaucgcugagccgauagcguccgcuaggcugucugccucg\n", + "gcagacggcgcugagcgcggcggcggcpagcggcgucgagugucuccgugcgcccgucuguggccaagcagccagcagccuagcagccagucagcuugccgccggcggccaagcagccaacc\n", + "gagcgcgagaggcgcggcpaggagccggcggcgcgcgccucccupcccggacucggccgccucccgccgccucccgcgcggccauggacugagcgccgccggccaggccgcp\n", + "ggcpaggagccggcggcgcgcgccucccupcccggacucggccgccucccgccgccucccgcgcggccauggacugagcgccgccggccaggccgcp\n", + "pcgcaugccuccgagugapccuuggcucacapcagcggcupcagagcugcuggauug\n", + "agaaacaguuccgacucuacagaacaagacgaccuuuaaguuucccagagaaaaugagaugcugauguugaagacgacaccacg\n", + "cuuuuuuacugcagauuuacuuuaaggcucauauucuccaagucuauucugcuuuaaaaagaagacaagaaaagaagugguuuaucaaaaucacguuauaaucagauuuugaccaagcauuuuguaag\n", + "auacaguuuguuuauuupcacugcaguacaucuggcugaagacaaucaacagcaggccuauuaucuguuccgug\n", + "uauacaaaugucagccaaugacauauaacaaccauuucuuauaaaaccuugauguucaaaagccugacuagcaguggcaucc\n", + "aacacapcupcaggcagaucagapagcugapaggccugaccugaggccggcacccggagcuggcpagccagacccagag\n", + "agaggaaacuguugagaaaacggaacuacupaaapapcucacugagaaccaucccgguaacccgaucaccgcuggucacc\n", + "pccaaacaacacggccpaggcgccgcugccugccpcccucucuucupacccuggauuuucggacacugagcgcc\n", + "gcauccagcccgcacuguggagcapaggacgugcugcacuggcugcgcupcagagcaggaguacucucugccaugcaccgcggagcacpuucgag\n", + "gugacguccuguaugagcugcuccaguacaucaagacccagcggcgagcccuggugugupcccuuuuuuggapaucuucaggcugaagacgcccacccagcacucuccaguccccccggaag\n", + "gccuapccccagcagccacagccapagcgcucaagacagaaagccgguggcuuccucaccuccaccugua\n", + "gcauccagcccgcacuguggagcapaggacgugcugcacuggcugcgcupcagagcaggaguacucucugcc\n", + "ccaguucucggagccagguuapuuuggcggaggaggacugcpcgcpccuapccccagcagccacagccapagcgcucaagacagaaagccgguggcuuccucaccuccaccugua\n", + "aguaacuuccucccuauaacuuggaaugupuggapuucauaguucucccugagugagacuugccugcuucucuggccccugguccuguccuguucuccagc\n", + "acuccagauccugcaggcaucuccccauccucagcuguuugccagucccaggaaagcacuucucaacucaccaacuccaguagaaagaapuguuaag\n", + "auggagaaguaacagcauguguuuauccugauggaaagaguccaguagagaggaagagauugaugauguaggagagaggagaaaugcuggaa\n", + "ggcuuggugaggugacucgcggucgcpugacucgccggcaggacacugccuggaacgccuggagcgccucccacugcagacgucuguccgccuccagccgcucuccucugacg\n", + "pcggugacggaggcucuggugcaccuuggcugugagcugcagaggagcagagagcggcccggcgcggcugcgcpaggcpcgcgcggccpagguucupcuggugugugcggagcgag\n", + "augagauaccuguccugucugaagapagaagaggaagaagagacuuauucucaaaaaguggaguccguggauaaagugcgag\n", + "cuaagcgugugucacugagaaccgaaucucuaggccaaccucuaaacagagaggaugaagaaauggacaaagagauuucagaaaaacucccuuccaaa\n", + "agaacugcgaagcacaucauggaaaagaugcaucuccacaugcucuguaccccucuucccgaggaguuccuggaccaaaacgugguguuuuuccucagaaauaccaaag\n", + "aggcaaucucugaagcuaccgacaugaaggaagcuauggaaauuaugccagaaacacuggaguauggaauuauaaacgcuaaugugcuccauuuucugaagaauauuauaugucag\n", + "guuuuuuugccagcauuguccuucaaucagcacaggacgaguacaaccgupagucacaucuggagaagucucuaauuccucugagcaugaaucagaccugccgccc\n", + "uuccuccucuggucgaccagacuauugucuauuaaacaguagcaagagaggcucaggagaccacugcauucuguuucuccucugauaag\n", + "cgcaggaggcgcgugcucagugugcupuaccaggcgacuccpacapucucggccgucggcguc\n", + "ggcgcccgcccccgcccccgccgauuaaaupccggcpcucagcccccggaaacggucguacacuucpcugcgagcgcggapcgacgacgacgaagcgcag\n", + "cgagaacucpaagccggcgagaagugugaggccgcgguapccgcaucccgcuccggagagaagucugaguccgccaggcucugcaggcccgcggaagcucg\n", + "ccggcgagaagugugaggccgcgguapccgcaucccgcuccggagagaagucugaguccgccaggcucugcaggcccgcggaagcucg\n", + "guaaccggccpcpcgccgcgcaggcggaggagcguacugucccgcgcugcgccgcgcggcg\n", + "aauucucugagcuggugacaggugccacaggcacupaucucaccagaaaggaaccgacggagcuapccagcgag\n", + "gacaaauccuuggcccucuccaaucuucucaguuugccugaaauccapuupcaggucagcuucugaaagcccuuccag\n", + "guaacaacauggcagcucccaugagaacggcaugguuggagucagaagaggaagaagcagaacupcag\n", + "paacccupccaguccucucucccuugagccacggaggaucuguauguagcagguggcucuacaugguggaggugupaggcaacaggauuggcugacucacuccagagaag\n", + "cccacauccuccacgaccuggccauggcaguggugguuacagucaugaugucucugcagcucucagcagcpaagcugagcagcpcugcccuggcacggcuggcapcagcuggagucc\n", + "agcgucuggccgauuupacgcpcagucgcuuccggccccggcucccgcacauucuugaggauupccp\n", + "agcugupucuguaacaacauggcagcucccaugagaacggcaugguuggagucagaagaggaagaagcagaacupcag\n", + "gacuccagaccccauccucccaacuccacccacuuuagucuccauggagacccaapcggcuuuapccucuggcacugaagauggaauagcuuugccuuguggaucugaccuccugg\n", + "gacuccagcgcuccuaaaggcagacucucapcuuggaagguagaagcaugcuacaagaaggcaaugucuguucaaag\n", + "gaccagcugcaaagacucagacacucagccagagacagcagccccugccacugccccaccauuaccccccauagaguccccaccagcacc\n", + "apcagaagagcccggagaguccggcggacgaagcpaupaupagcpagccaccgagaguggagcgagacacgcpcccggacupc\n", + "gagccugccpaaggaaggaagcpaapagccgccgccgcagccgccgccgccguggaguacucg\n", + "aaacagagcugccgcppaacgcggaccucuuuuccccgagcccapucggcupccgccgccaggcaag\n", + "gcggccgccccauucccagaccggccgccagcccaucugguuagcucccgccgcuccgcgccgcccpagucpagccgcpaaccpcaccugcacccgccucupag\n", + "caugagcagagaucauuaaaaauuaaacuuacaaagcugcuaaagupaagaaggagaacuugaagccacaauuuuugcacuugcuuagaagccaucuaaucucag\n", + "guaaaccaauagcccccaugcucugugcgauuucauugugugcucgcguucgcaagcuccguagugcaggaaggugcpaag\n", + "uggaggaaccuguaguuuuccucuccccpccagaaaguagccaaaacgaaagagcgcccgcccag\n", + "ggagcuuccacucggcugcpcuggagcggcggcpcaggcgugcggaggacacuccugcgaccag\n", + "ucgaacuucucaacccucagagacuuagaucuuccaccucacucccucagccaagccuccaggcccccucgugcauccgugguggccucucugccuucucuguucuguucuccccauggcccagac\n", + "guppcguggcagcccggcccgupcpuuuggaggagccaguguaaugcuagaaguccuagaagaaauuuggagugugcgugcgcgccgagcg\n", + "ccucccuccagucuccggaucucccucggucccucucuccuccucuuccucucucuggacgcccggcuccuccgcacccccucccccpucccgcggccu\n", + "cccaccaccagccccucugucucccccacccccagccccaacugccccccaaccuccupauccccuc\n", + "cucuccuucagugaggacccacuggauuuguggcugcupcuuugaagagccaggagugacuucuaaucuggauaucuacagaguuucuagacugagaccauucauaguagccuu\n", + "caggcgagauuacgaggcgaggcucgcgcgcccgcccccgcccuggcccccagugcccacccggucggcccggcacagcc\n", + "apcpupaaggaucgcaggcgagauuacgaggcgaggcucgcgcgcccgcccccgcccuggcccccagugcccacccggucggcccggcacagcc\n", + "cugagucagugcugauucucucaaauagagcuugaaggauaaaucuucauuuuuguuucaacaaaacuucgaaacaaa\n", + "uccgcgacgagcuuuguuuuuucgguupcaugcugcuuaccgcaggaugauggaagcgacggcccguacaaagacagaagcguugguuuca\n", + "gcacuuaaggagcucpccagcgcgapagcapaggaagcccggcugcugcggaccuccucggacccggacccagccccagcccggccccagccagccccgacggcgcc\n", + "apagcapaggaagcccggcugcugcggaccuccucggacccggacccagccccagcccggccccagccagccccgacggcgcc\n", + "ggagcapaggaagcccggcugcugcggaccuccucggacccggacccagccccagcccggccccagccagccccgacggcgcc\n", + "acuggcggcggcagcggcggaggcgacgguggcggcucucggagccggcgcgaauccggcccccgcagcpacccgg\n", + "gguuggagagaguppcggcggcacagupccpaggagagagccgcagapaaaccgauuuuaag\n", + "auucauuccguuuuugcggcupuuggagagaguppcggcggcacagupccpaggagagagccgcagapaaaccgauuuuaag\n", + "puuggagagaguppcggcggcacagupccpaggagagagccgcagapaaaccgauuuuaag\n", + "guuggagagaguppcggcggcacagupccpaggagagagccgcagapaaaccgauuuuaagaugaag\n", + "agagaguppcggcggcacagupccpaggagagagccgcagapaaaccgauuuuaag\n", + "ggagagaguppcggcggcacagupccpaggagagagccgcagapaaaccgauuuuaagaugaag\n", + "gccgaaaggucuggucgcagagacaggaacguguaauccucagcgugcuccagcccacagcuucgcucuacugcucggcapcagcuggccucupcaccggcggccccucugccucgcggaaaag\n", + "gaaaggucuggucgcagagacaggaacguguaauccucagcgugcuccagcccacagcuucgcucuacugcucggcapcagcuggccucupcaccggcggccccucugccucgcggaaaag\n", + "gcaccaucuccugagaagcacucucccuugucguggaggupcaaaucuuuaucagccacugccuucugcugccaggaagccagcuagaguggu\n", + "aucuccugagaagcacucucccuugucguggaggupcaaaucuuuaucagccacugccuucugcugccaggaagccagcuagaguggu\n", + "aguauauaacuguuaggugccucccuccagcaccaucuccugagaagcacucucccuugucguggaggupcaaaucuuuaucagccacugccuucugcugccaggaagccagcuagaguggu\n", + "aaguguuuuaaccaggacacaggaauaucugacagcauuuucuuuguuuccaauuacagcuuuaaagaaaacupcaucuccugcuacuuaaaaucaaaaacuaccuaaaauaaagauuaua\n", + "gacccuuuuggaacuaaagcuggugacgcagcgcgcagaggcaucgcccggcuaagcuuggcccuggcagaupucgcaggaacag\n", + "gcacucucccuugucguggaggupcaaaucuuuaucagccacugccuucugcugccaggaagccagcuagaguggu\n", + "accaucuccugagaagcacucucccuugucguggaggupcaaaucuuuaucagccacugccuucugcugccaggaagccagcuagaguggu\n", + "cgcguuuugccaguuaugcgaaaacauggcugcggccgguuuggcccuucuuuguaggagaguuucauccgcccugaaaucuucccgaucguuaauaacuccucaggucccugccugcacagg\n", + "cccagcucggcgcucgcccpcuuccccpcugcagagcgcgccugagugccgccgcccgccpcaupagccgcuuccupcggcugcggcagcggaggaggaugcucupcuaggcgag\n", + "gaagugagaaggcaaccaagaacaaauugauaucapagugcacaugucuugccggaugccugcuuucuuccucuug\n", + "gcucugugugcuccpauggagcaggugugcagapugagaacccagcucupaccaagucacuugcuuccuuacuuagcaagacuaucgacuugagcaaacuuggaccup\n", + "ggauucucauucugucucccaugcuggagugcaguggcgcggucuuggcucacugaaaccuuugcuucccapucaagcgauuccccugccucagcuuccugaguagcupauuacag\n", + "gaauccccpagcggcgguggcggcguccupccaggaggagcgaacaccugccgcgguccucccgccggcgcugg\n", + "accugguucaccugcgaguguauuuggauagugucuccacagaaaaugucgucucggcuuggaaucuuuuugccauaaauucuaa\n", + "gcuauaaaacccaggccggcaggaucgcugcacccgcggcggccuccucggugcgcgacccccggcucagaggacucuuugcugucccgcaag\n", + "gguuggacauuggaaaccuacuaagcagcuagaaaguagaaagagaaaugcuuugcaguucuggugcuuuguagcuguguggucuugg\n", + "acucggcuccucuccccccucgcgcccacagcguuugguguugauucgagcpaagappupupaucggupagacc\n", + "aggcgcggagcuggcggcagugacaggaggcgcgaacccgcagcgcuuaccgcgcggcgccgcacc\n", + "agcugcggugcpcggccaggacuuccuppupagcuggcguuggagapuuggaacgaaacaaaaaugug\n", + "agagcpccaggcgcggagcuggcggcagugacaggaggcgcgaacccgcagcgcuuaccgcgcggcgccgcacc\n", + "gcauccugacaaaaacaaagauccuggagcagaagacaaguucauucaaaucaguaaggcuuacgag\n", + "guuacaaauaaaaauuacgucagauuccucucuggcuggcagcaagagaauaagccucauguccuucuguuugaccaaacgcccauugugccacuguuauacaag\n", + "uugacugccuuugcauacaaagauuauuuaucauuuggauauguauaugupuuugagapacggaagag\n", + "cucuuuccccuccccaggcccaggcgagcgcugguguggacpaagcucccggcccggcgaacuaacuggagcacggagcugcagccgguupccgguguacuuucccg\n", + "aaugcgguagcgcpaauuucgagugguguuggagcgccggaggcuagupuggcugacccccagcauccucpagcgacc\n", + "uaaaaacuucuguucagagcaaggacggauagucacugcgauuapupcgacccggappucaugagccuggaccuugacagaucuggugag\n", + "guaaugcgguagcgcpaauuucgagugguguuggagcgccggaggcuagupuggcugacccccagcauccucpagcgacc\n", + "gcgcgcgcgcccuaggcggcggaucuaagcuaacuucuuggaucuuuucuuguuucuccuugguuuuugacuuuuucuggacccuggugucuacgauuuccgag\n", + "gacucucgccugacuuccuaauuugcuacuuauccccagcguuggucccggcgaggauaugcugagauuuauggcacuguuggcugcauuuuuggagaacagcaagcagcuucuuuucag\n", + "gaggcgccaaggcgcucguuuggcgcgcgcgcccuaggcggcggaucuaagcuaacuucuuggaucuuuucuuguuucuccuugguuuuugacuuuuucuggacccuggugucuacgauuuccgag\n", + "ucuccaaggaaaguuugccccgagcccuucccggcccggcguapuucuccggaaaccaucacucacaucuagcacuuggaggccuccapacagcggugacccaccaucugg\n", + "acaguuuaguaugagaucauuuucccuugccugaguuuugagcugauugagaaauaagaaccuacagaugaagaagcaagacaguaccuuuaaaaaaauuagcuuuuuauucag\n", + "uuuaguaugagaucauuuucccuugccugaguuuugagcugauugagaaauaagaaccuacagaugaagaagcaagacaguaccuuuaaaaaaauuagcuuuuuauucag\n", + "gcguucagcggacgcgcgcggccucgaucucuggacucgucaccugccccucccccucccgccgccgucacccaggaaaccggccgcaaucgccggccgaccugaagcugguuuc\n", + "agcagucagcugagccagccccgcucagugagucuguccucupcucgccaugcccccagccuccgc\n", + "aggcuaapagagauagcuaaugaccgguauuguguacugagaucagacuucapaugaagcagcugu\n", + "gaggagagacgapcagcggaggaggcgaggagcgccpuaccpccpagccgcpcucucpaagagacgg\n", + "agugcggccucgguccuggccuggcggcgacaccupuuccagcuuccuuacggaagagaugagcugcggcugcuguuagg\n", + "acuggacuugaacacuaagucuucaauagcugagauucuccaucuuaaucuacuuggaggcaagagcag\n", + "accggauuuccaucpcucccpaggaagagcuccgcggauupuuacgucgccggaagupcpacucuauuguggcg\n", + "aaucuugcccugucgcucaagcupugcagcggugugaucuuggcucacugcaaccuccgccucccagguucaagcgauucuccugccucagccuccugaguagcupauuacag\n", + "aacuagaugaacggcgcaaaaggaggcaagaagaaupagaaaguucgaaaaccugaagauccagaag\n", + "aauguccagaggagguuuaugacccucgaucucuauaugaaaggcuacaggaacagaaggacaggaagcagcaggaguacgaggaacaguucaaauuca\n", + "caauuagugacaacacugaagaccagaaaggcaagcugaagacaccagacuucgcuugaapcaaacaagaaau\n", + "acguuagcagaagaauuccuuuaaacgucauuuuugaggaaguagacaaaccuaaauaugugucugaacuccaaggaau\n", + "gcppuugauuucuaucaccccuapagagaggaucpacccgcugaucuuccagcuccccucacccaacgucgu\n", + "gcaugcugcagacagaccuuuccguccuucaugaacacacgugugguagacagaugacuguccuguacccugugcugcucuaggugugccagacguggagcuguccaguupagaag\n", + "acucugcggcpaagaaccaccuggagguggcppuugauuucuaucaccccuapagagaggaucpacccgcugaucuuccagcuccccucacccaacgucgu\n", + "acagcacccuccugaaaacugcagcuuccuucucaccuugaagaauaauccuagaaaacucacaaa\n", + "caggauuccagaauuggaaauaacpapaggaccugguccagcuucccuuccucaaauaaggaaauugacaccuggcgug\n", + "agacuccuugcpagcgagugcgucupagcccgcggccggagaapcugcpuuapccggcgcccgcgguucag\n", + "gauuccagaauuggaaauaacpapaggaccugguccagcuucccuuccucaaauaaggaaauugacaccuggcgug\n", + "gcuguuuagcuguaauuapugcaaggauaagguguaagaacuggcuggagguugaauguuuuccuggaggaguguuagcaucaacuagaucccuggaauuucugccuuucugucucaag\n", + "agaapuuuugccauguucgcuaggcuggucucaaacucauggauucaapacugcccgccuggaccucccaaaguacugagauu\n", + "ucucauuuuacucaucuguaaaaugaaggcauaugaaauuuaugaauuuaggaguuacuguaggagcauucugagaaaagagcucuuccag\n", + "gcacccagacuccuugcpagcgagugcgucupagcccgcggccggagaapcugcpuuapccggcgcccgcgguucag\n", + "agaapuuuugccauguucgcuaggcuggucucaaacucauggauucaapacugcccgccuggaccucccaaaguacugagauuguag\n", + "gugcgcgcacccagacuccuugcpagcgagugcgucupagcccgcggccggagaapcugcpuuapccggcgcccgcgguucag\n", + "aguuccuuugcgguccucuucuucagcacaugccaaagcuguuccucacggccugugagacaagagcaucuuggauguaggaca\n", + "acuuuuucuuacuuuuuaucupcguuggcguaccuuucucpugucugcguaacugcccagacuugccuugguuuggucagaugacaccuccucupacuggcuagccagcguuc\n", + "cuuucuccaagacggccggccaugcucuccuccucugccagucuccuccaccacucucuaaccugagagccuguggaaccugcccgucuccccuccuccaucagacacaccugccuaggaaacag\n", + "auggaaaaagugapaccggugagugacuugcugcaaaaguuuauaccagaugcaaaugacagagcuggaguucugcugugccug\n", + "cucugucuugaaaapccguacggcacagaagaugacuuugcugucccuccuucuaccaagcuggcccggauagaagaaccaaagagag\n", + "aauaugcaguuaaauuauugccugaaacauauuucagaagucugagagaucgcagacgcggaguuuaaggcucaccugaaagugaugaugagccuucggcgacugaagccuacuuccugacuguc\n", + "auaagagaggccaucugacagcuccagauacgacagucacugucuccauagcaacgaugccuacccacuccaucaagacagaaacccagccac\n", + "ggaagaauauggccgccpuguggugapcgacgcgcuugcagucgccgucucuugcuuccccguccucugacaucgccugcagccgagcpcccguuccgccggagcugaggaccag\n", + "gaauauggccgccpuguggugapcgacgcgcuugcagucgccgucucuugcuuccccguccucugacaucgccugcagccgagcpcccguuccgccggagcugaggaccag\n", + "aaggagcccccugccaccaccgacacccacpcggagaucaccugcugccccgcagaccccugucccuuccucccggaccagcagcuagag\n", + "gagaaaauacucccagcuggccugauacccaggcacaggcuucuccuaaacacaggucuccccaccugucagg\n", + "ccgacacccacpcggagaucaccugcugccccgcagaccccugucccuuccucccggaccagcagcuagag\n", + "cugagcucuuagaauaacagagcucuucacaguaaacucauuuguucucuccccacuuguauuguagaaauc\n", + "gcaggcgcacugcgaacgccggcugagcugagucucgcugcucggugcgaggcggcggagagcgaggccug\n", + "gcucggugcgaggcggcggagagcgaggccuggugagcaccgccgaggcgcpccagcucuucgag\n", + "ggagcccuggugugaucgccaucpaacgccggucgaggcuaggcpcpcggcguggcgcggcggcpcu\n", + "uuugccucgauggcacuuuccuguccgcgacuccgcccccaccagapcuaggcucupauucaag\n", + "gugaagaacaucgugcacaacuacuccgaggcagaaaucaaggugcgcgaggccaccagcaaugaccccupccccccuaguucgcuc\n", + "acuagcaapapcaggaguuaaacaaguuguggccguggcauucccacagaaggcccacgacccgcuggaaggaaagagauagcagacaaaag\n", + "gugcugccuggcgcuggcuaggaggcaaacgcacgcpaagagcugcuacccauuccapacccugccgcugccccucugapucugcaccuccupagcag\n", + "aacuuuccucggagugcugccuggcgcuggcuaggaggcaaacgcacgcpaagagcugcuacccauuccapacccugccgcugccccucugapucugcaccuccupagcag\n", + "agcaapapcaggaguuaaacaaguuguggccguggcauucccacagaaggcccacgacccgcuggaaggaaagagauagcagacaaaag\n", + "ccggcuccgcgcgagagcccugccagaggagcggcuccggccgccgcgccugacccuuguccpucuuccgcacag\n", + "gcccggcuccgcgcgagagcccugccagaggagcggcuccggccgccgcgccugacccuuguccpucuuccgcacag\n", + "agcgcccggcuccgcgcgagagcccugccagaggagcggcuccggccgccgcgccugacccuuguccpucuuccgcacag\n", + "augcucccuggaucuggcuguuaaguuugcugguuucuauuuucagupcugapccaugucaguuuucugccaccuacaggauagacc\n", + "acuacgcgccagaaccugcgccpaagcgucgcacagcgacugcaucaccauggagccgapcag\n", + "agcaaaaaaacauuguugguuccaacaccacgacugagaacpauuguuuaauaagaucacaccacccccupcaacuaaagacaucuugagaaaaugugccaccucucag\n", + "ggugugaggaacuacaguguccccauaggcuuggacuccagaguccucguggauuuaguuguggupauccgucgccguuucugaaaaag\n", + "pucuuaucuggcuugccaaaacaucaaagaccuagacguuuuugccagaacacaggaaguuaaaguggacccugauaaaccacuggaaggcguucggcugcuggugcugcag\n", + "gugccaccagagcgacupagacaggauagaauuuccaaaacaugcuccauuggaaauugccucaccaguucuaa\n", + "gguppccuggcpcuccpcggcupaaupapacagccpaccggugapucgaggcpccaccpcuggcagaggaupcagaaucaccggaagcggccgaggag\n", + "gugucuccaaacaggacauacgugaacaaauuupcuacauggaaucacaaaauuuagcugacuuuccccgaccuguucaucacaggauacccaacuuuaag\n", + "ggcgcuucucaugcugccgagcaacucccacgcuugcaggcguucaaaacggccaggaccauuaaaguaaauccugaugccccccagaaaagugcucgcuucuucguccuugaa\n", + "pcuccpcggcupaaupapacagccpaccggugapucgaggcpccaccpcuggcagaggaupcagaaucaccggaagcggccgaggag\n", + "gucacguggccgccggcgcpucacgagaacaaacacpcagccggcgcuucccggccggugucgcuccgcggcpcc\n", + "uccugugccuucguccuuuccuccuuuguccucagcuuucccgccuccuccuuucagagcccaccuucggcauuuuccugcccuacagcccu\n", + "gagugcaucaagccugucaaaguggaaaaaapcpaaguggcguggccaagauucgcauugaagaugacpagcuacuuccaaauuaaccaa\n", + "gagcpapccpaagccpcguugguggapaggcguupcuucugucgccgcgaagcuggcggaaaaggcaguggccagcgagccgccucgccaguucccacgacucccapag\n", + "auggcagaagauuuuuucauuuaaugucupuaaaauugcaacuuuuuggaacaaggcuuuccuuaccauuaucauccuauugauuguucuauuucuag\n", + "augcugugagagaaguaaggaaauauuccucaguucauaccauugagaagagcuccaccagcagaccugaugccuaugaacacacacag\n", + "gupaagguggaacacuguccauccccuggacaaaaacgcugcgccucpccuugaacccgguuuuguuugaaaggaagcaagagaaaauaaguguuuuuccauuuaggugugaagaaaaaa\n", + "auccccgaaccccgcuuuccggcccgcggcgaccccaggcaacuguuguggcugccgcauugcucccgccpcuguagcugagcgcggagcccgupaccggugag\n", + "auggaacuguuuucccgcguugagacgugcgguccgcuugugcuuuuagaacuaaagacugcugcagaguccggaggaagaagucaccuagaaaaaucupacapca\n", + "aacuguuguggcugccgcauugcucccgccpcuguagcugagcgcggagcccgupaccggugag\n", + "gcuggcugcuggcucuaccagguucugugcuggcauccugagcacugccaggcacuugaccauugagcagaag\n", + "auuaggauauguuugaaguggauuuagcuucucugaauuuaaagucuguauacuuuuugguupcagaucuccaccgg\n", + "aaaaggcapaaguccugcuuccgugccccaccggugcucagcagaggcucccuugcaaaugcgaggcuguuuccaacuuuggucuguuucccuggcagg\n", + "gagccaccuacccugcuccgaggccaggccugcapccucaucggccagapugaucagugagcagaag\n", + "caaaaggcugucccucccaaaccupauucupcucacugaguucaccugcgagucagcccuaccugcacugcucuggucuaguacaaacaggcugcuggcauugag\n", + "ggacggagucuccaacuccuggccucuagcaguccuccuguguaggucucccaaagugcuaguguguccggaauuggupuucuuggucucacugacuucaagaaugaagccgcggacccucgca\n", + "agcgauaaapaacauuccacpucpcggcugcuguuggaucuuagauaaagcuggaapauuaccpcap\n", + "ggcaggcgcgcccugcagaguacagapugugguguccucugcgagauccucuuaaaaagcuggcuacgcgcaggcgguuucugugcacggagccguagcugucggagcg\n", + "cuuccucaguucccuuaaagcacagcccapaaaccuccucacaguuuucauccagccacpccagc\n", + "ccggaacccugugugcupaggaaucccgcaguggccppcuugaggccgcugcuuugucucuucguccagagccuuau\n", + "cugugugcupaggaaucccgcaguggccppcuugaggccgcugcuuugucucuucguccagagccuuau\n", + "cggaacccugugugcupaggaaucccgcaguggccppcuugaggccgcugcuuugucucuucguccagagccuuau\n", + "gugugcupaggaaucccgcaguggccppcuugaggccgcugcuuugucucuucguccagagccuuau\n", + "caacucucucccccucucagccacuuccugucuccaguaugucccuggcgcggcccggcuggccgucugcgcacccucucuccccucggcucuuu\n", + "ccuaggaaagcugagccucauagcuuccpagaagguuuuccggaagaaaccuccagucugugcaguauguaaggugaccaucgaupacaggcguuucgugcagag\n", + "agacagccuacccuccgcccapaagcggcugccuccgccaggccgcuuccaggaagccccpccaggccccagcauuguucaggcccupccagcaccccagccagccgaacacc\n", + "gucccagauccauuccucugucgaagaggaagucauccuucaguggcuauucauugupuuaagagcgcagacuaugaauucagucuuuuupucccaguuugccagaccuuga\n", + "aauuacuaauuucagcuggauucaauuuguugucaguugauucuguaguaaggccauauguugccccucuggaggugcuugucaacuacucugg\n", + "ggcagcccupcggucccpaaucgcacaggacccggcuccccucgccuaagcugcuppcgcc\n", + "gcpcccgcgagaugccgguguuggcggcccgagcggcugcaguugcapcpaggcggcggcpcccpagapuggcgupaccggcgcguagccpacc\n", + "gcagccgccggcagcuacugcaaggcaaaagccggaguggacgugucuuuugaaacugcugcucuuucacuucucaggcgucaccgagagcucag\n", + "gaagucaacucuuuccaucaugaguaacagaacucaaucgaaugugacacacagaaaugucucaaaaaucucuag\n", + "agaauuucaucugaaaaggauuccaagagaagaaggagaaagaggaaaaaugauguuuuuuuuucuucagcuaa\n", + "pccauugacguuuapauguggccauagaauucucucuggaggaguggcaaugccuggacagugcucagcapuuuguauaggaaagug\n", + "agguuuugcucucacuucucugugucuucugcuccuapccuagccuguguggcccucugaccugcagauauupagauccacagcuaagacgccaggacccccuagaagccuagaa\n", + "guggagccggcgcpcpcugcugagguggcugucgccggcuccgagcugcggcuucccpccgagcccccg\n", + "augaaaucccggacgucuacaucguggagcgccucuucuccagcagccugguggugguagucagucacacaaaaccacggcag\n", + "cccguggagccggcgcpcpcugcugagguggcugucgccggcuccgagcugcggcuucccpccgagcccccg\n", + "uucauuggaacagaaagaaauggauuuaucugcucuucgcguugaagaaguacaaaaugucauuaaugcuaugcagaaaaucuuagagugucccaucug\n", + "acuuuggcucuuguugcccaggcuggagugcaguggcacaaucucggcucacuacaaccuccaccucccpuucaagcaauucugcugccucagccuccggaguaccupauugcag\n", + "uuccuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucugg\n", + "caaaagcuacccaccuuugccuccugugccugcuucugcccapacuuagguccucuuacaccuuagagaaaggccuuagcaucuggucacaggcag\n", + "acagauaaauuaaaacugcgacugcgcggcgugagcucgcugagacuuccuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucugg\n", + "aaagcgupaauuacagauaaauuaaaacuguggaaccccuuuccucggcugccgccaagguguucgguccuuccgaggaagcuaaggccgcguupugagacccucacuucauccg\n", + "gcugagacuuccuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucupuaaag\n", + "gacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucupuaaag\n", + "gagcucgcugagacuuccuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucugg\n", + "cuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucupuaaag\n", + "gagcucgcugagacuuccuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucupuaaag\n", + "gacuuccuggacpacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucugg\n", + "ccucugcucupuaaagguaguagagucccpaaapacapcccaagugaugcucupuacuggcgupagaguggauuuccgaagcugacagaugg\n", + "gacaggcugupuuucucagauaacupccccugcgcucaggaggccuucacccucugcucugg\n", + "acagagaaauggucccaaupaaaucagauacugagucuuagaugaagauuuccagugagaagaaacagauaggaugagaagcuuagaagaguaauugcccuuaagaaag\n", + "gucuugguucuuuugacuuugcucuucugguagagaaacgccaaggacugaucaacucuugccagucucaaacc\n", + "gccucgauuggucgauccupccagcauggcggcgcccauguaacccgguccgugccgcaaagcgaacggcggccgcggcgcpccccgcpuuagaggucacc\n", + "capccagguucugcccacccguggagaaggccaguacapagagagccapcucccacaaagcapucccuccag\n", + "ggccguugaggaggugcapagaggagcpapcucupuggcugccaapagcucugcgcucagacccucaacuaagaccaggaggugccug\n", + "agccgcgcgcccgccgcgccgccuugupcgcuguagucccggaguccgcgugcgcpccpuccpagccccapcagccgccccgccgagucgcag\n", + "gcuguagucccggaguccgcgugcgcpccpuccpagccccapcagccgccccgccgagucgcag\n", + "guuggagugcuggagugcaguagcaugaucuccguucacugcagccucaaccuccupcucaaguaauccuccugucuuguccucccaaa\n", + "auugaggcuuccauguuagagccugaauuaucaguaacauaggaagauagaagagaaaccaguacaaaagaucaagagacaaaguacaagauuugaaugag\n", + "uggaacaaauccaccagucucuacaaagagaacaucaagaaccuguguaacagucuaaaaaaacugagugag\n", + "gagaacacaaaggaaacuuggacaaguagaaaguggaugacccaggcuccguuacauauacuuggauuccagcupaccuagauuugcugaggacggaagccaaggagacaggaac\n", + "cccaucccuccuucaucucccuccagcauuuguuucuggaaggagucaacaccaacagcucugaccupcagccuuccugagaaa\n", + "aucucccuccagcauuuguuucuggaaggagucaacaccaacagcucugaccupcagccuuccugagaaa\n", + "guuaaaucaauuucuguuugcuuucuucucuucucuguagguuuugagcaaaauuuuggacugugaagcaaggcauugg\n", + "acaaaaaacuuggacuuucgccgaaagupacaaagaugaauaugagaaacucgccgagaagaggcucacggaagagagagaaaagaaagaug\n", + "gaaaaccagugcagccugucaagcgagagcuuuuacggcauapacuacaagguggacuuggaauccaagcuupaagacaauugucauuaccaagacaaccccucaaucugag\n", + "uuugcaaccgccupacgccgccgaguggucugugcagguucgcpucgcuggcpucgugapagugcgccpagcggagauaug\n", + "pucuguggugagccauaaccggagucuguggacugaacggcpagucuaupcagaaugaugaaccaucupaguucu\n", + "aguugupcgccuuugcaaccgccupacgccgccgaguggucugugcagguucgcpucgcuggcpucgugapagugcgccpagcggagau\n", + "gcgccuuugcaaccgccupacgccgccgaguggucugugcagguucgcpucgcuggcpucgugapagugcgccpagcggagau\n", + "ugccccuccaccccagccagcucaupccacguggccuggcccagccucagcacccapccagugaacagagcccuggcuggaguccaaac\n", + "agaccugcagcggagccgcggcgcccgcuccaaucggcucpcugugcccccpacccggcgacpcpcpcgcuucccgccggccupccccucggcagugccag\n", + "guguggauccaupuagccucaacgcaucugccccuccaccccagccagcucaupccacguggccuggcccagccucagcacccapccagugaacagagcccuggcuggaguccaaac\n", + "gcaguccugagcuuugucaacaugauccuccugccugagacuucaauuupaaagaaugauaugaagaagccaguaaugcagagaacaa\n", + "acccuaacucuaccuuucugcuuuaaagcaaaguaaacucgguggccucuucuucuccaccccucaaa\n", + "acuugcuuccucaguaccuugguccagcucuuccugcaacggcccaggagcucagagcuccacaucugaccuucuaguc\n", + "ccacuugcuuccucaguaccuugguccagcucuuccugcaacggcccaggagcucagagcuccacaucugaccuucuaguc\n", + "guuguugguguggaucagaagaugaggaggcaccuucuaagaagagcauuucuauacaaagagugucucaggucagcacuccupcaggugugucucccaagaaggcccacucuugugaa\n", + "caggcaucaucuggcugcaaagaagagaacacacuguguuugapaggaggaaggaggaucagaguuuaaacuccugccaua\n", + "gcaucaucuggcugcaaagaagagaacacacuguguuugapaggaggaaggaggaucagaguuuaaacuccugccaua\n", + "gucaccucauccuaacccgaauccugaagcagcgagagagcggcgacuguucacaggucugcagcccggacccggcgucpacacugaggcguucgcpagag\n", + "gcaucaucuggcugcaaagaagagaacacacuguguuugapaggaggaaggaggaucagaguuuaaacuccugccauaaugcag\n", + "cgccggccccaggcpugcgcupagccupccpagccpugapcgccgagaggcucggupcgcpcggcgag\n", + "auaugccacacuucugccugcuguuggcaacccuccuggacuaggcugcucuuguuaaucacaugg\n", + "cccgcgcgguagcagccaacgccggccccaggcpugcgcupagccupccpagccpugapcgccgagaggcucggupcgcpcggcgag\n", + "gugcupcupcggcuacauagcugugacuaccapugcagucucupaccaccacuaccgaggcupuaccaug\n", + "cucugcuggagcaggacuucagaguguuuguuuucagccugcuuuuaaagugauuugaagagaguggcuuugaag\n", + "cggcuacauagcugugacuaccapugcagucucupaccaccacuaccgaggcupuaccaug\n", + "gcuuugcgcugcaaauccagugcuaccagugugaagaauuccagcugaacaacgacugcuccucccccgaguucauugugaauugcacggugaacguucaagac\n", + "gucpcgguggcupaupcpapcccggcccgauuucccuugcugcuccccuuguggccug\n", + "aagagucpcgguggcupaupcpapcccggcccgauuucccuugcugcuccccuuguggccug\n", + "gagcugaccguggugcugagcgcggcucgcgcuccgacgcggugcccgagccugucgcggccgcgcccugcugcacugcpcccccagcg\n", + "aaucauggauaupcpcuggaggacuaggcaccucugcacguccugccccgccggaaguggaggccgcpcucugagcgg\n", + "ggucacaaccuacucguggaggcuccacucugucccuggcuuggcacaaacuugaagcccccuucccaaacg\n", + "uccaggcaapcuggagccapcugcagagcauuccucggcucagcupcagcgccgccccaucccccagugguccuc\n", + "cuucucuuaccgccaucuuggcuccuguggaggugagugaapucugcugcugaaauuupcaaauaaccggaguagguuuguuccugugccuuggcgagucgccg\n", + "agaccaaggcpcccggagcggaacuucggucccagcucgguccccggcucagucccgacguggaacucagcagcggaggcuggacgcuugcauggcgcuugag\n", + "agauuccaucgugccuggcucacauaagcgcuuccuggaagugaagucgugcuguccugaacgcpccaggcagcugcggccupuuuuggagugaucacga\n", + "aaugcgaccucaucuuugucagugcacaaaauggcgcccuacagccuacuggugacucggcugcag\n", + "cucuccucgcccucucucugccccacgcugugcgcgagcacacaggcagccccgccccgccucggcpupuggacagagguuucuuauug\n", + "guugugaccgagauucccgacgagagagacugapaagagaggaaggapcpcuccuggcaaggcauucgcuccugagcggaauccugcaaag\n", + "pcuuggcgupaggapcuaagcugcgcucgcuggaacccugcgcuccagcggugcgcgccaggagapcccgaagcgaggucucgccuagaguuggaaaggcagcgugcuuagg\n", + "agcugcgcucgcuggaacccugcgcuccagcggugcgcgccaggagapcccgaagcgaggucucgccuagaguuggaaaggcagcgugcuuagg\n", + "cuccugaggagaaagaaagagapapagagaaaaagagagagagagaaacaaaaaaccaaagagagagaaaaa\n", + "auucauucucccugaaucuuaccaacaaaacacuccugaggagaaagaaagagapapagagaaaaagagagagagagaaacaaaaaaccaaagagagagaaaaa\n", + "aacacuccugaggagaaagaaagagapapagagaaaaagagagagagagaaacaaaaaaccaaagagagagaaaaa\n", + "guagccccgcggacagcupccapugcpccugcgccucccucggcuccuggcgcpccucpagagg\n", + "gcggacagcupccapugcpccugcgccucccucggcuccuggcgcpccucpagagg\n", + "agcggccgcgcpacccggccggcggcgcacuuccgcccpcgcauuguagccccgcggacagcupccapugcpccugcgccucccucggcuccuggcgcpccucpagagg\n", + "gcaugucccucccagcugcccuaccuuccagagcccauaucaaugccupucagagcucupaggaacugcucaguuaggacccagacggaacc\n", + "agugupaggccagcuguuacaacggacaugaagaugugugauuauuuucaguaggcagacaucuaa\n", + "gucaugcacccugccuggcgacugcaccccguggaggcucuggcucuguaguaaacccpaggagagaguggcuuccugucggcuucauuguccuaggauucagauguapuuuug\n", + "cggcgacpcpacpacgacgcacccucuccgugucccgcucugcgcccuucugcgcgccccgcucccuguaccggagcagcgauccpaggcggccgagag\n", + "ugauccggaacpcgcpcugcaggcggcgcagagcagccpcccppcaggcgcgccgugapuguggugcgauggcug\n", + "cuaugacauggugcauuacggccacuccaaccagcugcgccaggcacpccaupugacuaccucaucguaggcgugcacaccgaug\n", + "ggucugaccagccgaccuggaccuggccaapuccugucaucccucauggccaccccgccauuccggcugauaaggaag\n", + "pucuucacggcuucucugcccapccagaaccgaggaggccaggapcugcupcuaapucuaaggaccucguugcacacgcuaccaggagcapc\n", + "ccgccuugcagcgcagcucggaucagcagcagcccaggaggccucccgcccguacuuucccgcguccaucccucugucccacggucggugagucagcggagccug\n", + "uagacccguccggucgcagacugucuccgagacgcuuccuguccggugagcgucgaccgacugaaacggcggcccaua\n", + "aagcggaguugagupugccugugguuggagcuguggagguguccccgguggcgagcgcggccagaacugcggucacuuaaguuuuccgugugcpuugcaaggagcgugcgugcgucug\n", + "guauaauuuggcuuccugagauucugccuuagcaagaaaggagupaaauacccuuggaaagaaaacuaaaaca\n", + "guauaauuuggcuuccugagauucugccuuagcaagaaaggagupaaauacccuuggaaagaaaacuaaaacaguaagaaagccaaaacuuauuuuuac\n", + "ggcccucggccucuuugcaccpcagagugacgagcuucgccggugucuucauugaaguccuguuggucccuaccggcacaucacacacuccuggaagc\n", + "acgcaggcauugapagcccggaagccacgcgcugucagugacaucucgugagcagacuguggugagg\n", + "ggaapuggugcucupccaggaaggccggccuggcaccccggucgacgaccaagcpuggupacuacucuuucuaccuggcugaugagccagccaccauc\n", + "ggaucgcuuacaccugagacgaacuacagaacagcacguaccagagguggaaguccaagucaaacgcagaaggacugccucacugagcaaccaaga\n", + "auacuuugacgaagguaauupacucccaucaagucuccacacagcuagcagccacgupcacuucuccag\n", + "cauauguaaguggaacucagaaggcaacauucccugaacauacucuuccaccagaaucuccucuacagauuuuugcugccccuuuuaccaguggcugaaucuacuuucucuuau\n", + "gcagaguggagcggccgccggagaugccugacgcaucugucugaggagcggucagugacgcgauggagcpcaag\n", + "augcucaggcpaugugugcgaagccugccgcugcugcagcgagucuggcgcagaguggagcggccgccggagaugccugacgcaucugucugaggagcggucagugacgcgauggagcpcaag\n", + "cugcccucucucupcuauuugaggaaugcggccuuuuugcauaagaaaggcuuuucucuacaguaacuguggucgcugaucaaugacaccuuccug\n", + "auguaagupaucuguggaucugaaaauucacaguggccagcucaccaccaccugaugaaagauacaccacapugagagcauccuaacagcaaacugcaaaugag\n", + "ccuuccccuaggucuucagaagcaucaaguuuuaacuguggacauuggauuugguggaacagcaauc\n", + "gaugugugcgaagccugccgcugcugcagcgagucuggcgcagaguggagcggccgccggagaugccugacgcaucugucugaggagcggucagugacgcgauggagcpcaag\n", + "guagugacuugucaggaggaucaauaugaaggacggccuaaacaucucccugcaaaugcuuuagcagcaucucccuccccucaccccupagaaaggauuguucacacaggauaauuugaaa\n", + "cucgccugucuucaccgcgguccgcucgguucaccgccugcccccucucccugccgcccggcccggcucgcccaguccaguggcuccaguccggaucucgccgccgcccggcccag\n", + "guggugcugauccupcacguccauccuagaccucaucgagcuacgcgcgcccuucggcaccacpcuuccgucucacc\n", + "aucucapaguugaugaccuuguuuucagaaggugacucaggucaacacapcccccaucuggucgacagaugcagugguucuaggaucugccaagcauccag\n", + "cagaggacagcgagauucucgcccugagcaacggccugacgucggcggapaagcaggcgcaggcuccgugaggaggcaag\n", + "agcgagauucucgcccugagcaacggccugacgucggcggapaagcaggcgcaggcuccgugaggaggcaag\n", + "gaggaagcggcaucapucccucaggugaagcgcucgcggupaggcaggaagucgagcaugcggcccucucgcaaccapugugaagcgcag\n", + "cauuuuucuaagagagcgucguggugccagugccugcagguucugugaggaagcggcaucapucccucag\n", + "pccagugucauucaaagauguggcuguggauuucacccaggaggaguggcggcaacuggacccugaugagaagauaacauacpaugugauguuggagaacuacagccaucuaguuuccuugg\n", + "agccucaugcuucuguagaaacguguuaaaaguuuauuuucaagaaagaaggcucuaagucuuccggucggaauuuugugguguucaguuauuugg\n", + "gcgccaugauagcaguggcaguggacauucagcauuugagccccugguggccaguggaguccccgcuucuuuugugccuaa\n", + "gccupucucugaagagaggccucaauucucagagcucagaugaccacuugaauaagagaucccgaagcucuucc\n", + "gacuuccggucgcggcpcuggcggcggugcaggcuuugucggcugaucugupcccgcgccggcpuccagucagcggcugcapucpcucgcgccguccucuccccgcccgcgccgg\n", + "auucuaauguaggaacuggugagaagaaggugacugaagccuggauuucugaggaugaaaacucacauaggacgacgucagacagacucacggug\n", + "agcuuapuuuucaggaaauuuggaagcugccgcaguaguuggagucuaaggacucgugacaaucuucpugcccuucgagagaaaapag\n", + "gupcugccpcuggcccagcuuapuuuucaggaaauuuggaagcugccgcaguaguuggagucuaaggacucgugacaaucuucpugcccuucgagagaaaapag\n", + "gucacaupugcgcgcccagacuccgacccggaggcggaaccggcagugcagcccgaagccccgcaguccccgagcacgcguggcc\n", + "guagupaggauaccuccagagaggcugcugcucauugagcugcacucacaugaggauacagacuuugugaagaaggaauuggcaacacugaaaccuccagaacaaaggcugucacuaag\n", + "gaacuuccggcugucaagcucccggccpcugacucaagcggaggcgcgcggaacagucgccgaggcgauucccgcccag\n", + "caguucgacagaaguguacagaggcuucuggcaacacggauugccgucuaccugaugaccuuucucaucgugacaguggccupcagcacacacaag\n", + "gacagcgcgugcgcggcgucgccpcuugcgaugaacuuccggcugucaagcucccggccpcugacucaagcggaggcgcgcggaacagucgccgaggcgauucccgcccag\n", + "ucgccpcuugcgaugaacuuccggcugucaagcucccggccpcugacucaagcggaggcgcgcggaacagucgccgaggcgauucccgcccag\n", + "gccpcuugcgaugaacuuccggcugucaagcucccggccpcugacucaagcggaggcgcgcggaacagucgccgaggcgauucccgcccag\n", + "cuccccugcccugagacagccuccggugcuucugcugugucccaggaaacaagccugaagcaagcacucaccaucccucaagaaugugcccugaccuaccuuccucaccacgguggcaucapccag\n", + "acuuccggcugucaagcucccggccpcugacucaagcggaggcgcgcggaacagucgccgaggcgauucccgcccag\n", + "uccggcugucaagcucccggccpcugacucaagcggaggcgcgcggaacagucgccgaggcgauucccgcccag\n", + "gcuaauggcgcaggcgauuaucugcpcgcugaguguuguguguccugcpcapccggaguuacaagcgccaggaauccagacg\n", + "puagcgcgccupapagaaagaagucpccguggcgcgcagcccgcpccugaap\n", + "gupuagcgcgccupapagaaagaagucpccguggcgcgcagcccgcpccugaap\n", + "acuuccuauucagcauucagcapapagccucugaacagccacguaggcauucucuucucucuggaggaaaaggcccagcagcuguccgaggaaaagacccaccagcugucagcaaapac\n", + "acacguugaauccgaggugacaucuguggucuggccgaaggaggcuagaaggaaggcaugugcuuuggauggauggaaacaggaaucaaagaggaag\n", + "pcucgccgagccgccgacuccucgucacaggcucagcugccgcggccgagguggcggcgacgagcggccgccgcguccugccggcgcgcgccccaggccccccuaccuggcugcccgccgagcc\n", + "gcagaccaggacccacagagacccuugacupccacaggcaugaacuaagagugcugaagaccuaggagaaccacuggucag\n", + "gaaaggccucgcgcgucgcgccugcgccugcgucccugcggccgccagapapuuaaggcgccupcgcacagcgagccggcugapcuguggcggccgcggcpcgac\n", + "gucccugcggccgccagapapuuaaggcgccupcgcacagcgagccggcugapcuguggcggccgcggcpcgac\n", + "aggaaacacaagaauagaagaggcuugugaaauguauaccagagcugcaaauauguucaagauggcuaaaaauuggagug\n", + "gugucupccgcgcccagcupucpacgcgcucccugagcugcccgagcuccgcpacucpccpauccucpcggcugcauuggccpccpccpagcpcc\n", + "gucupccgcgcccagcupucpacgcgcucccugagcugcccgagcuccgcpacucpccpauccucpcggcugcauuggccpccpccpagcpcc\n", + "cuggcugagugagauggcagcuggcuuggcaapacagcaccuuugucaccacauuaugucccuguacccuac\n", + "aaacccaguauagauaacuuuuccacagcuggauauaaaccugaauccauagaaggaacuguggaauuuaaaaauguuucuuucaauuauccaucaagaccaucuaucaag\n", + "auucugaaaggucugaaucucagaauuaagucuggagagacagucgccuuggucggucucaauggcagupaagaguacgguaguccagcuucugcagagguuauaugauccggaugauggcuuu\n", + "gucagaagcgcuagaggucguugcguggcgupuggcucpagupuggcugagcggagcupucccuggccagaggcggaacaaaaupucauggccaggaagacgcgcuaacgca\n", + "gccuacccucugaagagguccaagcaacggaaguacuacuacgaagcugccuuucuggccauccuugagaaaaauagacag\n", + "agcccagcucpcuccagcuccagcgccggcgcuucagcugcgaccgcgagcccucucaagcaagguagagaccccgcgagccccccagcgccccacccucccccaucggaaaaggacap\n", + "auauaacuuccccaagucacacagugguaucagagcuaagaaupacccagauaugacugaucuaguucuguuccaaaaccgugcuguauuauauuaac\n", + "uagapcpuuuggugagcguugccggcpcccgcgguaccucccgcacucugaccugcggcccguagguccgagccpacggcggcgucggupuc\n", + "ggcauccgagucggccaaaagccpcagaagagagcgccaaggacuggcaguuccggaacpcaaucccagccgapaccagcggcagagcacgg\n", + "puuuggugagcguugccggcpcccgcgguaccucccgcacucugaccugcggcccguagguccgagccpacggcggcgucggupuc\n", + "gcggcucpcuuccgccuupagccggcggcggaguccpacguggagacccpucccggcagccpcggcccgcpcccapup\n", + "pagccggcggcggaguccpacguggagacccpucccggcagccpcggcccgcpcccapup\n", + "cpcuuccgccuupagccggcggcggaguccpacguggagacccpucccggcagccpcggcccgcpcccapup\n", + "gcagaugacgcgcggcucpcuuccgccuupagccggcggcggaguccpacguggagacccpucccggcagccpcggcccgcpcccapup\n", + "gccggcggcggaguccpacguggagacccpucccggcagccpcggcccgcpcccapup\n", + "pagccggcggcggaguccpacguggagacccpucccggcagccpcggcccgcpcccapup\n", + "guuucaggaccguuggcaccpcuaacgguuccaccacguccgccgcccuggacgcccgcggccugccccccccugccucuccugcgccg\n", + "gaccupacacpugacucagacgugacucaggaaggcucagguccugcuggcauccgcggaggugagacggugaucagagcup\n", + "guggaccpccpcggacucpaccggcggaggacgccpcgcgcccggcccgaggcupagcpcggcguggcpcgcgccgaggaccccaggccpccpccgag\n", + "pccpcggacucpaccggcggaggacgccpcgcgcccggcccgaggcupagcpcggcguggcpcgcgccgaggaccccaggccpccpccgag\n", + "acagccuccucuuguaaauagagaguacaaaggcuucuccgaguaguguguaugccpcagacgcugaugccacpagaggccuuagaaggagcacaggaaagucccagguaagaaccag\n", + "aauaaccupuaucuuguggucugaaagagaagaaauugaaacugcacaggcuuaccuagagucaucagaagcacuauauaaucaguau\n", + "ggaapaaagguggcauuugccagcccuggaauaauucpuuaguggcagaggcuuguaaaggcacucaggagaccagcauuapccuga\n", + "pccagugucauucaaggacguggcuguggacuucacccaggaggaauggcagcagcuggauccugagcagaagauaacuuacapaugug\n", + "gccccgcccucacuggaacgcuucggacuuaucagguuaccggauucgagucagaagcggcggcaggucugaacgcuucg\n", + "cuuccagagcccaacacauacagcugauacacgcagaccagaucuggucagguccucggaagcugaguccagagcg\n", + "cuggaacgcuucggacuuaucagguuaccggauucgagucagaagcggcggcaggucugaacgcuucg\n", + "agcccaacacauacagcugauacacgcagaccagaucuggucagguccucggaagcugaguccagagcg\n", + "cgugaucucpuuugucpcugaaauguggcpucucggaagguuccgaccucaguaaagagagcuaacguguauucuucuuuuucuuag\n", + "gaaaguauuccaugcuacaugugcaagaaacuuggaaaacacugaaaaguagaaaaaauagcaagcaaaag\n", + "gugaucucpuuugucpcugaaauguggcpucucggaagguuccgaccucaguaaagagagcuaacguguauucuucuuuuucuuag\n", + "cpuuugucpcugaaauguggcpucucggaagguuccgaccucaguaaagagagcuaacguguauucuucuuuuucuuag\n", + "cguguugcuuugucgcccacgcugguugcaguggugcgaucucaguucacugcaaccuucgccucccagguucaagcgauuauccugccucagcuucccgagcagcuaggacuacag\n", + "agagccuaggcccuuccucgcuuuuccaagucuuuugccaaccaguuuguuagacuuuccccuauucugaaucaggupagcacagc\n", + "uuuucagaugcuucaaguguugugaacagagacuuguuuggauuaugcauuucucagcuagacuaaauaa\n", + "pucgucgcggccgccgaaccppcppccpugagcgcuaagauggccgccccggcucpcug\n", + "cacagccagcgccgccpugccucgapcgcgaggccagcccgccugcccagcccpaccagccuccccgcgcagccuggcag\n", + "gucuccuggaggcaaggcgaccuugcuugcccucucuugcagaauaacaapcuuagccacaggaguugcuggcaaguggaaagaagaacaaaug\n", + "agucaaucccgacgugucaaucccgacgauagagagcucggaggugauccacaaauccaagcacccagagaucaauupauccuuggcagauggacaucagugucauuuacuaaccagcagg\n", + "acagccagcgccgccpugccucgapcgcgaggccagcccgccugcccagcccpaccagccuccccgcgcagccuggcag\n", + "ggagaguagcugucupauuugagauccuaucuucccugcaaauuaccagguugcaucuucacugauaggaauacau\n", + "gccauuuuguagagaaacaagcggaguuaaccgaagapucgaggagagccggagucpacccaggaguuuccuguguccagcgcugccggagccgccugag\n", + "gugaccagcacccaugcagaaacuaccuagaaguugccaagcuaucagucaacucagcauacaaaaagaaacuuaccauucuaaggaucuuagaaguuguaugccaggaaaupaugaagaccaaau\n", + "cauuuuguagagaaacaagcggaguuaaccgaagapucgaggagagccggagucpacccaggaguuuccuguguccagcgcugccggagccgccugag\n", + "cggcgccauuuuguagagaaacaagcggaguuaaccgaagapucgaggagagccggagucpacccaggaguuuccuguguccagcgcugccggagccgccugag\n", + "uagagaaacaagcggaguuaaccgaagapucgaggagagccggagucpacccaggaguuuccuguguccagcgcugccggagccgccugag\n", + "auggagucuugcucuguugcccaggcuugagagcaguggugugaucucggcucacugcaacguccgccucccagguucaagugauucuccucccucagccucccgaguagcupauuacag\n", + "guagagaaacaagcggaguuaaccgaagapucgaggagagccggagucpacccaggaguuuccuguguccagcgcugccggagccgccugag\n", + "agugugugaaguaaapauuaaaggcuagucucaggcupauggcuccugucuauuucuucucucucagagacugcag\n", + "cugcpapagaggucggccgagagcaagaugguguguagagacaccaagcaggacgcuacuucaugugaggcpaauguuaguuuggaucaaccuguugauagapaaugaaagcag\n", + "ggcuugcugapcaggcacaggaguccuggcugagcucauggccugaggcugccuagcggccacpa\n", + "cuuucuguggugaggauuagcggcagcaaggaaugcaguggagccauuaccuugucaccuucugag\n", + "capuuaggcuugcugapcaggcacaggaguccuggcugagcucauggccugaggcugccuagcggccacpa\n", + "gcgcaacuccaccugcuucupaacccapaagcaapaagaccgugaccuuugccccpcugupagccccggagccupcccggagaagcgc\n", + "gguuaggcuugcugapcaggcacaggaguccuggcugagcucauggccugaggcugccuagcggccacpa\n", + "acuuuuguuuuccugcucccagcapuuaggcuugcugapcaggcacaggaguccuggcugagcucauggccugaggcugccuagcggccacpa\n", + "pcpcggcaggccgcgcggcgcagcpucagaggcgcuccupcucpccpacucaccgguggccpcgccgcaggccg\n", + "gcucccagcapuuaggcuugcugapcaggcacaggaguccuggcugagcucauggccugaggcugccuagcggccacpa\n", + "gacuguggcggcggcggccucgaggugacaacugucuccgucgcaggcuccggcpcgcaggaggucgcccggcgcgucacugucpucggcgagccacpccgccgcagcacc\n", + "agcugacuguggcggcggcggccucgaggugacaacugucuccgucgcaggcuccggcpcgcaggaggucgcccggcgcgucacugucpucggcgagccacpccgccgcagcacc\n", + "uccgucgcaggcuccggcpcgcaggaggucgcccggcgcgucacugucpucggcgagccacpccgccgcagcacc\n", + "gcapaggccuggauauuguuucuccuggcucuguguccugccauucucaucccugugcucagagcucucaagcacccacg\n", + "uagagaaauggucagaaggaacgacaccacagaagaaauuagaauguuuaaaagaaccaggaaaaacaucuguagaaucuaaaguaccuacccag\n", + "augccugcpcuauaaaaacgcucgcaagcgccaagucuccucaggagccgccggcaapcaacgaggaagcucuuaagagcgcggccggaaagcag\n", + "agaaauggucagaaggaacgacaccacagaagaaauuagaauguuuaaaagaaccaggaaaaacaucuguagaaucuaaaguaccuacccag\n", + "uaaaaacgcucgcaagcgccaagucuccucaggagccgccggcaapcaacgaggaagcucuuaagagcgcggccggaaagcag\n", + "aacuucgugguggaugaugccuguaacuacccagaugaaaucaagacgcaacagcccucaucgapaugcucag\n", + "agucaaggaaacuuuucuuuugagcuacugacagcuuaacuccugugaacaaaauuuggagcauauuuguuucucucugccugauuucuccaaaauuuggaaacuauuu\n", + "gcccuucuccuucupcugaaccccgucucugccucccuccaggaccagcacugcgagagccugucccuggccagcaacaucucag\n", + "gacugcagugcaacgcauccguggaccucauuggcaccugcuggccccgcagcccugcpcagcuagugguucggcccugcccugccuuuuucu\n", + "cugccccgccccgucccguuccguuccucugccccaccccgucccguuccguuccgcugcccaguccugcugguacucacuagguaguagcggcaacggacgcc\n", + "aupcaggcaacgcgcugapacuaggcagagccguggaaccgccgccaggucgcugucgguccacgccgcccgucgcgcugcccgcccgcucggcgucggccgccgcc\n", + "gcgucuggcuccgcagcagaacacgaaguuugcauuccccaapcggccapcggaccapaaagguaguccucugcauuuugccgugugcugg\n", + "ucccacccgccucgccuggucuagccuccguguuuccaugacaacuccaaaggaacccaaacupcuugaaugccp\n", + "cacccagacuccagcaccggccgaggacccccacuccggcugcapacccugucccagcgagaccgcaggc\n", + "acucagaagcpagucuccgagagaagaaaagcagguggaaggagaggaagcggaugccgup\n", + "uuuacagcaggaaaauccguggagacagcagauccgagaagcggcgauguuugcguagaacccuguacgugcuuccuucggccugucg\n", + "cucugaapagcuacucagaagcpagucuccgagagaagaaaagcagguggaaggagaggaagcggaugccgup\n", + "ggagcuacucagaagcpagucuccgagagaagaaaagcagguggaaggagaggaagcggaugccgup\n", + "gcagugcggcggucacaggcugagugcugcggcgcgauccuugcuucccugagcguuggcccpaggaaagaag\n", + "gaagcuggagaaacaaacccucuuggcugucugcuguccapagucgccacucccuucauuauagccuugcucagagugcagcggcaggccupauggccucpag\n", + "apaccacagagcaccagccugcauggaacuuccuuccucacucagcuucccacguugccagcupacapagauggaguaauuuugcuguggaaagacuucacgucuugccgaaugaaa\n", + "agucggccaccuuccuccgucccggccguuagcccagccaagcccagccaagcccagccaagccccgccgaucgcpcaccggagccagccccgcagcgg\n", + "gcgcgcpcggaagucggccaccuuccuccgucccggccguuagcccagccaagcccagccaagcccagccaagccccgccgaucgcpcaccggagccagccccgcagcgg\n", + "aagucggccaccuuccuccgucccggccguuagcccagccaagcccagccaagcccagccaagccccgccgaucgcpcaccggagccagccccgcagcgg\n", + "ggaagucggccaccuuccuccgucccggccguuagcccagccaagcccagccaagcccagccaagccccgccgaucgcpcaccggagccagccccgcagcgg\n", + "gcgcgcgcpcggaagucggccaccuuccuccgucccggccguuagcccagccaagcccagccaagcccagccaagccccgccgaucgcpcaccggagccagccccgcagcgg\n", + "acuuccpucuccucuguuuacgaauguuupcgcgaauuacucuaagcgcggcucucagaapugcaagaagaaucagug\n", + "cuucugguguacupupagguggaacuagucggacaaagcccucgcgucggacccuugccagaacu\n", + "uccucccuucugguguacupupagguggaacuagucggacaaagcccucgcgucggacccuugccagaacu\n", + "cuguccucccuucugguguacupupagguggaacuagucggacaaagcccucgcgucggacccuugccagaacu\n", + "agauggugucuugcuuuguugcccaggcuggagugcaguggugugaucauagcucacuccauccacugacucaupcccaagcucccuuccugccucaggcucccaaguagcugagauuacug\n", + "agcggcggcgguggugaaggccgaugcugupupcguggagagaauucuucugupuccucugguguugaguggucggcuugguguggugugcggaggagcuccaggcccgucggcgcggag\n", + "ggucuugcuguguugcccagccuggucuugaauuccuggacucaagugaugcuccugccuuggcuucccaaacuccuggaauuacaacu\n", + "caaugaaugacgguuuuuguugcuccacauccucgucagcauuugguguugucaguguuuuggauuucggccauucugacag\n", + "gcgguggugaaggccgaugcugupupcguggagagaauucuucugupuccucugguguugaguggucggcuugguguggugugcggaggagcuccaggcccgucggcgcggag\n", + "ccgaugcugupupcguggagagaauucuucugupuccucugguguugaguggucggcuugguguggugugcggaggagcuccaggcccgucggcgcggag\n", + "ggucaucuaguagcaggcacccaaaucaggcaacucccaagaaaagugguuuaaagaauggccag\n", + "paagcpugcuuuucaucgagccugcaagappcccaggcaucgaggcupagucgupuagagccccgauuccagccaagacgccacaggacauaa\n", + "cuauaagcccagccuuuugugguucagcupucgcacgcuggaucccaggccccuuccuugaaaagcagaggccuuguaccccccapuugccpcpacagugauuccagcccuucag\n", + "auaagcccagccuuuugugguucagcupucgcacgcuggaucccaggccccuuccuugaaaagcagaggccuuguaccccccapuugccpcpacagugauuccagcccuucag\n", + "acuacuucucccccggacuccuugguagucuguuagupagauccuuguugccgucccuucgccuccuucaccgccgcagaccccuucaaguucuaguc\n", + "cacuacuucucccccggacuccuugguagucuguuagupagauccuuguugccgucccuucgccuccuucaccgccgcagaccccuucaaguucuaguc\n", + "gauucucugccuaagcuuaaggaccuggcauuucucaagaaccagcuggaaagccugcagcggcguguagaagacgaagucaacaguggagupccag\n", + "ccaagauggagcgaaggaugaaguagcaagugcacgucuuucuupagcaggauguugcgcaaguuuacacuucugaccccaucacacugcuucccacugagaugcaagag\n", + "aggauuccucaucuuccagaugugcaggcugaaauauuuauggaugaaauugucagaugccuagcauuugcuccaugauaaucugag\n", + "aucgucuucuccuucaguuucaaagccaguggcgucgcggccacccugccpcucucugugagg\n", + "accugccccgaauacaguacaggagcaucuucaaaguacuuccagupugcccuggacagcagcuaagaaccccp\n", + "ccuggaguguagcagagccaucucagcucacugcaaccuccgccucccpuucaagcaauucuccugccucagucucccaaguagcuggaaauacag\n", + "pccucagccacaggcagcuguggccuggcugcccaccuccuuccuucccagccaggagcacugcugcagcaccgaguggagagccccacagccagcagcccuucpuccaug\n", + "aggaaccugagcagaugccuugacccagaccagagacccaagccaaggaaagcccaugaucaccaga\n", + "cucagccacaggcagcuguggccuggcugcccaccuccuuccuucccagccaggagcacugcugcagcaccgaguggagagccccacagccagcagcccuucpuccaug\n", + "pagguagcacaaapaggaccauggucuucuaacugaggaaccugagcagaugccuugacccagaccagagacccaagccaaggaaagcccaugaucaccaga\n", + "auggucuucuaacugaggaaccugagcagaugccuugacccagaccagagacccaagccaaggaaagcccaugaucaccaga\n", + "aaaacaaaagcaggaaaagugaccuuagcccggauucugccauccccggaaggcuuauuccuccuaupcaaaggagcaaapagccagaag\n", + "acuacccagapcugccgccgccucuccaaguucuuguggcccccgcggugcggaguaupcgcug\n", + "gccacuacccagapcugccgccgccucuccaaguucuuguggcccccgcggugcggaguaupcgcug\n", + "cucgugagcucccggcccgcugccgcapacupagcpcuccgcagcgcacucuagcccgcggcucggcucagucggucugcgaggauccggcccgccgccccccpacccg\n", + "auguuccaacugugacuucucccuggcgccuugaupagcaucugaaacacccuucaccaucuag\n", + "gcuaccucggaccugaacagcugccugacugccugaaagguugugaugugguaguuauuccggcuggaguccccagaaagccag\n", + "acucucgcgaggccccagagagcaggcgcupcaguguggaggucguuggagucacuuccccgucaccagcuccugugccugccagucggugccccucccgcuccagcc\n", + "gcgcccpaggaugaguacgcuacacccggaagugucuucapagaggaagccggcggccucacugcu\n", + "guggagcuggucucuupcagccugacaucugguccacuccucuguccuaugccpaucaucaugaccguagagauuaugucacuguuuugcauccuuguuacauaacucaguuccugguagauu\n", + "aaagaaggacuuugcugcuuupccaggaucugaacuuagguguaaaccauugcccuggcagapaaccuacccaguccauugcugccugcuacaag\n", + "auaugaacaguaauggcacauauuuugguuaugagucacucagaggacuguggauugaaugaacuguauccauccccaucaugauguacagaaccaagucucuucacuaguag\n", + "guuuugcuguggcguggcaccuggucucuuucuagaaggaaaguucaacauacagcacaauucuggacacauuguauugguuugaugcuccuaccuggaacag\n", + "upcagagcpuggcgguagcggcugaccugguuucuugccuuaucucguugcgaaaggaggaaaaaguuuucggcgcgg\n", + "auaugaacaguaauggcacauauuuugguuaugagucacucagaggacuguggauugaaugaacuguauccauccccaucaugauguacagaaccaagucucuucacua\n", + "uuuuaguacgguauuguugcagcugaccuguauacguaaggaauuacupucaucagcucupaaugucuuuugauuaugaacacauuuucagcauguguccacugaag\n", + "acagucuugaugcauucauucucaaggacacuugauccacugccagagaggcccagaauuuucuaacuuacuguguggcaga\n", + "gacccgguugcgaucgaguggccgacgcccccagupagugaggcccagcacgcgagcucggucccucuuccuggagccag\n", + "gaccccugupcagaucaacacucaaggcaggugcagaaucaacaaccugugacaaagccagccaucccugccaggaagc\n", + "acuuggauucucacuugcauuuaucuucagcugcuccuauuuaauccucucgucaaaacugaapaucugcaggaaucgugugacuaauaauguaaaagacgucacuaaauug\n", + "accgcacaggaaacpcaggapcggacccccaucucauguaggaaugccguguccccapugagcccucag\n", + "guaapuaccaguuucuuccugagccaugaccagagccauucccagauaaaugagguuuccuggaaggauguuaccagugccuuaucucuggccaac\n", + "apcuggcccccuccaccgcacaggaaacpcaggapcggacccccaucucauguaggaaugccguguccccapugagcccucag\n", + "guuuggapcucuggcauacgaacgucuuaggaaucccaauggcucuggccauguagcuacugaucaccuuug\n", + "ccaugaccagagccauucccagauaaaugagguuuccuggaaggauguuaccagugccuuaucucuggccaac\n", + "gaaccccacccgcacuccaaugaggucacaauggcuggagcucugapcccaggcucccugagccaggaggagaggagaaaguccaaggaaag\n", + "gcugcugcugcpucpcggcggccapauuupcaggcaccguggauccccgagaapacgaguugacag\n", + "cucupcggcugcugccgcugccgcugcugcugcugcpucpcggcggccapauuupcaggcaccguggauccccgagaapacgaguugacag\n", + "cugccgcugccgcugcugcugcugcpucpcggcggccapauuupcaggcaccguggauccccgagaapacgaguugacag\n", + "ugccgcugcugcugcugcpucpcggcggccapauuupcaggcaccguggauccccgagaapacgaguugacag\n", + "pcggcugcugccgcugccgcugcugcugcugcpucpcggcggccapauuupcaggcaccguggauccccgagaapacgaguugacag\n", + "gucucupcggcugcugccgcugccgcugcugcugcugcpucpcggcggccapauuupcaggcaccguggauccccgagaapacgaguugacag\n", + "aauagguggcuuuugacuacaggugaaucuucugauaaaguaguaugaaaauuaaagagacagagucaacag\n", + "gcugaagccuupaggaagugaucugcguaaguauuacuugucagugaucuauccaagacaccaugaagaucuucuaag\n", + "gaaaauccuguugugaauaagaaggauuccacagaucacauaccagagcgguuuugccucagcugcucucaacuuuguaaucuugugaagaagcugacaagcuugg\n", + "uucaucauagagagagcgcggaccgugugcpccgucuugacgaaagaaccgagagauggaugcgcuaag\n", + "aaacaacgaguuuucgucguucgaaucagguugacugguccuucauccccccaaucucccguaccuggcgaguccagcucgucgcg\n", + "gauucagugacuuuugaugaucuggcuguggacuucaccccagaagaauggacuuuacuggacccaacucagagaaaccucuacagagaugug\n", + "agaugguuucagcauguuggccagucuggucucagacuccugaccucaagugauccacccaccucggccucccaaaaugcupauuacagguauaagccacugugccuggccaaa\n", + "uagagaugguuucagcauguuggccagucuggucucagacuccugaccucaagugauccacccaccucggccucccaaaaugcupauuacagguauaagccacugugccuggccaaa\n", + "agacugaggcuggcuggcuggagguugacacaggagugcucapagcagcaucacaagapcagaucgaaagcaucguccuugcugaaaaa\n", + "cupacpccgaguagcgccuuccccpccccgugaaccggcugcpucgcccuuppcagcggccgcagccccccaccupcccucgguccgcccucccggcgcgucc\n", + "cggaagcccggccaccgcccccgacgcgacccgcgccgcguccgcggcpaguuguugcugccgcg\n", + "gugccccgcggaagcccggccaccgcccccgacgcgacccgcgccgcguccgcggcpaguuguugcugccgcg\n", + "ggauguugcugucaggucugagucgguuggagucugacpuaggcgagacgcgcaggcgcagagagccccagccacgccggcccagguggccucag\n", + "guccuggaccggaucaaaggcucacugcugccccggccuggccacaacuuugugcggcaccaucugcggaaucggccggaucuguaug\n", + "gccccuucuggaucugugccacguuggccuuuguccuggccgucacuggcaaccugacgcuggugcuggcccagaggapaccccuccauccacuacagcccccaguuccacaagg\n", + "ugaccguggcaggcaucagcaucuacugcuaugcguggcuggugccccuggcccugupcuuccugcgguggcgcaapuguccaggagcgc\n", + "gucugacpuaggcgagacgcgcaggcgcagagagccccagccacgccggcccagguggccucag\n", + "ggugappcggagcgcaccugupacpacgacgaguucaagccuccgupugcaguuggucgccag\n", + "agguapcupccgapaccggcucpcppaagugugccugaccggucucuguccucagcgapaugcggagacgccccugaacgacc\n", + "gguuggagucugacpuaggcgagacgcgcaggcgcagagagccccagccacgccggcccagguggccucag\n", + "cuccugcaggagcagcagcagcagcagcagccpauucuggaccuucagcuacuaucagagcuucuuugacguggacaccucacag\n", + "gacggcgcugccgccauuuugupuguuugucgcagcggccgaggapaagacggcaguuuggcgacauuucucggccgaapccauuugcuuuugcggag\n", + "gupuguuugucgcagcggccgaggapaagacggcaguuuggcgacauuucucggccgaapccauuugcuuuugcggag\n", + "apcgacggcgcugccgccauuuugupuguuugucgcagcggccgaggapaagacggcaguuuggcgacauuucucggccgaapccauuugcuuuugcggag\n", + "upuguuugucgcagcggccgaggapaagacggcaguuuggcgacauuucucggccgaapccauuugcuuuugcggag\n", + "agagacpuuucacccuuuuagccaggauggucucgaucuccugacuucgugaucugcccgccuuggccucccaaagugcuaggauuacag\n", + "ugaaaaauacaguaagaauugaucugcaauggaacuuaagcaucuucuuaaaauccapuugauccauuuucuaagaaagauugguaugaugugaaagcaccugcu\n", + "guugaguagcggcaggucggcugccuuucccaggccuucugguccuugcgcgcgucgcguuugagccggcuugccggcgcgacucggcugga\n", + "uccgcccuuuuggcucucugaccagcaccauggcgguuggcaagaacaagcgccuuacgaaaggcggcaaaaapagccaagaagaaagu\n", + "gcucgcacucccgcuccuccgcccgaccgcgcgcucgccccgccgcuccugcugcagccccapccccucgccgccgccacc\n", + "uccguuaccccpucaccaccgcgccgcggapcccuagaaguggaagccagagcccuagugcaguggccucccggagcgcccagcucaccag\n", + "agccaggacagccgcggcagccpuccgcapcagcagccggccucucccacugcagcccucccgcccgccuaccguccggcgcg\n", + "cgcuccuccgcccgaccgcgcgcucgccccgccgcuccugcugcagccccapccccucgccgccgccacc\n", + "aggacagccgcggcagccpuccgcapcagcagccggccucucccacugcagcccucccgcccgccuaccguccggcgcg\n", + "gcacucccgcuccuccgcccgaccgcgcgcucgccccgccgcuccugcugcagccccapccccucgccgccgccacc\n", + "ggcggaccggcgcupcagccaggacagccgcggcagccpuccgcapcagcagccggccucucccacugcagcccucccgcccgccuaccguccggcgcg\n", + "ucccgcuccuccgcccgaccgcgcgcucgccccgccgcuccugcugcagccccapccccucgccgccgccacc\n", + "ccgcggcagccpuccgcapcagcagccggccucucccacugcagcccucccgcccgccuaccguccggcgcg\n", + "ccacgccuccapcgcaccuggcgcaccupccagcuggcggcpcucupapcccggccuguucuccugagccuuuguuuuccaucucgcugauccaaa\n", + "gcagccaggacagccgcggcagccpuccgcapcagcagccggccucucccacugcagcccucccgcccgccuaccguccggcgcg\n", + "uucccuguguguaaaguguggauaguaacagcaucuaccugucgguuaaaggaguuacuauguaaagacaguacacugaugcuuggcgcaaaagg\n", + "ccggcucucacccucggcucccgaggccccgcggcgccuccuucugcggacucugcpacccuccccggcaggcgcugugcccuggagaaggcacaguggcucaggc\n", + "aguucucaagucagaucucuucucauaapcacuguguggagcuucugagaucuguggagguuuuucucugcaaaugcaggaagaaaucagguggauggaugcauaauu\n", + "agaucucuucucauaapcacuguguggagcuucugagaucuguggagguuuuucucugcaaaugcaggaagaaaucagguggauggaugcauaauu\n", + "aupcggaggaccugcacuuggcauucucaucuagaacggugucgucggcpaggapaga\n", + "gcuggcccuuggugacpucgcgucaguuccgacccggacccguacgcugcugcgcugacguggcuccuggaagcapcuggcguapccgcc\n", + "gauaguaaugaugacacugaagauguuucacuguuugaugcggaagaggagacgacuaauagaccaagaaaagccaaaaucag\n", + "acauccaguagcaucguuuuuccacuuauucuuucgagucagugcaaucaucgucugucuucucugugaguugcucagcagcagcuuuauuaccugu\n", + "uuggugacpucgcgucaguuccgacccggacccguacgcugcugcgcugacguggcuccuggaagcapcuggcguapccgcc\n", + "uaaugaugacacugaagauguuucacuguuugaugcggaagaggagacgacuaauagaccaagaaaagccaaaaucag\n", + "uacgacuuuacuccgugacauaaaagaaggacuacagaaagcuguaauagaccauacaauaaaagccauugugauuuguggagcagapcaaauuuucugcag\n", + "gugcugauauucguggcuucagugcuccuaggacauuuggccuuacacupacauguaguagaugaaauacagagaaaugagaagcccgugguggcagcaauccaaggc\n", + "acuuccugcupuggaugaggaggagccggagacgccgcggaggagaccggaccgaagacggaccgugccpaagag\n", + "caacccgccgcuaccgcgccgcugupagagaccccagcaggagcccaaaggcagcuacpcgcgaaggccgcuggcgccgccucggccagcccuucccgcgcg\n", + "cuuccagucugcugcccugagaagauacgucacaaaagccuuagccupugaagugcuggaupaccga\n", + "cagcaggagcccaaaggcagcuacpcgcgaaggccgcuggcgccgccucggccagcccuucccgcgcg\n", + "accgcgccgcugupagagaccccagcaggagcccaaaggcagcuacpcgcgaaggccgcuggcgccgccucggccagcccuucccgcgcg\n", + "gauaguaucacacuagccgcuuccuaauguaacuguggcuggcacucugcagaggcaapagcugcagguucuguagcag\n", + "guggagcgcugcggapugcgugcpccgcggcagccgaacaaaggagcapcgccgccgcapacccgccacccaccucccpccgcgcagcggccucucgucuacugccacc\n", + "apcuuaauaguuuuccaagugcuucaagacauguuagcuaauuggaucuucacaggaacucuaugag\n", + "gcgcugagugcgugccgcuccgccgaccgaagaggcugguaaguccucaagcuggcagguggucpagcggccggagaggagcugccpaguucgugcccugcag\n", + "uaaguccucaagcuggcagguggucpagcggccggagaggagcugccpaguucgugcccugcag\n", + "cuggcpcuugguauuuggcgccugcgcgcugagugcgugccgcuccgccgaccgaagaggcug\n", + "uuguugcucgaggapcauagagcuuacaaauagugaagaggaapcgaggcuggaccaggupagcpugccccaagucccapcggugaggaucgaggcag\n", + "agucucacccuguugcuuaggcagauggcgcgaucucggcuccupuucaagcaauucuccugccucagccuccugaauagccpauuacag\n", + "ccuggugcacugugcguccucugagaggugaaggagcacuguguggucagapcugcgagcucucuguuupuuccgaggaagacagaaupcugaacuggaacugaccuaa\n", + "gccgacucgcpccgcugcacccaccgccaaggacaaaaggagcccagcgcuacuagcugcacccgauuccucccagugcuuagc\n", + "apcccaggucggcccapagcacggaaccaaagagcgcuagcgccgguucggccgccuuuccagaaagcccpccgaacggccccgccgcagagacucagcgcggaucgcugcucccucucgcc\n", + "pcggagacccauaauccggaagugaccucgaaaccuuuuccggucuuacucacguugcggccuuccucgcgucacagccp\n", + "acucuuccagguggccucaaacacuaagcagaacaguuccaagccaggacccaccugucgaugccaag\n", + "aagccgauccuacugcapccaugagcgguccauuacgcagauuaaguauaaccgcgaaggagaccuccucuuuacuguggccaaggacccu\n", + "gccuccucacaggcuugcugapaauuugagcuuccgguggupaaaggaggugaaaucgucucgacuccup\n", + "cpacucccagcagagauuuuuuuuuuguacuggcuguguaacaggacaccgcaugcagcccucaggapcucugugcuucu\n", + "ugccauauauagaucccpagcapagcpcuaagaguagaaucgugucgcggcucgagagcgagagucacgucccggcgcuagcccagcccgacccag\n", + "aagaguagaaucgugucgcggcucgagagcgagagucacgucccggcgcuagcccagcccgacccag\n", + "aagaguagaaucgugucgcggcucgagagcgagagucacgucccggcgcuagcccagcccgacccaggugapcpagacgccugcgugcgugcggcccpagcgccgagcaaucup\n", + "ggagcpcuaagaguagaaucgugucgcggcucgagagcgagagucacgucccggcgcuagcccagcccgacccaggugapcpagacgccugc\n", + "uuaagauuuguuagucugaacucaauuuuaacaacuucugaaacucauguguuaaguuacagcccauaauaggauacag\n", + "aaaagaucccgcaccauccuccaggauccaauggccuuggagagapcugcapcccacggacauugcugacucuucagaacgugcugacauggagccag\n", + "guagacugaaauuaccauguguccaaauuaaaauugcauacuucaaggauuauuugaaggacuauucuuagacccuuuuaagaagauuuaaagaaaa\n", + "accacucggcccugagugcggcgaggacccuguuuguggauguggaggagcgcpccggaggcc\n", + "gacuccugccgucacgcccpcuccgcguagcagagaucpagacgcgucugugccuccpaagccgacccaucuccccuccgccucuuuggcugcaguugcaccuccggccagapcag\n", + "gcguuggagguuaagcagagagagagaggcguggaccuauuuacgagauguaaguuguguucuuuccaccuuuaccuucugapcuucuuacgccucauggugacaggugcaaauc\n", + "gacugagaguggcuuucacaauggaapaucaguaauuucaagacaccaagcaaauuaucagaaaaaaagaaaucugguaagauagcagau\n", + "ugaggacacagugagaaggcagcuauuugcaagccaggaagagagccaucaccaagaacugaaucugccagccccuucaucuuggauuucccagccuccaaaacu\n", + "ucuaccaugugaggacacagugagaaggcagcuauuugcaagccaggaagagagccaucaccaagaacugaaucugccagccccuucaucuuggauuucccagccuccaaaacu\n", + "cuacaaguuagaguuggauuaucuacauuacgaagagaggaaagugauuguaaaacuagacuuuauuucauucagcaaaggaaauucauuggcapugagacuagucga\n", + "uuuccagguuaacuaaggucucagcuguaaaccaaaagugagaggagacauuaagauuuucauucuuaccpuugucuucuuccugaagagca\n", + "gugcuguaaacugcaaaccauaauccugucuuaauacugcaaacaaaucauaguggaacuaapaacuuaauuuacug\n", + "ucggacagcucpucagucgacggagcacaccpcgcccgaauccgccpucccacucacgcccgccggccgccg\n", + "gagccacagugucucagccapcapccpaacuccugcgaaaaaccacpccggaggagcagcagccgcgcpcccag\n", + "caccgagcaccagcuucuccgacgccpaagccgcugucgccgccgcuaccucucccuguugccgccgccucag\n", + "acuggugguggcggcggcggcggcggcccpcuccggcugucpaagcugcugagcugugauggugaugacgag\n", + "acccuggucugugucucggaggcgccgccgccgccgcugcugcupagcccapagcgccgcgcgaccaggaggcggcggcgccgccggcuuug\n", + "puugguugaggcggacggcpuccpccggaguacgucguucccgcugcgcuapaagcpcag\n", + "guccggccgccgccgccgccaccgccgccaccgccupuugguugaggcggacggcpuccpccggaguacgucguucccgcugcgcuapaagcpcag\n", + "gucgguaggcuccacgacaaaagucaacccuucuguaaaucaccugcugugguuaugaugcucugaguucaauacgucugaaccuuugcugucuauggaucugcucuaaaccuuauagccugcuu\n", + "cacauuggagauauauuuccacagcaucuggcuuuucuuguuccuguucugaaguaaauguaacugcuauccucuggag\n", + "gugacgccuucupccccaucuguccuuccucacagcacccucagcaccuuaagccaccacccucagccacaauuuggcagaagg\n", + "cuucuguaaaucaccugcugugguuaugaugcucugaguucaauacgucugaaccuuugcugucuauggaucugcucuaaaccuuauagccugcuuaupaag\n", + "cuucauuuaccucuuaauucuccuuugccuggaagugaauugaccaaggaaccuuuucguupaucagagacucuuugcauuaguguugcgguugccuggcacc\n", + "uccggcgcccgcgaggccccgaguccuccuccggapcggcugcpccugcccucuucuccuaaccag\n", + "aagccagaugcpcugccaggauuggucuugucagauucguccuaagapccggupacagcugcag\n", + "uaccuguuugauuccuuuuucucacugauaaagaaaggaaaagcuaccaccauuacaucagucuuaccgaagccagcacuaguugcaucucpuugag\n", + "guuuccaaaguccuuauucuaggaucaggaggucuguccauuggucaggcuggagaauuugauuacucaggaucucaagcuguaaaagcc\n", + "gcucuuuuaaaauaguugcuuucuuaggaaauguaguugcuuucuuaaccucaucaaauucaugaagauuuagccgaggcccaug\n", + "cuacccauuaucuucuaaauggccuucagaaaugauggagaaacugacacguuaugaguauuuccugcccuacauggauuuugaacuugaauucccagccucgcuugcaucuagacacag\n", + "gcucuuuuaaaauaguugcuuucuuaggaaauguaguugcuuucuuaaccucaucaaauucaugaagauuuagccgaggccc\n", + "gagcugaaapccuucaagaagagaguucucagagcagacucagcuuuaggugcugaaaugaauuucucaag\n", + "aaapccuucaagaagagaguucucagagcagacucagcuuuaggugcugaaaugaauuucucaag\n", + "pccuucaagaagagaguucucagagcagacucagcuuuaggugcugaaaugaauuucucaag\n", + "auuauuagaaaucuuuagucaucucauucccugugagcugaaapccuucaagaagagaguucucagagcagacucagcuuuaggugcugaaaugaauuucucaag\n", + "uuuugaacgucacaaggaagaaacggugcccggcgcagcuugcccuggagcguagcuggagugcggcugaguuuucgcuccgcugaagccg\n", + "paaacggaagauggcggcggcggccpcacpuuccpcuccgcucpcagagcccacccgcugaccaacgccgccgcccccgccpcggugcuguguccccgcaggagucggagagg\n", + "apcaapaagaggaapcgapaggagccugaggagacucgcccggcucaaccccgacguccgcgccccggccgccuguuggcc\n", + "acagagucccapagucccaccagccuagucgccagaccuucugupaucaucggacccaccuggaaccccaccu\n", + "gcuggcccucacggaagaacaacagcugauguuugagaaacugacucuguauugcgacagcuacauccagcucauccccauuuccuucgugcugg\n", + "gcuucuacgugacgcuggucgugacccgcugguggaaccaguacgagaaccugccguggcccgaccgccuc\n", + "capagucccaccagccuagucgccagaccuucugupaucaucggacccaccuggaaccccaccu\n", + "agugacuuaagcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "uccuccgccgaccgagcagugacuuaagcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "ugacuuaagcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "auuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "caaaguuuauuccuacuuugaaugccgugaaaagaagacagaaaacuccaaauuaaggaaggugaaauaugaggaaacaguauuuuaupuugcaguacauucuuaauaaguacuuaaaag\n", + "guaaaguaguaaccaaagagaaaauccaggaagccaaagaugucuacaaagaacauuuccaagaugaugucuuuaaugaaaapauggaacuacauucuugag\n", + "guuuuggagauuuuagguaagaaguuuccuguuacugagaacucaaapuuacaaguugcugccaccuuaucuuagaguuauucaapauggaguagauauuaauaccuuacaagag\n", + "uccgccgaccgagcagugacuuaagcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "cucucccccuccuccgccgaccgagcagugacuuaagcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "uuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "puaggacggaaggucccaggcpcpcgaaccggcuccucguggcacuggcaaagcupaacgcccccuccaggccccgcccucccgcgcccgugccpaacucgaacuuag\n", + "aacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "uaugaupcaucuuccaauagaaauaaaagcuguuccugapcuuugucauucccagaggaaauguucucuucacgguggaaaacacagauccagaguguuacuggcuuacaaauuggauugag\n", + "gcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "cgaccgagcagugacuuaagcaacggagcgcggugaagcucauuuuucuccuuccucgcagccgcgccapagcucgcggcgcgcggccccuguccuccggcccgag\n", + "gcacagaaguuugcugcaucacuggugagcupaguguccugugugguguccacuuaaucuuacuaggaaggauccccucauuucaacaag\n", + "gcaugaaugaauuaaucgugccagauucuccaacacuuccucaggagacccuauugcucugaucaagaaguuccaucagcaccgaagaaaacagcag\n", + "augccucccaggacccagapagacuguagccucauuucuguggagaccuuuggcuggacucuccuggcucucccagag\n", + "gcuccgcgugugugccccaacuguccuggaagcuucaauuggaaaacuccaaacuuuaaguuuugcuuauagcuucagcucaa\n", + "aaacagagaagagcuggugauagcuccagagcucagagaaaggaggucucuuuacaagaagucuggcucucaaag\n", + "acuccgcgucagcgcgcgcccaccuaggupcuggcaaccagccaccaguuuccaacucuuucuccaacapaagccgca\n", + "paaccauuugaaugagaggapaucacpuagagupcuccaggagguapcgagcapugugacpccagacucuugagccag\n", + "aaapccgcgaccccugucccggcugcuapapagguagagaaggagcgcpccgucgcugucugcaguucuaggcuuguagccuuugcacuaacccugccgcag\n", + "gaccccugucccggcugcuapapagguagagaaggagcgcpccgucgcugucugcaguucuaggcuuguagccuuugcacuaacccugccgcag\n", + "agagacggugucagugguagccuagagaggccgcuaacagacaggagccgaacpcuuccgcucagcagagaggcaag\n", + "agagaucaggccaaapagcucuagaagguuguupagcacuaaacuggagaauaagagaagauaguuuaaugccguacc\n", + "uuaucugcagagaucaggccaaapagcucuagaagguuguupagcacuaaacuggagaauaagagaagauaguuuaaugccguacc\n", + "gcggcggcggcggcggcpagccgaggaggagguuccggacgcugcuuaggaaccpacucaggagugcccgcgcccugagcgcucagcuccagaggcg\n", + "ggaugcucaccccuuccuaauugcagcuccgaauauucagaupacagugaagcacagaucucaggaguccuaaguauucauggcuaccacuaaguuggauag\n", + "agucucauuuaaagcucccacugguuuuacugaaaaauugagupcucaguuucugcagcgcuuucuuccacugcaag\n", + "ugcgaggcugaguaugaupcuccauccagcacgaacacaaagcccugugagaggaggcagagugagaugaagucgaacugupauaugaaaggcauuuugaaggaguaggcaucag\n", + "aguggcgugcaguggcacauagcucauuguaaccucaaacuugagcccagaggcucaaguguuccuccugccuuggccuccugaguaccupacugupugugcaccaccauaccag\n", + "aagcgacgguuaggccagacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaapuaaauucugag\n", + "auccugccccugagcuuucaugagcuguugaaccaucuggaauucacaggccugucaugagagacacgaugagaaguccuuaaag\n", + "gccuaaapaguggccccaguggcgguagcggcgguggugccaaugguaccucuuucagcuacacauuccauggagacccucaugcc\n", + "aagcgacgguuaggccagacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaap\n", + "auccugccccugagcuuucaugagcuguugaaccaucuggaauucacaggccugucaugagagacacgaugagaaguccuuaaagguagaucacugauucacapagcaggcggaggcaagg\n", + "uaauuuccaapagaaacugcaagagacggccuaagcugcggcagcuuccaaggaugagcuuuucuggaccucag\n", + "agacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaapuaaauucugag\n", + "guggaaaccaagguaagcgacgguuaggccagacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaapuaaauucugag\n", + "puaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaapuaaauucugag\n", + "gcucuguguggcugcacagugaacguccccacucuggacggcaggacgauacccgucguauucaaagauguuaucaggccuggc\n", + "gguuaggccagacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaap\n", + "agacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaap\n", + "guacaccpaacagcaggagapcuapcupucgcpcugcggagucugguuggcgaggag\n", + "guuccugugcccguugaugauucaggcuggcuucupcuugaucuggagcugacuuuuugugcaaggaugguggcaguga\n", + "guuaggccagacgcpcpuaagaaguugagugacaggcaaggcagcauccacaugacaggcggcgccgaap\n", + "guguguggcuucauacauuupacccuauuuccacucccuccucuuggcaugagacuguauacaggauccacccgaggaca\n", + "agaccugcccucaaggacuggcacuguuggcaggupacapaggccagcagagagcagacgcaugacguuuggugugaagagugccaggaagacagucpcagagcag\n", + "agcggacagacagcucuggccagugaggaagagcuccugcccgucccaaagcagguguaugaggagccaugagcucaaccuggaaccagag\n", + "aguugguccgcccpccccgccccupccgugcggugacaccacuucapccggcccccggaacuuuupcaggcgucagcgcccgugucaccgccacgucgcggac\n", + "guugguccgcccpccccgccccupccgugcggugacaccacuucapccggcccccggaacuuuupcaggcgucagcgcccgugucaccgccacgucgcggacaug\n", + "gccccgccccupccgugcggugacaccacuucapccggcccccggaacuuuupcaggcgucagcgcccgugucaccgccacgucgcggac\n", + "cccpccccgccccupccgugcggugacaccacuucapccggcccccggaacuuuupcaggcgucagcgcccgugucaccgccacgucgcggac\n", + "cpaacggauggcggccupccccguagcagcggcggcucuacggcccpccccpcpcggagguggcggcucccpaccggccgcgcg\n", + "caaugauguuguccacupcauguacugaccaauguggcaggucugagaacauagcugaagcugaaaauaggaaagcupcaaggaagagccuugaaucuugaggupacguugacucuaag\n", + "acugaagcagcagcucaguuucucacuccgaaguggcagcagccagagapagucgguguggacgcgaggagccpcgcuuagaacagaggcuugcacagguggag\n", + "gaaguggcagcagccagagapagucgguguggacgcgaggagccpcgcuuagaacagaggcuugcacagguggag\n", + "acuccgaaguggcagcagccagagapagucgguguggacgcgaggagccpcgcuuagaacagaggcuugcacagguggag\n", + "agcagcucaguuucucacuccgaaguggcagcagccagagapagucgguguggacgcgaggagccpcgcuuagaacagaggcuugcacagguggag\n", + "ugcuuuuaggaagaagauccuuuuauugcuuuuguacaagaccagacaggaucucauuuguuaaacgugguaccaauupugucuuaacacaggagcagaacuuccuagagcaga\n", + "cugugccuacucaacagauucuagcuuuuccugagcaaacaaacaccaaagacuggacagugacaccugagcacgucuugccugagucccag\n", + "cuuuuauugcuuuuguacaagaccagacaggaucucauuuguuaaacgugguaccaauupugucuuaacacaggagcagaacuuccuagagcaga\n", + "augagaacaagapaccucggcugcggaguggaggugugacccugccuuagcccpaggcaccucpaggcuggcccugcgcucaaguccuccgguccccucgugucccu\n", + "gcggaguugaccuggaaaccucuccuuggccacuguccuuucuaaggaacucauuuccagaguccaccagcacagaacuggupagccuacuaggagcagagaaa\n", + "agcucggucgcuugugcguuccgcuccggccgcccuuugcgcuuggauccacuuccccaucuguaacgagguguugagacgag\n", + "cgcuccaccucucaagcagccagcgccugccugaaucuguucugcccccuccccacccauuucaccaccacc\n", + "aaucccuuaauuaaauagcuuccccucuacaggcuuuugaagugguagcaguuccuccuaacuccugccagaaacagcucuccucaac\n", + "ggccgucucagucucauaaaapaucaggcaggaggaguuupagaaaccugagaapccugauuugcagcauc\n", + "gagcagccgccgccgccgccgucguugcuacugccgcagcggaguucagapcccggaggupagacuucccacacggugacugag\n", + "gagccgaccucgagcagccgccgccgccgccgucguugcuacugccgcagcggaguucagapcccggaggupagacuucccacacggugacugag\n", + "gccgccgccgccgucguugcuacugccgcagcggaguucagapcccggaggupagacuucccacacggugacugag\n", + "apagaccagaapcugaguggcccagaupacacugcucugagccucaauuugcugauccacggaauacgaaaaccagguuacaucccca\n", + "agucucpaccucccuuccgucupcguguguccgcccccggccggcuuccucccgucpcucpucgaccccaccgucccgcuccgccccpuccucccucccagcuucccuccg\n", + "puauggcgcgcugugcggcgcapcggcuggcacaaacggcggcgccpccggaggaaaaagcucg\n", + "gagcggcccuuaggcccugccccugucgccuacugcgcucagaapccucapccugccccpuupcguupugcccuggaupcaccuuuaucucucguccugucuccgg\n", + "gucagucucpaccucccuuccgucupcguguguccgcccccggccggcuuccucccgucpcucpucgaccccaccgucccgcuccgccccgg\n", + "agucucpaccucccuuccgucupcguguguccgcccccggccggcuuccucccgucpcucgg\n", + "ggagagupcuggaggccpcpacgcguugugcagcpuaagcgcacggccgagcgagc\n", + "guagaggaagacacuguggaggccaguucuggagcuauugcagccucgguugcccggccpacccgagccgaaaaguuaucgucaga\n", + "gacucccguagaggaagacacuguggaggccaguucuggagcuauugcagccucgguugcccggccpacccgagccgaaaaguuaucgucaga\n", + "acaaccagcugacucccguagaggaagacacuguggaggccaguucuggagcuauugcagccucgguugcccggccpacccgagccgaaaaguuaucgucaga\n", + "ucccguagaggaagacacuguggaggccaguucuggagcuauugcagccucgguugcccggccpacccgagccgaaaaguuaucgucaga\n", + "caaccagcugacucccguagaggaagacacuguggaggccaguucuggagcuauugcagccucgguugcccggccpacccgagccgaaaaguuaucgucaga\n", + "gcuuccupcgccgupcgcggacugcgcpcugcgcpugccgaggagcgcgaggcgcpaaggcgcaccupuggcccuggcgugcpcggcgac\n", + "gccgauacaaagcapaaaaggagccagaucccaagacguggaaggccaacuuucgcugugcc\n", + "pacaucugcugcuucccaaaugccacauuucuucaaauaaaaagcagaagacagcaugcaguacauaaggaacucaugucuug\n", + "cuggauuuugaagauugauccaapacuguauuaauuucaggaauugauuugaaagacacuggcucugccacuuaacagccauguaaccuugg\n", + "aaagapaaaagagccpagagaggupcaaggacgapcgapcacggccpuccuggcuggccaaacgaggcucgcggaagcagcagccgccgccugaccgcag\n", + "auuucucacauuggcaaacugagagauuuucuucuggaacacaggaaagauuauauuaaugcuuauag\n", + "aguccuucagcggccpuucgcgccgcggucgccggcugcuuacgupcpccuagugupcugapugcpucgcu\n", + "agaagcupcagccucugccpuuccpaaaaggagcuccugcugccacugcucuuccggagccugcagc\n", + "ccaggcaggcccagaagcupcagccucugccpuuccpaaaaggagcuccugcugccacugcucuuccggagccugcagc\n", + "guggcccuaggcagcupcgcuuugcucuccuucaggccggagagagagagccaggccaccgcgagagcacugccapcccucgaaaguggcagupugcuggagaguugag\n", + "cuggauuaggcccugguuugcgcgaccucugcgguuuuaugccuugcaggaguaauugcguuuugcgaaaguuagagcaapuugagucgucuagguuucuuaauuucgaugucagaguguuaaua\n", + "gacguggupuccucuggugcgaaauuccggauuuccuupucuuccgguaggagcuguaaucaauugugcugacaacacag\n", + "gagccaaaaaccuguauaucaucuccgugaapaucaapacggcugaacagacuucccgcugcuggugupugac\n", + "auuaggcccugguuugcgcgaccucugcgguuuuaugccuugcaggaguaauugcguuuugcgaaa\n", + "gcaaaggaaauuuuaacaaaagaaucaaaugugcaagagguucguugcccuguuacugucuguggagaugugcauggucaauuucaugaucuu\n", + "guuaaaggaaagacuuaugucagccccagcccupcuacccgaucugacaaagccuuuuacauugu\n", + "ggcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "aggcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "gcaggcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "uccugcaggcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "cpcuccugcaggcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "ugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "acccacuccpcguguggccgupccggucgcuuccucgcucpccaaaguuccucagccgugaagapuggaugucacaagucaagccuccuucccapuggccgugag\n", + "gcpcgcugugcgcgccgcgauccgguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "gguacgupccuccpcuguccccucupcggcgauccucccuccggagccccccuucaacccucccggaagugag\n", + "gcgaucacgcgguccuacccggaagcgcgcccpcuccugcaggcpcgcugugcgcgccgcgauccg\n", + "gaccapaugcugugcugcucucccaugagccagucaccgagucggucugcugcagcccuuucugaaccucuggccgucuggaugcuccacugugcuugccaag\n", + "agauugaaaggaaacacacugaaugaggaaaaacuaacauacggucaucaacauccuuguauaaccuaguuuuuaaaaaaauuggauuucaaag\n", + "aaaacaaaauuaucuuccuuuccaaauccaaaaagaugaaaacgacugagauacuuucaaaagacaaccaagugagcagcacagacua\n", + "auugaaaggaaacacacugaaugaggaaaaacuaacauacggucaucaacauccuuguauaaccuaguuuuuaaaaaaauuggauuucaaag\n", + "gagaggugucaguauauuugaaggauugaaggaauaaauguaagcauuugaagaacuaaauguguuuaaccaaaaucaaacaguggagacaag\n", + "cuggagaacaaaagacauauaaaccuuagauaucaagcauaagagaggugucaguauauuugaaggauugaaggaauaaau\n", + "cccagcgcuupccacggacgucccaccccgcuccucugucgcuggagaaccgccpccgagccacupagaagcaggccagagccuuccapccuccggcccguggacccgaggagg\n", + "augagagucccuacacuaaauccgccagccagacaaagccgccugauggagcguuggcugugaggagacagagcaucccag\n", + "uaaagugauagugcagaaagaagacuggauguggaaugagaacugaaguuagaguuuuaaguccucacaaaaggauuugccugauaccuguccuuag\n", + "cugcugcugcugcagccaccagagcagagagccuugaguacacuuugccacagaaagcagugagcaaga\n", + "agucucgcucuguugcccpcuggagugugguggcuugauccugguucaaccucugccucccagguucaaggagucucgugccucagccuccuaaguaccupauuacag\n", + "aggaggaaggcugaacaaggaccugcgacauuuucucaaucagcgauuccagaapucuccugaucaugagcuccagcagaccauaapauaaccuuuaccgccaugcugugccuu\n", + "gcacaacccgaucucccagagaaggagaagugccuggcguggacuauaacuuucugacugugaaggaguucuuggaccucgagcagagupacucuucuggaagucggcaccuaugaag\n", + "agccacugccgcagaggagccaggcccagccucggugagcacacacgcccucccugucucucgccuucgcuucccugcaucugcgcugauug\n", + "accaaagccagcguuucggcucgcgugcgccggccuaguuugcucgcguccucacgcgcuuupuuucccggucuc\n", + "acuuccggaaucucucggcgugugagcuugguuguccuaccaaagccagcguuucggcucgcgugcgccggccuaguuugcucgcguccucacgcgcuuupuuucccggucuc\n", + "uccuaccaaagccagcguuucggcucgcgugcgccggccuaguuugcucgcguccucacgcgcuuupuuucccggucuc\n", + "auugucccccgccpcggcupcugugugcggcggcggcggcggcggccgapauggagcgagcgccgagccpucag\n", + "uugucccccgccpcggcupcugugugcggcggcggcggcggcggccgapauggagcgagcgccgagccpucag\n", + "acucgaccpcugcgcucacugcccagccpccccpagccuccaggcucccgcccgcccugagcugcggccuccgc\n", + "cpacucgaccpcugcgcucacugcccagccpccccpagccuccaggcucccgcccgcccugagcugcggccuccgc\n", + "aguagcagcagcagcagcggcggcagcggcpcggccgcgcpuguuuaugucpucgcpucucgcggcagc\n", + "gucagcaguagcagcagcagcagcggcggcagcggcpcggccgcgcpuguuuaugucpucgcpucucgcggcagc\n", + "auucgccgcccggccccugcuccguggcugguuuucuccgcpcgccucpcggaaccuggagaua\n", + "uggcucugcggacacuugguccaacuccuuucuucaaugagcagaucapaggaaacgaacgcagg\n", + "cugucacuuccagacagugccagcuaccagauuuagcccauuggcucagcccuuuucuggucccag\n", + "caucuagagguggaggauugagaauuguggcuggagguucggucgcugccpaggaggacucugucgcuggagcugaggcuggaaaa\n", + "gccuuggccccuccaccagaggaaggugcugccacgugucugcuccuucugaaccuccagguuucugcuacguugcccc\n", + "gcugcucuuuggcguaaauugcaaucgauuapaucguuucucagaaucaaguuagaagugagaguucagauaagugaggccgccauugcugcuuugaacaccucagaapaga\n", + "auccaaaccaccuaaaagagaugaaaaggagaggaaaaggcggagcccaucuccuaagcccaccaaagugcacauupagacucacccggaaugugacaaag\n", + "ugaagauuugugccgaaacgcccucuccucgagauuuaacuaauuguucucuccucucucuggcuguuggacgcgcaccuuuccggaggaupagguaaccgag\n", + "gacucugacgucagagcggcgccggccucggcggcugaggaaagcaggaggagguggcggcggcpaagau\n", + "uggcuguuggacgcgcaccuuuccggaggaupagguaaccgagguccugagccgguaccugaacuugg\n", + "aacguauuuucagcagcauuuugaagcaccccuggcgugcacugcacapaaaccaggaccacauuggugugcuguguccuccuuaccaacuggcucuuggagaag\n", + "guaaguupcggaauccgacugcauccguguuucpcugcccggcaggcccggcaggacgccucgugaagccgguccacuccucagccccgcagugcggcgguggccuggcagcgcg\n", + "ccaucugugagaaagacacacugcaguggaaggaaacacaaagagaaugugaaagacuauuaucagaaaugg\n", + "aaguccaapaguaagcuuggaggaaacgcupuucaacuugaagcccuuccacagacauuaagucg\n", + "gcuccaaaaaguccaapaguaagcuuggaggaaacgcupuucaacuugaagcccuuccacagacauuaagucg\n", + "aacugaugcaugugaauuacauaucucccugauaggugaaaaccauucacuaggagaggagaaacaca\n", + "gguuugccgcugucucugcuauuccauccuccccauapcucucuccccucucccaucucaag\n", + "gugucugaaagcauuucuggaguguuuuaggccuguucacuuucucuuacucacugucuauucacuuguccuguucacucgucuggaagaucucagccagcacc\n", + "gaccaacuccucuucaucuucgucuuccucagccugcucaaugugaagccccugaucaugauucacuuccacuuaauaaaua\n", + "aaguguuuacaaaucagaauaacuuuuagacaauauuaaggugguaaucaugaacagaaaagauuuuguaguucuuccaupaaaaccuggaaauucuguaaagcuaaaauauag\n", + "caauguaauaauuaaaacaaaagucuaagauuugaagagauaauuugcuucaggauuuugauggaaggcaaaugcuaacuuuaaaaaccagauuucggagaaguacaaaagaaauag\n", + "aguaauuagaauacaauugacccucgagcaacacagagucgacugcgugagauuugcuuucaccucugccaccccugaaucagcaagaccaaccccuccucuuccucuuccuccucagccuacucaag\n", + "ccucugccauaauucuuuugucuuuguuacuuuuacagaaguguuuacaaaucagaauaacuuuuagacaauauuaaggugguaauc\n", + "acuccgcuuccggccgcucucgcugcggccgcacccgcgcccgugcccgccccgcgccugccccgcgccuc\n", + "cacuccgcuuccggccgcucucgcugcggccgcacccgcgcccgugcccgccccgcgccugccccgcgccuc\n", + "uuuuguucgccguuacucugcgcguaagucgcuuguccguggcuucucugagaagaaaaguugaaaaagg\n", + "gagaaaaggcagaaccagaguagagauugacagugagcugagccaaucaggcugugaaucugcagcagugaucccagguccuccaauuaauacuaagagaguggaccapccccugaggaagacag\n", + "aagguggcuupapaccaguuuuccuagaugcaggagacagcguccauaguuucaguucgaagcaacugguggcaaaagguuagcauuuaag\n", + "apaccaguuuuccuagaugcaggagacagcguccauaguuucaguucgaagcaacugguggcaaaagguuagcauuuaag\n", + "auugugacccgcccugaccucacagccauccuucccaccgccaggcccaggagguupagacuaaccuggcaaggagccccca\n", + "ccguaggugcccggcccgccccucgcagccuccugacuucccuuccuguccucagcggccpcccacggccccgagcagcc\n", + "uccguaggugcccggcccgccccucgcagccuccugacuucccuuccuguccucagcggccpcccacggccccgagcagcc\n", + "caccaguccucgccapuagcuccucccpacaaggaccgaagugcgacggucaguaguucagugccc\n", + "guaggugcccggcccgccccucgcagccuccugacuucccuuccuguccucagcggccpcccacggccccgagcagcc\n", + "gucpuccgucccgugcpcaggugccgccccucugccggcgacgccccpccgcccgcccguccgcuugccacc\n", + "pucucpcuuccgccuucuugcugcccucguucuugccapccgcgguuagucccugcuggccaccccacugcgacc\n", + "gaggcuccpucucpcuuccgccuucuugcugcccucguucuugccapccgcgguuagucccugcuggccaccccacugcgacc\n", + "uccpucucpcuuccgccuucuugcugcccucguucuugccapccgcgguuagucccugcuggccaccccacugcgacc\n", + "gccuucuugcugcccucguucuugccapccgcgguuagucccugcuggccaccccacugcgacc\n", + "cucccuucaaugaccuuccugucccauaggaguucucaggcagcuucaauggaaggapagccaagaapccugguauacauucaaag\n", + "auaggaguucucaggcagcuucaauggaaggapagccaagaapccugguauacauucaaag\n", + "agcccuuggcgcugupcagccupccuggapcgcuuccucuggauuggcggugaugccuggcagcauggaaaugccaguucac\n", + "gcacugacugucgcgccgugcccugcgccaggaggagcggaggccgcgcgcggcccgccgagcgccuucagg\n", + "cacguuagcuggccccauuuugcaggugcaccccgcugugaccguuguucuuguguauccuuggacgacaccaaacagccaggcggagcucuggaaaauag\n", + "cuuucuuugcccgccguucgccaaacgaagucguggagguggcgaaacgaggaggagauaacgcggccuupcucug\n", + "aaugaagaguaguuuuacagaaaaaagaggacaauauupaucaccuuugaccuuuccauuuggaaauaauauuuucuauuguguuauagaaaggupaagcuuucauccagaaca\n", + "aaugaagaguaguuuuacagaaaaaagaggacaauauupaucaccuuugaccuuuccauuuggaaauaauauuuucuauuguguuauagaaaggupaagcuuucauccagaacaa\n", + "aguccaaucuuuuuucuuuugacagguggucugacugacagcuupuaacuugaagaaccuuacaaagcucaua\n", + "agaacaagaagguaucuggucuacaagaacucgaggccucacugaaacggaaagcaaauacaaagaaacuuuauuuuaaaaacaugucuuggucucccaagaagapcaauuggauugcucagccag\n", + "agugupacupcggaacgccgcccggccgcpucpcucugugucagcagccpcpcgcucpcpac\n", + "agccaaagagcacacuggaggcggagaggcagcauccaccagcccgcuccccgccuccaggacagagccucggucugc\n", + "aaagagcacacuggaggcggagaggcagcauccaccagcccgcuccccgccuccaggacagagccucggucugc\n", + "cuaauuuacauuuucaucaacaguguacgapuucuccguuuucugcacucuugccagcauccguuuuuuccugucuuuuugauaaaaaccacuuuaacup\n", + "cucuuucuggcucccaacugaagcucucugaggccagcagccgccgucaauguucacagagugcaggcaggcagccaa\n", + "guaucauuggaacauuucaagaucaucaaaucaaauuccacapauuggugaccaaccagaaggcucagacaucugauugcugaccu\n", + "aagaauucuggauuaaacucccucccuugcauuguauucapugccuuccuugaagaauugaaagcagaaagauuupagcugagaguuaagcugaacaaaag\n", + "gaauagagcaguguguauucggcugccugccugcccgccugcuugcucucuggcugugcuccugcuuaaagaaaucaguccuuccuuuccgacuuaguccucpaagaaguuucagacuacaag\n", + "uccuggaucaaucaugaagucuucacuuccugugaaaaaugcuagugacuugaaucaauaaagacaacaugagucagccuuccaag\n", + "guguauucggcugccugccugcccgccugcuugcucucuggcugugcuccugcuuaaagaaaucaguccuuccuuuccgacuuaguccucpaagaaguuucagacuacaag\n", + "aguguguauucggcugccugccugcccgccugcuugcucucuggcugugcuccugcuuaaagaaaucaguccuuccuuuccgacuuaguccucpaagaaguuucagacuacaag\n", + "cugugcuccugcuuaaagaaaucaguccuuccuuuccgacuuaguccucpaagaaguuucagacuacaag\n", + "auauucaagccugcucucaggccugaaaucuuuugacuucauucucaggaggcaagacupucuaccucuagaugucucugaupauuuagugugcagcuugaaaugcag\n", + "cacccugcgagagccgcccgccagccagcguccgccgccguccgcgucgcgccacccgcgguccgacpagcaggcccagcggcc\n", + "guuucccgccggcgucuccacccugcgagagccgcccgccagccagcguccgccgccguccgcgucgcgccacccgcgguccgacpagcaggcccagcggcc\n", + "ggagccaccgcccagccgcucgcaggcgccgcacggaguugcgucccpacuupccgcapag\n", + "gaggagccaccgcccagccgcucgcaggcgccgcacggaguugcgucccpacuupccgcapag\n", + "acccuagcauccugugauucagccgcgaagacguggccccaagccucccaccgcccuccuucuguccugacugcccacucccapacaccag\n", + "guucccagaccagaggacuguuguuaggugauuggcugugaacacccugaggccagugccccucgcugcuuggcacucggagaugccugauuagcaccuuuaaucccuuaccagugag\n", + "cpcgguagcacgcuguguuggcggcggcuccccgcuugccucagcugcagcagcpaagcucgguggcaagcccuuguaguccugugcg\n", + "gaggcgcguguggaagcgcuuccpcgguagcacgcuguguuggcggcggcuccccgcuugccucagcugcagcagcpaagcucgguggcaagcccuuguaguccugugcg\n", + "gcgguagcacgcuguguuggcggcggcuccccgcuugccucagcugcagcagcpaagcucgguggcaagcccuuguaguccugugcg\n", + "gcuuccpcgguagcacgcuguguuggcggcggcuccccgcuugccucagcugcagcagcpaagcucgguggcaagcccuuguaguccugugcg\n", + "acuccaugugauguuugcuugguugccuguucccuuuucuaccugcagagcacgguucccauaapcggcgagaucagccuccugucucaucuggaagaccaccacucupucucagaggaaug\n", + "gagacauauacugccuggacugccuggcugaugugagcuaguuugucugguugaguuggauguuuaaauagaaggcagaacaacaacag\n", + "agcacgguucccauaapcggcgagaucagccuccugucucaucuggaagaccaccacucupucucagaggaaug\n", + "aaccgacccgaaagagagccccacgcuggcaaaguggcucgcccaucucacagccgguuggcgcucgcggag\n", + "gcucacagaacauuuccugccuguugcucacacucuguuguccacagcauacccgcacccuagauggcugacucuugucuucugu\n", + "guacuccacaucagcauucucaagacuggagaaguuaggccucagacaucccaagccuucuccuuucauuggaaacuugacauuuuuccgccag\n", + "agcacgguucccauaapcggcgagaucagccuccugucucaucuggaagaccaccacucupucucagagga\n", + "cuaccugcagagcacgguucccauaapcggcgagaucagccuccugucucaucuggaagaccaccacucupucucagaggaaug\n", + "gaggcccaagccaggcuccuapcagapcaaacggccccuccaggapagccpagauuacgcagcuccauguagguccacguuuagguupaggaucuacc\n", + "agcuggaggcccaagccaggcuccuapcagapcaaacggccccuccaggapagccpagauuacgcagcuccauguagguccacguuuagguupaggaucuacc\n", + "apcggaacagcgcpccgcgcpcguaggcpuaucuggaggaggcgcapaaccuggagapuccagcccucagugccccggccagaggcpaapcucuagagcuucg\n", + "pcguaggcpuaucuggaggaggcgcapaaccuggagapuccagcccucagugccccggccagaggcpaapcucuagagcuucg\n", + "agugguggugcagaaugagagaagagaagaauggacuucacuucucguaaccauuaaaaaacucuucauccaguauccaguguuggugcgacuggaacaggcag\n", + "apcuuuccucaaggagauaauucuaccucagcacaaggaaacuaccuggaggccaucaaucugucauucaaug\n", + "pcgcgapcpaaggaggcpccccpcggagccaccggagcggcgcpuucucag\n", + "gcccggcgagagcggcgcpcgcgapcpaaggaggcpccccpcggagccaccggagcggcgcpuucucag\n", + "gagacgagacggaggcccggcgagagcggcgcpcgcgapcpaaggaggcpccccpcggagccaccggagcggcgcpuucucag\n", + "pccgcgcpcguaggcpuaucuggaggaggcgcapaaccuggagapuccagcccucagugccccggccagaggcpaapcucuagagcuucg\n", + "gacgagacggaggcccggcgagagcggcgcpcgcgapcpaaggaggcpccccpcggagccaccggagcggcgcpuucucag\n", + "ggaggcaagaugacuucucugccccaagcuuggaacagcuaaapaaaaacagugcaagaugagaacaacaaaggucuacaaacucgucauccacaagaapcuuupcagug\n", + "uggcugaauugucuuucagaugaugagcuaguugugaaccccaaaguguucccucacaucaagcuuggagacauuguagagauugcacaccccaacgaugaauacag\n", + "aaacuaucaguguggaccagacugugacucaaguguuccggcugagaccuuaucaggaugucuauguuaaugucguagacccuaag\n", + "gugcuuaggagaacaugcaguagaacuuuucaucaaacaaauggaacacgucacagaauuuugcuaacauggacaacucugcacagaaaa\n", + "gugcuuaggagaacaugcaguagaacuuuucaucaaacaaauggaacacgucacagaauuuugcuaac\n", + "ggaguuaccucgcggacggcggaagguggacucgcgaauguuaggccugupugccauagcgaccpagguupcuggccagauucagcugccpaccggaccag\n", + "auuuccggcaccggcauggccpugagcugcaggcuaccuuauuuaagaccpaauuuagucagccuggugagccgacucugaggagauggaguaucgcugaggug\n", + "agcaucgcggagucggugcuuuaguacgccgcuggcaccuuuacucucgccggccgcgcgaacccguuugagcucgguauccuagugcacacgccuugcaagcgacggcgcc\n", + "agucuaagcaaaccccagcaggaaagcapuacagagaggagcccccuuggcaccgccaccgcacccuaggccacccacc\n", + "gugcacgcgguuguagcugcccggcggcggcagaagcggcgcucgcgccaapacguguuucugcgcucgcgugguc\n", + "ggagcagugugugcccagcccugcccaccapacauuuggccagaacugcagccaggauuguccuugccaccauggapcagugugaccacgugacuggacagugccacuguacagcuggauac\n", + "agccuggaaaccuggccggcgucaggcacaucauccugguccucucaggaaappcguupaaaagcaccaucuccacggagcuggcccuggcacugcgccaugcaggcaagaag\n", + "cgcugauaaagcaguuuguguccgacguggccuppagcuggacuaccuggugguggacacgcccccpaccuccgaugagcac\n", + "auugguuggaaggcccuucgcucuagcupaggcugacggcccgcpcguaagcggacugcagccgcgagcuccuggaggcggcp\n", + "ccuuuugugacgccggcugugagcgccugagagucuuuuugccuuucagaguuaaggccucacuggccugg\n", + "gaaaauaauugcugccuuuugcauccgcguuggcuccguccccaggaucuucccgguucapaccuggcgauuucugaguguuccg\n", + "gaaucccaauaacccuguuuaaagaggaauggagauugccacuguccauuuagauuaaugagguguccugaagugauggugacaucaaugaaaggapuucugacacguucucaccucgcp\n", + "pcaaaguggcaggaaccucuuaaapcgagagcggcgcggagccagaacgcggucggcccgguccccgccgcacccagcccag\n", + "ccucaccauuacaauuaagaauuauuuucagagucuucuuauuucugaagcaugugaauauuaucugcaucguuaaaagu\n", + "agugcagguggaggccccggcpcaaaguggcaggaaccucuuaaapcgagagcggcgcggagccagaacgcggucggcccgguccccgccgcacccagcccag\n", + "gucagugcagguggaggccccggcpcaaaguggcaggaaccucuuaaapcgagagcggcgcggagccagaacgcggucggcccgguccccgccgcacccagcccag\n", + "aguugcccugucagugcagguggaggccccggcpcaaaguggcaggaaccucuuaaapcgagagcggcgcggagccagaacgcggucggcccgguccccgccgcacccagcccag\n", + "ugugucucacugcugucauuugcuuccaugugccacugcggugauggcuccauggccucuccuggacuggcugcgugaccccgacggcugcuucugg\n", + "guuuuagccgguggcugcugucucupcpccgupaggcucccgaggupccpcp\n", + "gcuccuuccucagcggcpaagcuggcggcagcggcgguggcgguggcugagcagaggacccggcpcggccucgcpucag\n", + "ugucuuucuccgcggcgaaggugaagaguugucccagcucggcccgcpagccccpagccgcacg\n", + "auuguguguuugccgcaaauuaaaaccucagcucuguaucuugccuucugcuggagguuuguaagcuugcuccugcuaaccacuucauugucugagagagaaac\n", + "uauaacagaagagaacuauaauuuccugccacauagccccuccaagaaagauucugaauggaagaguggaacaaaagucagucguacauucagcuacaucaagaauaaa\n", + "aacupaagugcaguacagucgugaugcuccucugcccccccggcaagaccucaacgccccugaccucuauaucccca\n", + "pcuccgccccccpuapaccuacagcpcgcggcgccggcggucugcggccggcgguguagacgccccuucgccpaccuggcacccgaauccggccugccgg\n", + "gaccuacagcpcgcggcgccggcggucugcggccggcgguguagacgccccuucgccpaccuggcacccgaauccggccugccgg\n", + "agccgcuguucugccccgcpcauccgcupuccccgcgccguugucaagaccpaccuggacgcagcggagagaggugccgccgcccgccccguccagucgccgcgcgcag\n", + "gaagcuccgccacccgccgccaugaguagcuuuggagcupugagacccuuucgcagaccaccccccaucuccucuccgcgcucccpcuuagaucucag\n", + "ggagugugcggaupuuggagagcugupauuuccuucccccuucagaguccucuuccuuggcucauguccaagugucccagccccag\n", + "acauuucaacucugcucaaacauagcaaacacaaauacagcguuguguauacuccaggcacuucccaauaauuaaccaauuucacccucgcaacuacccccpaggu\n", + "gagacagcccgccggccgcccggaucuccaccugccaccccagagcupacagcagccpcugcggcacupapagaccccacaguggccucuucugccacccacgcccccaccccuggc\n", + "agcuccaguccuggcaucugcccgaggagaccacgcuccuggagcucugcugucuucucapagacucugaggcucuguugagaauc\n", + "aggcgccgcgupcccgcaccucupcagcagcggcagccgagacucacggucaagcuaaggcgaagagugg\n", + "gaacccgcagcagcucccaggaugaacugguugcaguggcugcugcugcugcpcgcugagaggacacgagcucu\n", + "gagcccuuaacaccugagcaaaggagagaacgcuggaggagaaggcggcgcgagcugagcccuuaccaccugagcaaggagag\n", + "ugucaaaucaacagugccuugacaucuuuccacacugcuuuggaacuugcaguagaccagagagaaauucaacaugucugucuguaugaaauug\n", + "ccccuccccucccggcuccgcuuggcuccpcagguagagccpcuccpcgcgcgcpccgcagcagcugcucccgaucucgccucggcccagcgcapccucgcacgccc\n", + "cuuccuuggcucagugcccuucaccacugcuggcuuuuugcuguagcuccacauuccugugcauugap\n", + "agucggcgcgcpccpccpccggcgccccucugccucgcgcgcuugucgcguugccccpcuccpaugcccccggccgagcccuucuc\n", + "aacuccggcuacpcccgaacggaccgugaggcgcagauuugagccgcuguugagaugauuccuuuccguucgcggaagag\n", + "ggauucaccuacgcucuuaccagcuggapaguaaacuggcucgcccagcgcuuccauugucagaauggcuguauccupagaugag\n", + "cccuaugagguaggucuuauggauuguccccauuguacagaugaggaaacugaggcuuagaaggugaagugaugccaaaugaaauagcaaagccaggauugaaccagaauaag\n", + "auccccauuguugcauagcupaaapagcuggacaaccugguaccuuuucgauuauggauucaaaugucucugaag\n", + "agacagagucuugcuauguaacccaggcuggucucgaacuccggcuucaagcaauccuccugccucagccucccaaagugcupauuauag\n", + "accggacacuaagacccagcgcugaggacaaaaggaagcaagcucugcauauuugaaguguugcaaacuapuccauccucupccagcccucuccucuagugacuuacucagaguguguugg\n", + "gcggccgcagguuccgcugucucpaaccgucguaucccucgguccggcggcggcggcggcgguagcggaggagacgguuucaggccuccggugcggcugca\n", + "ccgucguaucccucgguccggcggcggcggcggcgguagcggaggagacgguuucaggccuccggugcggcugca\n", + "apuuggaggccupcccguaggupaggacugacpcuccaguccuucggcaacaccaauucugucugcacuccccag\n", + "caggcuggagugcaauggcucaaucucggcucaccgcaaccucagccucccpuucaagcgauucuccugccucagccucccuaguagcupauuacag\n", + "guacugaagauuuaccccccaaaaaaaauugucaaugagaaauaaagcuaacugauaucaaaaagcagagccugcucuacuggccauc\n", + "guugcaucauaaauacaaaggacugaaguuauaaaagagaaaagagaaguuugcugcuaaaaugaaucugagcaauauggaauauuuugugccacacacaaaaag\n", + "gcuggagugcaguggcaugauuuuggcugacugcaaccucugccucccagguucaagcaauucuccggccucagccucccgaggagcupacuacag\n", + "aucugccccgcgccgagcgccgccgccgccgccgccgccgccgcuccgcugcccgcgccgcccgcggcucccg\n", + "aguuugucucucuugagcuuggagaaaaucauccguagugccuccccpacacguagaggagagaaaagcgaccaagauaaaaguggacagaagaauaagcgagacuuuuuaucc\n", + "aguucaguuugucucucuugagcuuggagaaaaucauccguagugccuccccpacacguagaggagagaaaagcgaccaagauaaaaguggacagaagaauaagcgagacuuuuuaucc\n", + "cacpagcgaggccugcupcuuggcaacgapacucggccucggaggcgacccagaccacacag\n", + "cpaagcuggagcpccggcggugcagucacpagcgaggccugcupcuuggcaacgapacucggccucggaggcgacccagaccacacag\n", + "ugauucucuucuaccuuccuuagacacupucaaggaguaagcagaggauaaacaacuggaaggagagcaagcacaaagucauc\n", + "gagacaggupuacucpaagcuggagcpccggcggugcagucacpagcgaggccugcupcuuggcaacgapacucggccucggaggcgacccagaccacacag\n", + "gagacuuaagguuauugcuuggccgcggccugguauuccggcgauucguuucuugcucggcuuccuggagcugugguccgugupcuuccaccucagacaguugcgcuggcucagcpccggaac\n", + "aguagccccucuaccuccggaagagacgagugcgguaacaccguucacagagcuagccggacguccuccgacucaag\n", + "cuaccuccggaagagacgagugcgguaacaccguucacagagcuagccggacguccuccgacucaag\n", + "gcgaguagccccucuaccuccggaagagacgagugcgguaacaccguucacagagcuagccggacguccuccgacucaag\n", + "agccccucuaccuccggaagagacgagugcgguaacaccguucacagagcuagccggacguccuccgacucaag\n", + "cgcgcuuccpaggcuugucccaagcucacggaccccucgcupugccgguuaagaccccgcuccccgucgccagugcu\n", + "agaggacauaugucuccugcgauucaauaugccaggaugauaaaaaugcaacagaaucuuaaaaua\n", + "uuuuguguagccgccgaaccuuguuggagguucupcgcagaaccgcuacugcugcuucggucucuccuup\n", + "auuuuguguagccgccgaaccuuguuggagguucupcgcagaaccgcuacugcugcuucggucucuccuupuaagugcggcggcugucuguaacgacg\n", + "acugupuaggagacggccgucggcggaggcgccauuuuguguagccgccgaaccuuguuggagguucupcgcagaaccgcuacugcugcuucggucucuccuup\n", + "cuugucuccuagaaaaaauaaaauuugaaccuuuuggagcugugugcuaaaucuucagupaca\n", + "auacagucucgcugugaugcccaggcuggagugcaauggcgugauuuuggcucacugcaaccucucccacccagguucaagugauucuccugccucagccucccgagcagcupauuacag\n", + "aacagaaaccuggaaaucuaaggcucaaagacauccaaguaauugguaucupagauuupauucaaacccagcucugcuugacuug\n", + "acucugcauacugaauaauaggugaaauaaggaaagacuuugagaagcaauaagaaauauaucugauuugaccuuguccauuag\n", + "ggaaaauacccgccaacgacccaaaaaaggccggcggcpuggacgcggcgcgcgaggacccgagccaggcpacaggacggcpcgagccag\n", + "acaaaaaguaaccuuccugaagaggacaugugauuggaaguugucaauuguugaagcauugguaacuccagucucuaacguuuuagaaaaucauaacaagcgguucucuacccuguaaag\n", + "agacaaaaaguaaccuuccugaagaggacaugugauuggaaguugucaauuguugaagcauugguaacuccagucucuaacguuuuagaaaaucauaacaagcgguucucuacccuguaaag\n", + "gagaaaagcaaaggaggugaguacpacaugcuggauuugagaugccagcaagauaucupuggacucccuuguaggcaguuuuacuuaugaaauuggaggccagcugcaaggucug\n", + "ugugauuggaaguugucaauuguugaagcauugguaacuccagucucuaacguuuuagaaaaucauaacaagcgguucucuacccuguaaag\n", + "auuuaugugaucccaaugcaaugcaaugcaauuccaauaagaauccccauaugguuuuugaggaacucagauggaaaugugaapuucauguccuugguaag\n", + "acccgccaacgacccaaaaaaggccggcggcpuggacgcggcgcgcgaggacccgagccaggcpacaggacggcpcgagccag\n", + "aggcucugcccuuauccacpcuagccauaccugaaacgugagguugcagaucugcacugaagcacucugaggaaacacacugcaguggcuuuupcucagcauucaggaguuuucagcauaag\n", + "auugugaccagapuuuguguggcugaagaggcaggaggaacaguguauccacagcgupacc\n", + "caccacgcuuccuaugugacccgccupcaacgccgaacccagucgcgcagcgcugcagugaauuuuccccccaaacugcaauaagccgccuuccaag\n", + "gccaagauguucauaaauauaaagagcaucuuauggauguguucaaccuuaauaguaacccaugcgcuacauaaag\n", + "ucaaagupaaaaagcccaccggugapcucccucucuggaaaagucagccuaccuugucauuuuucaacg\n", + "acuccauggaggugcagagauaaggccccagacauuuuggcccaguaupacaacuuugaccgucuuuuucagcuucaggacucccauggaguugg\n", + "aauuaccaccagccagccauuuugaauucaucggcucuucggcaaauugcagaaggcaccaguaucucugaa\n", + "agucgacccaapuggagaagapaaggcgaaggacgcgcguucccpcucgugaccgccagcggcccpaacccgcucccagacagacucggagag\n", + "guacucgccacggcacccaggcugcgcgcacgcggucccggugugcagcuggagagcgagcggccaccpagcccccggcacagcccgcgcccgccccgcaggagcccgcgaag\n", + "gaapcggacguacucgccacggcacccaggcugcgcgcacgcggucccggugugcagcuggagagcgagcggccaccpagcccccggcacagcccgcgcccgccccgcaggagcccgcgaag\n", + "gcuuccuccuuggapaccucagaagucccaggcuucauagugucaaguucaacagaaagaguaguuuucaucuuuccacaguucuuagaaaaguccugagacugaguuuuacugg\n", + "ccuccaggucaccauccuugucaccucuacugccagagacaucgagugccuugaaguccupcuuuccpauucugup\n", + "ggauuccucuagccacuccucucaagagcuagucaacgaguuugccucccaaacacgcuggaaggaugcucagaggaccccucagaggcuguuuucp\n", + "cgcagaguupagaaggcapuppuguggaaaaauaaaaggaaaaguccuugcaccauguagaucagcgucccccacuuuggcaucccggccggccpaccucccagucugcggcc\n", + "acuggagcccuuccccgacuaugugacgugcuacaagugcugupaagagcaagaccagugccugcaggaacucuccagagagcagacaggagaccupcacggagcagccagugccag\n", + "cucauuucuagccccuuccaagccugaccccagcgaugaccucucagapcacpuuccagaagucuguugcaggaagcaguuucccuguguggcugcccuuggaucaacuuupagaauug\n", + "cgugauucauucacagcggcagacgagcgccaggaaapuuauuugaucugaucccucaaguuccggaggcagcag\n", + "gcaggugcuupcguagccuggagugapuuuggcugguguagcuuggagugaggcccccuggcguggagucuugaggccugcugapcgugagcuggc\n", + "gguuuggcugguguagcuuggagugaggcccccuggcguggagucuugaggccugcugapcgugagcuggc\n", + "caacaggugagaagaaggaaugcuggucgupaguccuaccuagaggagcagaaggccauuacugcuccagucagccucuuccaggac\n", + "gugcuupcguagccuggagugapuuuggcugguguagcuuggagugaggcccccuggcguggagucuugaggccugcugapcgugagcuggc\n", + "gcaggcgcgcggcgcccggcucggaccguagcuaggcgcupcggccaccggcuggccaggcag\n", + "acucuacuacucaauaauaguuuuguuauguaggaagaugcagcagcuuguuugugugaacuucugcuuccacuacaaacaguacuuuaaagacaggccuuccacugccauucagaaag\n", + "cagccauggaggauacucuaguuucuuupaagauaaacacucaaucugcuaguuaagagacaaagcucaagagaaauaagcugaagcuguaaccuccauuucaaacuugugguucugc\n", + "gccacuuggucauucuggcauuuuaugguagagaauacguugaguuuggcucuggaaggaauaugag\n", + "ccauggaggauacucuaguuucuuupaagauaaacacucaaucugcuaguuaagagacaaagcucaagagaaauaagcugaagcuguaaccuccauuucaaacuugugguucugc\n", + "cucuucccgupcpuuaccagucggugcgguupauggugccacugcgcagccgcgagapcgguaccacggcggcagcgac\n", + "gacugcpaguggagccggcgagagaguggcagcpcugauggaagugcagupcuggagapcacccua\n", + "ggaguggagccggcgagagaguggcagcpcugauggaagugcagupcuggagapcacccua\n", + "gugugcpapaagcaggaagugacugcpaguggagccggcgagagaguggcagcpcugauggaagugcagupcuggagapcacccua\n", + "gacuugcgagaagacacgugcgcggaaggagcuugcaguagcpcggcagagcuggagugaapagcuagug\n", + "gaacucgcuucagaccuuugucuuuugaggugcccaaaccauuguuuccuguggcapucccu\n", + "aguuagcgcaagcagcucuggagcpcacaggagcgccggcuccaggcgupaggcupcaggcugcacapcucugccggapcaggapcaca\n", + "ggagcgcccagccugugccaguuagcgcaagcagcucuggagcpcacaggagcgccggcuccaggcgupaggcupcaggcugcacapcucugccggapcaggapcaca\n", + "gaaccauguccuaaaugguuuacacugcgcacagcuuccucucagcccgcucugagcuggaagcagc\n", + "gugcugcugguugaccagccucuggcccuaggagaccccguagcgacugapucccagcaggcc\n", + "agucccuuggucucuucggucuccugccgcccccpaagcgcgcugcgcugccgaggcgagcuaagcgcccgcucgcc\n", + "gcugagcucuguucucuccagcaccucccaacccacuagugccugguucucuugcuccaccaggaacaagccacc\n", + "aacagagccaccuucugcguccugcugagcucuguucucuccagcaccucccaacccacuagugccugguucucuugcuccaccaggaacaagccacc\n", + "aagucaaggugaagaucapuagcccuuuaaaaggccuccuugugcccuagaguugccacagcucuucuacuccacugcugucuaucuugccugccggcacccagccacc\n", + "cggacggagcpcggcuguggccucgccagcuggugagaagcpcgapuccgagguapaag\n", + "cuucuggagcupuccugacuapaccgccupugaggugaggaccugguggccgcaguuguggcacugugcgcaggcgcugaacugaccggacggagcpcggcuguggccucgccagcug\n", + "uggagcupuccugacuapaccgccupugaggugaggaccugguggccgcaguuguggcacugugcgcaggcgcugaacugaccggacggagcpcggcuguggccucgccagcug\n", + "aaaccaggucuccuuauguugcccaggcuggucuuggaacuccuaggcucaagugauccucccgccucagccuuuggagugguuacag\n", + "aagcacuuccuuuuccuguggcagcagccpcugagaggagcguggcugucuccucucuccgcc\n", + "gcauaccagguagaucaagaugcacacaccagaagaugauagaguaugacaggauccgagcuacaagcaaggagcuug\n", + "gucaucagacuagugcugagucuupuacuggcagagcuguggcucgaauucccagaguucgagguggupacucaccgcucuggccapugcuuuuggaaac\n", + "guacacacacucacacaaggacgccaaccccaccuagaugcaaagcaggauucaaaagaacaucuuugcguuuucuaccggcuccccaucaucguacuapaggaagaagcgg\n", + "acacaacuggaacccaucuccaggaacaaacagcuggaacccaucucccguugaapaaacugccagauuuuuguaagauucuuccuccugg\n", + "acuucggcgacgcuuccccgagaguagccccccuccucaacccagaaaagacaaccccgcpcugcagcgagccag\n", + "ugccaggccpcaccugguguguaaccaaugccgccagaaguugagcugcugcccgacgugcapcgcccugacgcccagcaucaggaaccuggcu\n", + "pcpcggagcgcpcgcggcpcpcggccaggcuagucpcpugcgcpcgcucpcccpccagagcuggagccggagccpcpcgcc\n", + "ccucggaccuagcuccggcccucggucuauccgguugcauccucccucccuguuccggaucuuaucuugcgccagcgccuacuccaggaucccguagccagaccucaagcc\n", + "gcaaucagauuupcpcuaggapuuupucuucaggucacaucuggacggagagaccuccpccuccguuggucgguccuuccgcuccggauaccguuccgg\n", + "puucaacuagauauagcuucacaaucucuggaucaagaaauuuuauuaaaaguuaaaacugaaauugaagaagagcuaaaaucucuggacaaagaaauuucugaag\n", + "gccagugacauaucaggcauuucpaauguacacuggagaccacaguucaugccagcggcuggaauaag\n", + "gccgcupacccugucggaagcaacugccgccgccgccucuuucaucucuucupcapccapccag\n", + "uccuaaacupaucuupuaggaggaagaaaagauaaggaguuccucuaucugaaauuagucpcuguuuugaggaguacugguuag\n", + "ggcggcgguagauuapccgcpucggagcacucaccgccgcupacccugucggaagcaacugccgccgccgccucuuucaucucuucupcapccapccag\n", + "aucugapcgcacggcccgcgaccgagcgugcggacuggccucccaagcgupcgacaagcugccggagcugca\n", + "gucucuguguagaaaaaagagcauucuacagacuuauaucuggccuacaugcaagcauuaaugugcauuugagugcaagauaucuuuuacaag\n", + "gugcaugcugcggcaguugcaacaggagaaccgaguaccaguugcucaacacuuuaucacuuugcauugcucuuucuccucccuuaagugaauuuccauuuugapuacagcuccacaggagaaag\n", + "aaccucccuccccucccaggcgccgccgcagccggagcggcucccpcccupccgccgccggccag\n", + "acugccugcaapauggucauacuccuggcugcacuuccagagucuugaagaagaaagcagauguggauaccuaaauauagg\n", + "paaccucccuccccucccaggcgccgccgcagccggagcggcucccpcccupccgccgccggccag\n", + "agacaaagccgcccgcccgccagcccgcuagcuccucgcgcgagcuccuccuccacpaaccucccuccccucccaggcgccgccgcagccggagcggcucccpcccupccgccgccggccag\n", + "gaaguguuuggauugugagcuauuucagaacuguucucaggacucauuauuuuaacauuupagaaacacagccagaag\n", + "augcacacuugacugaaggaggacapaaucugaagacuccggaugacaucagagcuacuuuucaacagccuucucaauuuucuuucucagaaagcagaggcucagagcuuggagacagacg\n", + "gcuggagacuucgcagugacaaagcagccgaggauuaacccugcuccupuccuacgucuguccapagcugagcpcgcuccucag\n", + "guguuuggcgauccgccgagaaguuguuggccccaggagcaucccucpccgaaugcgcaguggacg\n", + "acuuccuccgcgguuccucggagccgccucgcuccucuucapacuuugcugagaapcucucpcguccagaccccaccgcaaag\n", + "ggucucacacuguugcccaggcugaagugcucacggcucacugcaguuucaaguuccupcucaa\n", + "agaupagucucccuauguugcccaggcuggucuccaacaccupcucaaguggcuuggccucccaaagcgcupauuauag\n", + "agaggcgcucapuggcagcagagcagacgccpcugcgcgcupagcugcggucuccggcc\n", + "cccpauguuagaggcgcucapuggcagcagagcagacgccpcugcgcgcupagcugcggucuccggcc\n", + "aaaaaaaaaagugaaugccugcaguuaaaaauuuuggugcuucagaaugaacuggaacggcagaagaaagcuuupacpagguggcauuacugcauaagcaacaaauugcauuacaagacaaag\n", + "gaagugcauuuucagcugagcaccucaaacuucaacuccagaaggaaucccuaaaugagcugaggaaggagugcacugcaaaaag\n", + "agaacucuucuugaagacuaaugcucaguugacaauucguugcaggcaguuacucucugagcuuuccuacauuuacccuauugauuug\n", + "acaucccagacgaupcggccaggcagagacgcuccucacuuccuagacpuggcggccpcagaggcugcacucugg\n", + "agugcucagcucccuugccaugcgauacccugcaaguccucaccagcaaaaaggcucucaccagaggcugccccucggccuguguuaucagauuuuuug\n", + "cggcgucuucgacaucuucggaacauugcugcccggaacauuguuaauagaaauggccaucagcuccuugauaccuacuuuacacuucacuuguguaguacugaaaagauauauaaag\n", + "gcuucauagagcccagugugcaauuaaacagacucagguaacuguucagaaaauuggaaaggaaauugaagaaaaacuaagacucacaucuacaagcaaugaacug\n", + "ccccaucacacacaccaggcccugccaggacaaggcagcuccuggaagcuccaccaggacccacguccaccag\n", + "ucacacacaccaggcccugccaggacaaggcagcuccuggaagcuccaccaggacccacguccaccag\n", + "cacacacaccaggcccugccaggacaaggcagcuccuggaagcuccaccaggacccacguccaccag\n", + "acacacaccaggcccugccaggacaaggcagcuccuggaagcuccaccaggacccacguccaccag\n", + "guugcugaaugcuauaaagccaggacuuguuaaaaagaucaauagauugccuacccccauugcaggacug\n", + "gacaauauuaucuuauucuugagagguuguaaagagcucggccuuaaagaaucucaacuuuuugacccgagugaccuccaggauacauccaacagaguaacagucaa\n", + "guauuaguuaccauuuacuggcupaaaagcagcaaacagcugcacauccuacagcggaacgacacuaaaccugaaggaguuugaaggauuguuggcucag\n", + "caaguaacuggcagaaguuuuggugauaaagauuuucggacagguuuagaaaauggaauccuccucugcga\n", + "aaaaagguggcguauauauugacacuacuaaaacagaucugccaaagagccuguugaauuuuucuuuguaaugcaacuuuuuggagccaacu\n", + "ugccuccaaagccauuacaccugcagaauucaccuucguccaauauacaccaaacccccaggcauaaagcuuuaccuagugcaaaaccaagg\n", + "gagacuaaugagcaaaaacuucacaaaauagccaaugaacuuuugcuuacugaaagagcuuaugucaaccgacuugaccucuuagaucag\n", + "auggagucucacucugucaccuaggcuggugugcaguggcacagucuuggcucacugcaaccuccgccucccggauucaagcaauucucccaccucagucuccugaguagcugagauuacag\n", + "auggagucuaguucugucgcccaggcuggagcccaguggugugaucucagcucacugcaaucuccaccuccuggcuucaagcgauucuucugcuucagccucccga\n", + "ggucucauucugucgcccaggcuggagugcaguggugcagucucggcucacuguaaccuccgucucccaggcucaagcuauucucgugccucagccuuccaaauagcupauuacag\n", + "acuuccggcgcacugaucccgccupccggcugaguggcacuuaagcpccaugccaugcaaccuupcgcugccaaccgupcgagcucupugugcpcggccuggcgcggcgcuccg\n", + "cagcaggcpcacccggacuggcggcuucgcuggcgcaaggucgguccggcggccapaccuggaaggcugcgaggcccugcgaggucgagguucggaguuugcuggucccaggcccggcccgag\n", + "gccaccggagccgccagcuguuuggaacugagcuacugcagaaapaaguggagaguaapccaggccccgupcag\n", + "agcaggcpcacccggacuggcggcuucgcuggcgcaaggucgguccggcggccapaccuggaaggcugcgaggcccugcgaggucgagguucggaguuugcuggucccaggcccggcccgag\n", + "ccagcuguuuggaacugagcuacugcagaaapaaguggagaguaapccaggccccgupcag\n", + "gucgucucccggcagugcagcugccgcuaccgccgcccucugcccgccggcccgucugucuacccccagc\n", + "auucuucucccggugcccgcugagccgapcaagaagagaacaaggacccucucggccucaggaaucuucuccccagagacuccuaagupcacacugcuucu\n", + "agucuggcggcggcugccgugagcugacugacguuccpaacgccgcagcagcccgcgccgcccgcagccuagccgagccgcgccgcccpccucgcccgcccgccugcccgccaugguguc\n", + "agucuggcggcggcugccgugagcugacugacguuccpaacgccgcagcagcccgcgccgcccgcagccuagccgagccgcgccgcccpccucgcccgcccgccugcccgcc\n", + "cagucuggcggcggcugccgugagcugacugacguuccpaacgccgcagcagcccgcgccgcccgcagccuagccgagccgcgccgcccpccucgcccgcccgccugcccgccaugguguc\n", + "gcuuauauuuggcacccuuuacccugcguauuauuccuacaaggcugugaaaucaaaggacauuaaggaau\n", + "paacgccgcagcagcccgcgccgcccgcagccuagccgagccgcgccgcccpccucgcccgcccgccugcccgcc\n", + "uuuacgcggcgauuucaucaugcuccgagccpcggcgcgcgccgcuuccgucgccacccucucuggacagcccapccgcaggcuc\n", + "gauuucaucaugcuccgagccpcggcgcgcgccgcuuccgucgccacccucucuggacagcccapccgcaggcucaugcccucuccgcguccagugcugcuuagag\n", + "ggagaucuugugcgaaaacucaaagaagauaaagcaccccaaguagacguagacaaagcaguggcugagcucaaagcccgcaagapuucuggaagcaaag\n", + "gauuucaucaugcuccgagccpcggcgcgcgccgcuuccgucgccacccucucuggacagcccapccgcaggcuc\n", + "guuuacgcggcgauuucaucaugcuccgagccpcggcgcgcgccgcuuccgucgccacccucucuggacagcccapccgcaggcuc\n", + "gcggcgauuucaucaugcuccgagccpcggcgcgcgccgcuuccgucgccacccucucuggacagcccapccgcaggcuc\n", + "pcugcgcagaguagcapcccuggapcgcggccugaauccugauugcccuucugcugagaggacacacgcagcugaagaugaauuupaaaaguagccgcuugcuacuuuaacu\n", + "caucucaguuauaagaaaugcacaucuccgcucaagguccccupacagugcaaggaaagaaagaagccugcggugaaagugacacuga\n", + "auuccagaaauaaauuggaaauugaagauuuaaacaauguuguuuuaaaauauucuaacuucaaagaaugaugccagaaacuuaaaaag\n", + "aagccaagucauccagaagccagcuucugcagcuccaaagapccuuagcaguuacaaagaaacacaagauaacg\n", + "acugcpagcagcguccucccpccacggcgcuucccggccccggcguccccggaccauggcgcucuccpcucuucucuagcucucagcggcugcgaagucuguaaaccugguggccaa\n", + "gaccugcgccuuuuacccaccgcggcgccggucucacgugcagucccuucgcucuucuccccuaguucggugcc\n", + "aaaaugcacggaauugcuccugcuucaagaugucaagaccgapagcuugagcuguucuauaccuuuuccpaaggacaacugag\n", + "ucccacaggaucacauguugaaugguguaaacagcuuauagcugcuacaauuucuagucagauuucagguucagugacaucagaaaauguguccagagauuacaag\n", + "gaucacauguugaaugguguaaacagcuuauagcugcuacaauuucuagucagauuucagguucagugacaucagaaaauguguccagagauuacaag\n", + "uugcuaaaaugcacggaauugcuccugcuucaagaugucaagaccgapagcuugagcuguucuauaccuuuuccpaaggacaacugag\n", + "ggaggaauugcuaaaaugcacggaauugcuccugcuucaagaugucaagaccgapagcuugagcuguucuauaccuuuuccpaaggacaacugag\n", + "pagaaagagagacggagagagagagagacgcacagaugugcacggaggccacagacacugacauuuggaauuccuucagg\n", + "cggacggaauagaccucagcagcggcguggugaggacuuagcupaccuggaaucguauccuccuguguuuuuucagacuccuuggaaauuaaggaaugcaauucugccacc\n", + "ggagaaagagagacggagagagagagagacgcacagaugugcacggaggccacagacacugacauuuggaauuccuucagg\n", + "gaaugaaggaupapagaaagagagacggagagagagagagacgcacagaugugcacggaggccacagacacugacauuuggaauuccuucagg\n", + "gauugaaaaaacguacaaggaaggccuuuggaauacggaagaaagaaaaggacacugauucuacgu\n", + "agauguggcccagccuggagugcaguggugugauccuagcucacugccaccuugacuuccupcucaagugauucuucugccucagccuccaaguagcuugccaaaacuuggaagcaacc\n", + "papagaaagagagacggagagagagagagacgcacagaugugcacggaggccacagacacugacauuuggaauuccuucagg\n", + "cucccggcggcccauacpaaucgcggagcuuagcugucgccaccucgcgccpuccgcgcggcccacpaccccccacugacgcccccggccagcgguccac\n", + "auacpaaucgcggagcuuagcugucgccaccucgcgccpuccgcgcggcccacpaccccccacugacgcccccggccagcgguccac\n", + "cuccagcuccagaaaucccaguaccugcaacupccccagccgaggccaguacuauggcpucccugcccaacgugaaccagaucpaguggcacc\n", + "gagacpuuucaccgugucagccaggauggucucgaucuccugaccucaugauccucccaccucagccucccaaagugcupauuacaggcgugagccgcggcgcccggcagag\n", + "uucguguuuaguaggagcacaguagcuguuupaacgaccuuaagugaauagaugucugaaaugcugugugaagupcgcuuaauaggug\n", + "uguuguuggaaguggaggcagcagugacaapaagcuuucccugcaggauguagcugagcugauucpccagagccugccagapuggugguc\n", + "agucgccccggcaacagccgccucccucgcgucccccacucccccucugucucuccaaggaaaacuaggccccugcgcggccaacgcccaggauccgcaagcugcgcgcccacgag\n", + "cuccaccagcccauuggagaaaaguuacuguucagucccugaaggcuugugccauaaaagagupagacauucccapag\n", + "cagucgccccggcaacagccgccucccucgcgucccccacucccccucugucucuccaaggaaaacuaggccccugcgcggccaacgcccaggauccgcaagcugcgcgcccacgag\n", + "agcagcaggaggaggcagagcacagcaucgucpaccagacucgucucaggccaguugcagccuucucagccaaacgccgaccaag\n", + "gaggaaagaaaacaagaggugagugaggcaacugaaaacuguucuuggaccugcggugcuauagagcag\n", + "aaaagcauaaagaauguauaacaaccuaauuguuacaapaguggaauuaauaaucuacaagaaggcacaaaaggacagaaaagaaacagaacaaaugagaaaaauagaaagccaacaguaauaug\n", + "gcgcgcpcpcpcuauggcgcaggcpuugupccggcgcugguggcpcccggugcauggcggucugucggcggagucgcccucpcugucag\n", + "auuugugacccagaaggaaaucucugaccucagcuguggcucuuggugcuggccagaagccaacuucaugucugagugcacgagcagcaguuugcc\n", + "ggccggcgcugguggcpcccggugcauggcggucugucggcggagucgcccucpcugucag\n", + "ccpcccugcggagcgugagcagcuagcacccggcpccagcgagcgucccugcagccagcgagcaggaggaggagcugcugccpcggapcagccgcpagccgaagapcgccccag\n", + "gugguugcccccucccucuccugagaugucaggaaggapccaccuguguccuccacapccccccgaagccupacucccagccccagagcuccgaggcggaggaggugcugacag\n", + "auuccuuuuuaaacaauauccauucucuugaugucuacaauaucaccuuucuuauagauucgcauauacauggccaaaggaacaacuccauguuuucuaaaaggccuagagaacauacaucag\n", + "cucaccaggacaugauuauagcuucucaagcuuaucuaaaauaaaagauaacauauauaucaacauuuuugaugaa\n", + "guuuucuuaugauaugucauucucaauaauauuucuuauuuauuuagaaaguugaaauaaaaggaccauc\n", + "auucucuugaugucuacaauaucaccuuucuuauagauucgcauauacauggccaaaggaacaacuccauguuuucuaaaaggccuagagaacauacaucag\n", + "gguuggugaucauccuagccugcgguagauggugcgcccugccuucccugcccagacguaagaaaagugcacuguccguccag\n", + "uacaauaucaccuuucuuauagauucgcauauacauggccaaaggaacaacuccauguuuucuaaaaggccuagagaacauacaucag\n", + "gcggupcgguuggugaucauccuagccugcgguagauggugcgcccugccuucccugcccagacguaagaaaagugcacuguccguccag\n", + "aucuggauuuuggacauuguuagguuugagaugcuguuggauauacauguggagauaccuagcaagcaguuagaaaugaagguuuggaguucagaagagaugacuagagaaaaau\n", + "agguuacauugauuacccaccuaguacaacaucuuacpaagagcauaguauuuccuagaggaauaugaacauaacaggaag\n", + "cuccugguacaguuuguucagaauacguccaucccauupacapcuuguagaaucagaagcuaaagauauuacuugcuugucccuccuucccgugacugaagccucagaaugcagucggcua\n", + "aaacuuccugucccgcgcucgagcugcuuccggcpagccggaagacgcuguguguggacggaauucpaccgacugacggccggccggcuucccggaacuggaag\n", + "aaaugaccgcuccuucaucuguccugcagaagguugupaaaagcuucuaugugcugcagaggcugaaggugcac\n", + "gccaaacuuccugucccgcgcucgagcugcuuccggcpagccggaagacgcuguguguggacggaauucpaccgacugacggccggccggcuucccggaacuggaag\n", + "guguguggacggaauucpaccgacugacggccggccggcuucccggaacuggaaggugagcuccgag\n", + "guuugagaugcuguuggauauacauguggagauaccuagcaagcaguuagaaaugaagguuuggaguucagaagagaugacuagagaaaaau\n", + "cgcgccgccggcccuagucugccuguuuucgacucgcgcuccggcugcugucacuuggcucucuggcuggagcuugaggacgcaaggapuuugucacuggcagacucgagacuguaggcacugcc\n", + "agucugccuguuuucgacucgcgcuccggcugcugucacuuggcucucuggcuggagcuugaggacgcaaggapuuugucacuggcagacucgagacuguaggcacugcc\n", + "gcggcupccupcpcggcgcpcugcuccggaggcucpuggcuugagagucuupaggcuccpcgcugcccgcgcggucgccggc\n", + "acccgugccuguauauuccacgcuuugcgcaccugcuggaauucpagaagaaccacgaggugucc\n", + "gugcuggcaaaaccccgacucupuggcggcuuccacgugaaucupaaggagucgagagcgcagacccugcagaaug\n", + "ggaggcgccacauccaccaccupaaccagcugcagcugaaccagcacugccuggacaccgccuucaacuucuucaag\n", + "ccgccaaggacacacccaccgaggccacagcugcgauuucauagugupaccccacuggcaaagacacgcuggcugcuguggccgugguuucugucccagccgucuguuuccauagaaaaag\n", + "gugaauguguacgugcuuggaaagacguuucuucucuuggcaagagagcucugcaucaaugcgccggccauag\n", + "cagccagccugcaugagguucucuacguuugagacuggcuucuccacggaacuuggucuguagccacagagcaaacugcapccauugacagaga\n", + "aacgcuaaccugguccggagcgagucupucucagccccgcgaacagccuuucacgagucuucaagcuuucag\n", + "aucccccuuagcaccucugguacuguaccguaccuugccuuucuguccagguuugguggaauugaccuauauauaaaugguauaaagag\n", + "ggauuuaaugugcaaaauggcgauuauaccagacuggcuuaggucgcauccucacacacgaaaauuuacacauucaagaccccauucuucaccguguagaguauauucaagga\n", + "ccaggcuuupcuagcgccggagacuuccaggcggacucgagaaccacguggaugcugcgcupccguacupccguggcgauaacccug\n", + "acggcpcupccggagccgagccpucpcagcagcapaccccccagaggcpccugupaccgcuaupcguggagaucgagaccaucucccccggagacg\n", + "gcgagguagagugaguucuucaggacugcuggcaggaagaucaugagcagguguuuguuccaapag\n", + "cuccggcucugcaguggcggcgaggaggcgagccggagcgacggcpcupccggagccgagccpucpcagcagcapaccccccagaggcpccugupaccgcu\n", + "gcaguggcggcgaggaggcgagccggagcgacggcpcupccggagccgagccpucpcagcagcapaccccccagaggcpccugupaccgcu\n", + "gaagcauggcacucuggcpcauaccagcpcccuggccgcucacccguggaaaguacagguccugacagcug\n", + "gccuccuggacugaaggacacgcuuccugcuccucacuccaagaagccacuucuugccccucugccuucugcgcaugaaacucaaaagccacaaaa\n", + "uccuuuugucccguggcaaguuggcugccuguupaagucagagguggcgacuucaacuccgucggaggcaacucacuuuguuggapauguauagg\n", + "agauggcggapacgaggcagcgcgapcagcaaccgcaccapcuguggcgccggcgacggaccagcgacccaagcgccgcgguuaaccacgucucguccacgaccucccuag\n", + "acuguggugcgaauugaucgcaugaaauccugauugaaaauuuugaugguacuuaagaaaggcauaaaguuuuuucaaaggcuuauaaauaguaaaagccuacgauuug\n", + "aguccaggccuugagacccagaapagcgaagguuuuugcugcgccaacgcagugaccgaaggcuccgcucacgcccgg\n", + "cucauuuucucuugccgccaccauguaagaagcgccuuucgccucccuccaugauucugaggccuccccagccacaugguacu\n", + "uguaugccuagacagcpcacapcuugcuggacacagaaggcaaggacucagagaauauccaccagaugaaagaaugacugcauga\n", + "gcapaguuuucccauguuccaggaggcagccagcuuguaacuagcaagcauugcuauguuuguauuucugauacauuuucuaaaagagaucgcagaacaaapuccugacucaccaaggauacag\n", + "pupaguguuguuaaccggapcagccgcagucgcgcggauugagcpcucgcggcgcupuuccug\n", + "ugcaugaugagucccaaggagaggaaagcagaaagugaccucaaaccacagccucuccccacuccuagguccuguacauccaggccuuuguccuugucuuccuucupcaaggug\n", + "acaguuuucacaaaggucucuugauaucaaaacuucuuuccuugcaugcuucucugauccuguggag\n", + "aguuuucacaaaggucucuugauaucaaaacuucuuuccuugcaugcuucucugauccuguggagaugaaaauugacauccauagucauauucuaccaaaagaauggccagaucuaaaaaag\n", + "acccugagacaaggauucagaugcaaguaguuugcuuuggaggugaucccaggaaacaccaguagagugaggaagugagacapaaaacapcagccagugaaag\n", + "acucgccucauuuucucuaagcagagcaacuucgcggacagcggagcucgcccagcauggauguuccag\n", + "agugcgcgugcgccgcuuguupccgcauggcuuucggccggccguucapacuggcugccggacggcgacugcggccuuu\n", + "agucacacagcugccugguaggugacuggaggccuugaucgguucuuauupauuuugcugcuguggccccaacccuuccucccuccccacccugca\n", + "gcacgagaucugcgccucgccucccuccucacgcpcggauuuucuuaccuugugaaaaaccgucucagcggcugcccccgccuccucugcuggaugugaaauggcggucggcgag\n", + "aauaaaacccaagacaagccacauaaaagcaaccuaaaaauuaaacugucaucauauuauuuguuuuaaaacuauggaauaauauaucugaggaagauuucucucaaaauuguuuuucucaauuucaa\n", + "gucagaagacaugucuucaucuacauggcaucuuuccuuaccucuaugugccauacgaugguuauggacagcagccagaaagcuaucuuucucag\n", + "aaaggagapupagcpupcaucgcgacccapcaaggcggcgagucgccgucuucgagucccaccuguccgaagcp\n", + "gacgagcacaaguguguggugagguacagapaaaacauacagupuacuggucccugugcgccgccgucaacagagcccucgacgaag\n", + "ggauaccaauaacuagugccucguacuacgcgacagugacccuggaucagguucggaauauacuucguucugacacagacguuucc\n", + "gcuacugcagcacupugucaguuguugguccgacccagaacgcuucaguucugcucugcaaggauauauaauaacug\n", + "apcgcuccaggcgacagcacugcagacgccauuauccucuguuucucugcugcaccgaccucgacgucuugccugugucccacuuguucgcggccuauag\n", + "ggacgcgagaaggcpapagccugcgcucguuuucugucuagcuccgaccggcugaggcggcgcggcagcggapacggcagucucgcgcg\n", + "cgagaaaggaggapcgcuccaggcgacagcacugcagacgccauuauccucuguuucucugcugcaccgaccucgacgucuugccugugucccacuuguucgcggccuauag\n", + "acccgacucccaggccggcgaccgcugagccucccgagaccccgupccgcucgagugacag\n", + "cgacacuugacccagaccagucccaacgcccagugcggccgcccpagccgcpagaggcggcggcppaggapagaggapccgagccggcggcacpaggcccg\n", + "aguugaaaacuaaaagcccuaucccucaaggaacuuacaguccagugacauuacuuauggagagaguaaagcagg\n", + "gacaacaaaagacgcggacggcggcugcgcgguguggcagagcgaagcugaggaguccagcgcucgccgacapccupcugucccgagccg\n", + "gaauccagaucuuacauaagauggaagucucucacacuagauacugaacauuaaauagaaaaucuauuuaguaaaaucuaaguugcc\n", + "aaacagcuuuaaccuggauguggaggaggaugacauugagaaucucuuagaggugguucaugaggaaupuuaaugaggagucauuggaacugauacaggaacauguagcugaagaagag\n", + "ggacacuugacauucapacguggccauagaauucucucaggaggaguggaaaugccuggacccugugcagaaggcuuuauacapaugug\n", + "ccccccgagcuccccgcuaacccagcccccagapcccaaguucccucgugugaagaacupaggupagcaucaccuaugacacccucagcgcccaggcgcagcag\n", + "auccgccauguuagauucaccccacapauagcggcagagccgguagcggacgguccuugcauuggccuccggcaggcgccccccpcpaagcug\n", + "agauucaccccacapauagcggcagagccgguagcggacgguccuugcauuggccuccggcaggcgccccccpcpaagcug\n", + "uugcugagagauggauguuaaaaaucaacaccaggacuacaguaaggcugaaaucauugaagugcuuggagugcagaacugaaagag\n", + "gcuagcugccggcgcuccccuccguuugcacccacggccgcccuauugcggcuggcacuacgcuucugccaggaccccggcucccuuuuccguugaccugguguucguuuuccaugug\n", + "gaacuggugacacucapauguggucaucaacuucucucaggaggaaupaauaucuggauucugcucagaggaacuuguacupaugug\n", + "uuucauupaucauguccauggagcuccucaugcugucaugccagaaguggaauucccugaccaauucuuuacaguucuaaccauggaccau\n", + "gaacuggugacacucapauguggucaucaacuucucucaggaggaaupaauaucuggauucugcucagaggaacuuguacupaugugaugauggagaacuacagcaacuuacucucacugg\n", + "gucuacauugagacagauaucgguacaauggugaccaagaccaauacagacccugcucucauggaauugacauacuaguucuugagauguauaauaaacaa\n", + "auuuggaguccaggaaugagacuaagcauuuaucuguaggaaaagauauuauucaaaacacugguucucagupaggua\n", + "gcacaauucugucuucucuugaacugcauaacugagaacucugcaaauuccccaaagaaggaggaaaa\n", + "cuaaaacccaaucucggauauacuacuaauaggcgcggcgcucggacuauaaaacacaacaaaucauaaacccggcggagcagcagcggccgcgcgcgccuccccuccca\n", + "agcauucuuuuggacaccacaccuaggucggagcacugucguccuucapcuccagccucuugauauuuuuguacuucaguaucagcucgauagagcaaaagagagagaggacgagagap\n", + "gcgcggcgcucggacuauaaaacacaacaaaucauaaacccggcggagcagcagcggccgcgcgcgccuccccuccca\n", + "gcagaaaccccagcaugacaagcaaguaggaaggugacauuguuguuugagaaaagccagugacccgguupacggagacacgaupagccggucuccaacagcaugcccuuccugaag\n", + "aacagcuaguaggcuaaggccagacacugacacuugcaguugucuuugguaguuuuuuugcacuaacuucaggaaccagcucaugaucucagg\n", + "uuugcacuaacuucaggaaccagcucaugaucucaggauguauggaaaaauaaucuuuguauuacuauugucag\n", + "guacggugacuguguuuugagapugaacuccgaaaauaacaguaauuugacacaccagccauuaagaaggcaaagag\n", + "gcuuaccuacugccuucuccgaccguccguccucpcaggcgugcucucuucccugagcuuuuapuuggcuuuuccaguuccagaucagcuacagcaaacaucguucgag\n", + "ccaggcaggagcaacgcgcgcpuccguucugcugccacccucccaggucucggccguccagccgaucugacagccggcg\n", + "gacuguacaucagaggaagccaaaagccagcuggaauacuuccugaauacaguuuuaaucuuguuugcaauuauuucgaapagaaaucaucuggaucag\n", + "pagccpagcpcuggcccgcgcuccuccugcuggcupauuuuccagccupcgcugacgccgcggaccucccugcgaccgucgcggacc\n", + "pacacgccgagguaacuuccapugcgccuucguugucuucuccaagcuguaguucuacgucccgaccucccuaucauaccacacucuucagcgaccacgcaggcacuuucccgguccccag\n", + "cacgccgagguaacuuccapugcgccuucguugucuucuccaagcuguaguucuacgucccgaccucccuaucauaccacacucuucagcgaccacgcaggcacuuucccgguccccag\n", + "agccgcucccgaggccccggcgcggcgcgapcgcpcgcggcguccacaggcgccgaggcugcccccgccgccccgcccgcgaag\n", + "agagcagagcaggacacuggcgccgcpucaggcagcugcgugcgcgucuccuccaggcagcaapaacccgaggccgccggcgcccggacc\n", + "accaaguauccuuuugagacaauaaaggaaauaauguauaaccaggcugugcaguuauuccacgugugaauauaucaccuagc\n", + "accaaguauccuuuugagacaauaaaggaaauaauguauaaccaggcugugcaguuauuccacgugugaauauaucaccuagcaugaccuugaggauag\n", + "gccuacccuuguagcagugauaaggagugugaaguupagguauugccacaguccccaccaaggaucaucggccugc\n", + "agagaaccuagagcugaagguucagagucacccaucucaacaaguccaacagcaucugcaacaucu\n", + "guuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "gaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "gcugccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "ccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "gaacccagugacaauggaccucuuuuuacugaauuaaaguucuaccaacgagcugcaaaaccagagcaaa\n", + "uucagaaauggauucguacccguaagcugaaguaccupuguuccuaaguauupucuggucuacaugacaaaaauggaaaaag\n", + "gagcucgcaaacgccgccucpccucaccpaagccgguucugucaggcpcuccpugaacagcgcag\n", + "cgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "auacugcapugcgaapccggcgccgcugccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "aaauugccugaaaagcaacaaggagauugagaaacagugauuucauauucugagaaacugagaagcuucuguagcccugaacuagaaaauaaggagcugccaaauucagugaag\n", + "pugcgaapccggcgccgcugccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "ggcgccgcugccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "ugcapugcgaapccggcgccgcugccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "acugcapugcgaapccggcgccgcugccgaguuacgagucggcgaaagcggcpaaguucguacupcagaacgcgacpucugcggcuuagg\n", + "agugccuupuacaacuaugucugaguaggcagccgguaacacaaugucucccuugugcaaaguaacucucuuagugagugcucagauaugugaggaaaaaguauuugg\n", + "puacaacuaugucugaguaggcagccgguaacacaaugucucccuugugcaaaguaacucucuuagugagugcucagauaugugaggaaaaaguauuugg\n", + "cagacuuaugaaaauaugcaucaguuuaauacugucuuggaauucaugagauggaagcauaggucaaagcuguuuggagaaaaucagaaguacaguuuuaucuagccacaucuuggag\n", + "gauauuacuuuuuuggucccuauuaaacuauguggcagcaagucacaaaggaggaaucagaaaguaaccugcuccccacccuugguguguaguccaguuagcaag\n", + "acuuaugaaaauaugcaucaguuuaauacugucuuggaauucaugagauggaagcauaggucaaagcuguuuggagaaaaucagaaguacaguuuuaucuagccacaucuuggag\n", + "ucucauguaagucaacaacauccupauupacacacuuucupcacugcuggccagucccaaa\n", + "augccaggauagaagaauuuguuuaugagaaacuggauagaaaagcuccaagucguauaaacaacccagaacuuuupacaauau\n", + "ccacaugcucccaccuaggccgagagcugcuuguugccpcaacgucguggaugcuggaguuggagcugcauugugccuggcaguggugcauccucaugccacpcuag\n", + "gccgagacgcauccagagcuuucgugaccpacuguucugaagcaggccucguggaugacguauccgaccugucagccgcugag\n", + "ggaaugagccuggauccpagccccagapaapcupaggcpaaucuugcuucggaaggacucagagaguccugacuugaaaucucagcccagugcugagucucuagugaacuaag\n", + "gugupaauaaguaucuuuggaagaccaggcacuuuaugcaguauugagcucaggaggcagugaguguuaaggaaupuguaaaa\n", + "caucaacaacagcaacuugugauuggcggugaccggauauucaguugcacauccccacaucaaugcacugccaaug\n", + "auuuupugguuggaggcgguggcggcggcggcgaggapaauuuccuugugccuccauucccpappagcggcguuggaggccaccguuuccag\n", + "uuauuuupugguuggaggcgguggcggcggcggcgaggapaauuuccuugugccuccauucccpappagcggcguuggaggccaccguuuccag\n", + "augaggaaacugaggccuuggacuagaacagaggucuccugacucaguccaggacucuuucuauuacaucaugcggccugauauuugucuuuauggaacucagcaacaucacauacagg\n", + "auauuuuccucuucuggacccuaucuagaagaaguauuccuuagacaauuuccggcuucuuuucucucaugaagaggag\n", + "uuagugcuuuuuaucgucuuaaggagguauuugguggaggcucuuugaaguupuucaggaguguagaauuggcaaaguuauugccagcuuccug\n", + "uauuuupugguuggaggcgguggcggcggcggcgaggapaauuuccuugugccuccauucccpappagcggcguuggaggccaccguuuccag\n", + "ggcgaggapaauuuccuugugccuccauucccpappagcggcguuggaggccaccguuuccag\n", + "acagcaaaaccaacuucuccucagccuugugaagaggaugaggaccuucaggaugauucacuuccauuuaaugaaug\n", + "agugcuuuuuaucgucuuaaggagguauuugguggaggcucuuugaaguupuucaggaguguagaauuggcaaaguuauugccagcuuccug\n", + "aucgucuuaaggagguauuugguggaggcucuuugaaguupuucaggaguguagaauuggcaaaguuauugccagcuuccug\n", + "augaggaaacugaggccuuggacuagaacagaggucuccugacucaguccaggacucuuucuauuacauc\n", + "aguuucacucugucacccaggcucgagugcaguggcguguucucggcucacuacaaccuccguccucupcucaagcaguccucgcaucucagccucccaaggagcupaccucag\n", + "agugcaguugugaaggucagagguaggaagcaugguccuugcuacagauggugaccaugcucacccaaguccauucaacacaaacucagugagugccugug\n", + "cacuuccggcgccgcggcuguuccpcggagaccgcuugugcuggagucggaguuguaacgcuccacugacugauagagcgaccggccgacc\n", + "guuccpcggagaccgcuugugcuggagucggaguuguaacgcuccacugacugauagagcgaccggccgacc\n", + "accugccacucuauuucupugacuuuugucagcugcccagaaucuccaagccaggcugguucucugcauccuuucaaugaccuguuuucuucuguaaccacag\n", + "cacagupccaggauucgccaugcacaggaggagacaggaguacucaucugauacuagagaaaaggaggcuucaccggaaaaucaaag\n", + "guuaauagaupugaugucaagaucacagupccaggauucgccaugcacaggaggagacaggaguacucaucugauacuagagaaaaggaggcuucaccggaaaaucaaag\n", + "ggcgaguuggaguucauccuggaagcgucugcacgacaaggucapaggagguguggaauaacuuuuuc\n", + "agucagcugaggagcugcgguggcucggcgaguuggaguucauccuggaagcgucugcacgacaaggucapaggagguguggaauaacuuuuuc\n", + "caucuuaaauguuaucccuugacuucuggcuuccaugguuucugaugagaaauuggcugcuaaucuuacugaagaucccuuauag\n", + "ugaaucugaauggugccuacccuaagcuggugccuuucagaccugcaggacggcugaucucuccaccucugcuacucucugugauuuucaacauucuucucagccuggcc\n", + "guuuuccaucpaugacaccpagagcucgcucgaagcagupuapacugcugaagcacgugcauucguuacuugaacauu\n", + "guccggacacuguuugucagcggccucccuguggacauuaaacccagagaacucuacuugcucuuccggccguucaag\n", + "gguauucgcuuugaucccgaaaauccacagacucugaggcuagaguuugccaaagccaacaccaag\n", + "agacacucccagagapcaupacguugacugcugaggacugcgcugcugcugupuugagcc\n", + "uaaggcccggcgccugcucugcuacccgcgcugccuuuagcggucgcccccgccgccgcugccapacgugcupaaagcccaagccccpagaag\n", + "gacucpaccugguucpccpugcugaaggagaagccccugugguuugacguauaugacgccuuucccccgcugapagcccgucuuccaaaggccucgagugcgau\n", + "auuuucuccuggacaaggagagagugcggcugcugagagccgagcccagcaaucccgauccucugagucgugaagaapaggcagcgapuupuupccugaggcaag\n", + "gaaguugccugaagugaaggapuagcggcugcagaagcuaaagcuuccgccaaacaaaagaggacagcacuuccggucacgccaucguugcugccuucuucgucaag\n", + "gugaaggcagaguaugugcaucucaaccauccgcucacccucgugaccagagagcgcgauuuggccgugaaggagaaacaccagcuccaagccaagcuggagaaccuagaacagguccugaag\n", + "aguuuguaaucugacacaguacacugcaguugucuccgaggugaaccuccggagccuuggcacagcucgcuucuaaag\n", + "gaaaaugaacugaaggaugccacccapagaguaucuccugagaucccaucaugcaggccuucccacaapcccggcagcaugacaag\n", + "ggugcgcuugagaagcgauggcggcggccugaacucaccuaacaccgcagcagcaaccpcccggccagguucggcguuccgugagugaacg\n", + "gcguguggcgcpcpcgcggcuggugcgcuugagaagcgauggcggcggccugaacucaccuaacaccgcagcagcaaccpcccggccagguucggcguuccgugagugaacg\n", + "ggccacgcggccuacgcagccgagucggaaccaaccgguuguuuggugaaaccuaccccagagccucccgcggcccacagagcacag\n", + "gcggcggccaucucupcggcggcggcpcgguguuugcgcggucggugagacccgcgcpugagacgcugg\n", + "gucacuuggcugcucgcgucaggccacaccgguggucupcuguggcgcgcpucpcccgaggcpcggccaggaag\n", + "gcguupacugucacuuggcugcucgcgucaggccacaccgguggucupcuguggcgcgcpucpcccgaggcpcggccaggaag\n", + "guucuupcugcaccccuaugacgacuggupaucauccagucccucaggcuggaugagcagccuggaaaugucag\n", + "acuuggcugcucgcgucaggccacaccgguggucupcuguggcgcgcpucpcccgaggcpcggccaggaag\n", + "acugucacuuggcugcucgcgucaggccacaccgguggucupcuguggcgcgcpucpcccgaggcpcggccaggaagguacggaccacgagcagccggccgcgcccccaagccucg\n", + "paccagacguggagguuagaucuuaaggugaccgugguguuuggaaaugcagaaucuugaccuucaagcuguucag\n", + "gucauggugccgcpccgugcucgcgcaugcgccaccugacccacaggccggucguggagcugcgaccccggcccuag\n", + "gagacacccagcgacgacgagguugucauggugccgcpccgugcucgcgcaugcgccaccugacccacaggccggucguggagcugcgaccccggcccuag\n", + "aguuuugcccugcugagcuggcaggcugguggaugccuggapugcacaugcugccuggcacagaugcaacgupcuggugcgaaugg\n", + "ggccgcpcupccccgccgcagcuccagcuggccggcuugguccugcggucccuucucupaggcccgaccccggccgcgcccagcccccacc\n", + "gaugcucaccccauuuagagaaagaaauccaccuccccaaccccaaucaagaaccugcuauuguauaucaucauagagccagauuaccuag\n", + "gcagaacggcgaguagcggagcpacccgcugugaguguggcggccgcgcupuuccuagcupaaacgugauccaggcgaagcgccccaggaaggauup\n", + "aguguauccagaagcuacugucaggaggacacuguaagagaaccuuggcaccucupcccaaapaaagacaccaguggaaagag\n", + "cgccpaaggcagccggcgccpcaaguugcgagcgcgccccuccgaccaggaaaguuuccccccggccgccggcpauuuggcgcpuccggcagccgccgcuggaag\n", + "aggcgapcagcccgcagaggagacgcgcuucucggcagcaacggcgucuggagccpapcggag\n", + "guuuuugaaaauaaaguuaauucagagaagguaaaacuuucucuucggaauuucccacauaaugauuaugaggauguuuuugaagagccuucagaaag\n", + "gugaacaaaaauuguuugcuggcccccaggauacuaacuagaccuuuggccugacucacaggacacuaaggcuccuuuucugaagaagccuuuuaccagucucauuuapaupaacaac\n", + "gcguggacccaacuggcgaggcugcupuugcagcpacaguupcggccccgcaggcccag\n", + "gcaggupauuggauagcgacgaaggccggcaggcuaggcguggacccaacuggcgaggcugcupuugcagcpacaguupcggccccgcaggcccag\n", + "uggccugacucacaggacacuaaggcuccuuuucugaagaagccuuuuaccagucucauuuapaupaacaacaugucuucaccuapacuuuagagcagagccug\n", + "aggcuaggcguggacccaacuggcgaggcugcupuugcagcpacaguupcggccccgcaggcccag\n", + "gaccuuuggccugacucacaggacacuaaggcuccuuuucugaagaagccuuuuaccagucucauuuapaupaacaac\n", + "uaaacgauuaugapaaaugacucugaagcagaagacuugaauuucapagacuuugccuucaucaagucaggaaaacacaccuagaucaaag\n", + "gaccuuuggccugacucacaggacacuaaggcuccuuuucugaagaagccuuuuaccagucucauuuapaupaacaacaugucuucaccuapacuuuagagcagagccug\n", + "ggcgccccgcggcgcuuuaagagacggccuggcagcccagccccagccgcccagaccggcgagaccagccugcpagcagcccc\n", + "agcpaagaccaucucugcaagugcagcauagccucggccuaggacagcpagugcguggccaaagcugugagcagaggcacaggugguggcagacaguagaggcgcccc\n", + "gugguugagucugaagcgcupaggcggacauuaaagugaagugguugcgguaaccuggccupccugaagugagugagaggcacaugaag\n", + "gcugcgapaaacupaaapccuaauuccccagucuccaccucgaaucaggaaagagaapcpcugcupcaaaagag\n", + "gugaaguguccggacgcacccucaucgacauugguucaggccccaccguguaccagcugcucagugccugcagccacuuugaggacaucacc\n", + "gaaaucgacauuugccucuggcaggaaaaugagcuugucaguuucugccuccauuagacccucaacccaaaggagcaggagauuucgguagcguuuuaacuuuaucucagaaucugaaagcggaag\n", + "ccgccuccuggugaugucacggcgcucgcagccgucgcgcugaagaaaggaugcucgaggaugcuguccaggupcggccgcpcgcgaugcggcacugcag\n", + "gucgcgcugaagaaaggaugcucgaggaugcuguccaggupcggccgcpcgcgaugcggcacugcag\n", + "gccgucgcgcugaagaaaggaugcucgaggaugcuguccaggupcggccgcpcgcgaugcggcacugcag\n", + "gcgucuuguuuguggcaagauucugapaaguguagcucccagguugguuccaagucuucuuccaauuag\n", + "gaucuuauccaggacgcuucauugcauuuggucuucauuucuccuuagucuccuccaggcugacauuuccucaaucuuuauuggucuuccacagcccugacacuuuuggagauaccagucag\n", + "gcgcagauapuagccuggaggccugcaguccgcgcggccgcpapacgagapccugacguacag\n", + "acuauaaacucuacaagaauaggaaucuucguauuuuuuuccucugcugaauuccuagugcccagauuagugcuuggcac\n", + "acacacccugacccgcaucgcccupucucucgagccugcugccugcucccccgccccaccagcc\n", + "accucugacucugcgcugccacccggcagugcgaggaccacauacugaccagguguggagccgaugcccagacccgugauggcag\n", + "guccugcguguuccgaaguucapcccccugaucccgcugagcccccuccaggagcgaaapuuaaga\n", + "ggcugaggcgcgucgcccugagcgagcpccupcggccggcagucuucucgcuccgcacccccgcggccgcgcucag\n", + "aaapcacuucuguuuguggaguaaagccugccacauugucaaaauauguaacuggaggauuacaguaugcuuaccucugauuuuauuucuacagugcugcuauaaguaaca\n", + "aagcauuugugugcauaguggcuccaaagaggugugugaggugugcgaggapaagagcacacacuugguaaugaaggccugagagcugcapcuggaagagaacacucgu\n", + "acguuccauccucagagcagccugaacuguuccuaaagaaacuucagcagugcugugucauuuuugacuuc\n", + "gcuggcugcguaugcgucacpcgucaugaccucgcuguggccccggcagcggcugcpaaagucgcgaggugcauccgcuucggcugca\n", + "gcuauuuacugaggacccacuggaugucaagcauugugcauaguuuucuucgauuguugcaacaucccuugcgag\n", + "aguuucacuccuguugcccaggcuggagugcaauggcaugaucucagcucaccgcaaccuccgccuccugaguucaagcaguucuccugccucagccuccugaauagcucggauuacag\n", + "gcpagcacaccccugcgaagugccpcacccuuupcggcucccgccggcgagcuggacagcggcgcgcgccaggcguggcuuucucggccggupcuaggauuggacgcaguag\n", + "ugcggccuuugaacaaguaagugagccacccucggagacccccgcgcupacpaggccggcgagccucpaccucugaaagccuugaggaggcgcp\n", + "ucagaapcucugagaacacgcaccpagugccuggapuuuccugcaaaguaggagcaggcaccuggccaggcuuggaagaaaaagacuguagauccaaaaugauacg\n", + "ggcuggcuggauuuggaggacugugauaacuccuacagcuuuuugacupcuuuugcuucauuuguucaggagucuuugugccauguugcuucacucgua\n", + "gccaguacucagaagucagaguugagagacagaggcaccccggacagagacgugaagcacugaau\n", + "aacugccaguacucagaagucagaguugagagacagaggcaccccggacagagacgugaagcacugaau\n", + "gcugcucaaguuggcugaucaagagauaggcagugcaaaggaacaggauuugagacagcccapuuuccucuucaa\n", + "cguccagcugcuccggaccgagcucpuguaupccguaggaaccggcuccpccccgauaacpccgcccccacagcaccccpcuggcgugag\n", + "ucuauggucpcccucugcguccagcugcuccggaccgagcucpuguaupccguaggaaccggcuccpccccgauaacpccgcccccacagcaccccpcuggcgugag\n", + "accccauucccacuccguguccupcccgcccagccuccuuaggcgccgcgccugcucgcggucuccgcugacaccccag\n", + "ccugauupcugccuccagaggaugacuggccucgagauguaucccugccccguggagccuuuccccccagapccccgcccagugcagucggugguaccugag\n", + "aaaagaggaggcgagaggcuaucacugcagcgaccugccugacagaagcuuugguggaucaccucaaugup\n", + "agaaggauccugagccucgcacucugccgcccgcaccaccuuccgcugccucucagacucugcucagccucacacg\n", + "auccucagaauggcccuuggugcugcaggcgcggupcuccpcccaggcaccgapcacuggaugacucuccaggugcaggacccugccaucu\n", + "gauccucagaauggcccuuggugcugcaggcgcggupcuccpcccaggcaccgapcacugg\n", + "aaaugcuuggcaggcucccugcccgcuggcugcuuapaggugcucccacuucccccgccguugccugagcucucuapcuccuucacucugcag\n", + "cuggccuccgccgcgcgcuccuccucgucccagcgcuagcpcacgcgguuccuuuuugcgagcuuuccgagugccaggcgccggccggcugcgaagacgcggupccgccccuccg\n", + "gucccagcgcuagcpcacgcgguuccuuuuugcgagcuuuccgagugccaggcgccggccggcugcgaagacgcggupccgccccuccg\n", + "cacaauaaggcuuucaaaagccaaagaauaacaagaaauaagcaccauuuuagaagccuuuccacu\n", + "acucuagagcauuaaaagugucuucaacauggcagcugaggugcuuucuuugcupaaaagcugcaaagagacuggcagaauggcgacuucaggaguuaauaccucuccag\n", + "agcpcacgcgguuccuuuuugcgagcuuuccgagugccaggcgccggccggcugcgaagacgcggupccgccccuccg\n", + "uggaaucaacuaugaaauuauaaucauagaugauggaagcccagauggaacaapauguugcugaacaguuggagaagaucuaupucagacagaauu\n", + "agccguugcucggccgguuuugguaggcccpccgccgccaggccuccgccugagcccgcacccgcc\n", + "gacgcgagcgcggccgcucccgaugcgcucgugccgcccccgccgugcuccucggcagccguugcucggccgguuuugguaggcccpccgccgccaggccuccgccugagcccgcacccgcc\n", + "ggaaucucuuaguuauaacauuuguuagcuacuuuggagccaaacuucacaggccaaaaauaauuggagcapuguguaauc\n", + "ucuguggugugugguccauccucuugcugagcacauugaaaggaacuggcuaucuuugaucucuuccuccag\n", + "ggucuauugacauucapacguggccauagaauucucucaggaggaguggaaaugccuggacccugcucagaggacucuuuacapaugug\n", + "gauugacuucuaaagaaucuugguacgugaggaagaaacccagaagaggaagaggaaagcaaaggagucap\n", + "aggccugguuucuguccugcgcgcgcagauucgcgcagaccaggaagcggaucccguggaaugacggugacgccgcggcpcg\n", + "gauugacuucuaaagaaucuugguacgugaggaagaaacccagaagaggaagaggaaagcaaaggagucapauggcucuuccucag\n", + "gucacgugcgguucauugacuaugaauaugcuggcuacaacuaccaagcuuuugacauuggcaaccauuucaaugaguuugcag\n", + "gcgugaaugagguggauuacugccuguacccggcgcpagacccagcugcaguggcugcacuacuaccugcaggcacaaaap\n", + "cccagcuacugccaagcuguggccaggaagguggagcucugagucagaguauaaguuccugaucuugccacccagcuggagagcugccgug\n", + "aaggcaagagaucuaggacuucuagccccugaacuuucagccgaauacaucuuuuccaaaggagugaauucaggcccuuguaucacuggca\n", + "aaggcaagagaucuaggacuucuagccccugaacuuucagccgaauacaucuuuuccaaaggagugaauucaggcccuuguaucacuggcagcaggacgugacc\n", + "ucuccgccgcagucucagcugcagcugcaggacugagccgugcacccggaggagacccccggaggaggcgacaaacuucgcagugccgcgacccaaccccagcccupuag\n", + "aguucccpagaagaggcuggagaaggapcaggcggccccucgacgaggacaccgcupagcugccggaacpccccpcucugcccccgccccggcgcuggcucgaaggcgcccgcucg\n", + "gucgcagccapcggcpcgcgcccagccccggccccuggagcgcccgccgcgguccccaccucc\n", + "cupacuucgaggcggccgagacpaguugauucuaggcgaaacaagucauuugaggccugag\n", + "caagagguggaaacauacagaagaagcaaggaaauuacaguuagaggucacaacugcccgaagccaguucuaaauuuuuaugaagccaauuucccug\n", + "cagacgugapcucuuuggagacguaaacaucuccgaguggcgapupcpcupcuupaaapcpuggcuugcuugagguguggaaagaccagaagaag\n", + "gucgcgagagcugguugccuuggcucccuguagcuauagcagccgcggcgguuaaguaugcggcgccaggagcu\n", + "gcuaagagaupcucuccuguguugcccaggcuguacucgaacuccuaggcucaaguaauuccuucccaccucagccuccugauuggcupacuacag\n", + "aucacuugccccacagauacccucgugauuagaggucuuuugcuggagguugacugugcugucug\n", + "guuuacggagacucggaacuggauaaapaccaggcuacauupaaagaagupaagaaaupuacagcgacgaggagg\n", + "acauccguguuccuggaucucaggacuucpcuuggacugaauuacacuacggauuuuccugguucuccagcuugaagacagcagauugupacuucuugaccuccauaauugu\n", + "guuaaugaagccaaagaagcacaugaaaggauauuucugaauacaggauucuggccuuaaaauacacu\n", + "gagugcaaucugaagccacuucaaagaaucaccuuguuuucuugcugacauugcagupacgaugagacccaaggacauucagccaagapaaau\n", + "acauccguguuccuggaucucaggacuucpcuuggacugaauuacacuacggauuuuccugguucuccagcuugaagacagcagauugupacuucuugaccuccauaauu\n", + "gugauccaapaggucuuacuucucaauaggagacaagugacuugauuucaacacggaupagaaauupaggugaaauupagaaacauggaaauacug\n", + "paagcaugaacaucuggccuuuucuuuuucuuccuguaaguccauuggagaugcaagauuuuaaggagcaggaggauppaaggacacccucuugcau\n", + "guugcaggugaugagauugaaguuccuaaaguuuaaguaaugaaucaaaggccugagucaagauuuaaauccag\n", + "gaaacaagapcaaggagagagcagagaacacacuuugccuucucuuugguauugaguaauaucaaccaaauugcagacaucucaacacuuuggccaggcagccugcugagcaag\n", + "ggacagaaauguugaaggcaggugccugauccaaaaugcauuuagucaggacugaacacaagcugccuggauaguuccu\n", + "cuccucacggcucuucccggcgcucuccuggcucccuucugccccagcuccgucucggcggcggcgg\n", + "accuccucacggcucuucccggcgcucuccuggcucccuucugccccagcuccgucucggcggcggcgg\n", + "auucauuuggacagaaauguugaaggcaggugccugauccaaaaugcauuuagucaggacugaacacaagcugccuggauaguuccu\n", + "auuuggacagaaauguugaaggcaggugccugauccaaaaugcauuuagucaggacugaacacaagcugccuggauaguuccu\n", + "auaucaucucuucuuuugaucacuguuccugauugugacauugugcaaguguuaaauugugugccuuuuguuccugaagaaagag\n", + "augucuccuacucuuuguguuggauagguccupaucuuugaaaugcuaagauucuuggauaccacaguaucauaaaauuccucuaaaugca\n", + "augaggaaacugagguccagagaaguugaaguuuucccaaggucacacagcagagcuggaacuagagcuugcauuuccugacuuccagauuaguguuauuuuuacuucaaacuauuacuucuug\n", + "gugaguuauugupaaaaauccuguauauugaagaugucucuacacaguaucguuuccuguuuaaauuacagauaacuucaagaguuuucagaaaaaaagaaauupacuuuuuugguuaaauc\n", + "guccupaucuuugaaaugcuaagauucuuggauaccacaguaucauaaaauuccucuaaaugca\n", + "augaaggaacugagacacagagguugagacuugucuaaaguaacaugaccaguaagugcuugaauuaaugcag\n", + "gguuguggauacccccuggcupcuucauggagaaaucuucucugaucaccaaccugaaucccagaguagccuccaucuuaggacagaaugagaggccuucuguaaccagauauaacuggccagc\n", + "uccagcuucagacccacucuuugagauauuggauucugacaaguuuccagagcugagaagacagccagaugucaaggucugaag\n", + "ugaucaccaaccugaaucccagaguagccuccaucuuaggacagaaugagaggccuucuguaaccagauauaacuggccagc\n", + "gccucuggccgcuccagaapcacuugacuguaaggaugaaauccugucucugagcugcacucagugugaagugccaccaccugcaucccccugucucag\n", + "ggccugcugaccucggcugcapagccccccccgcgcccccucgccagccucagcagccagagacccugg\n", + "gccuggcpaccaggaugcugcccugucaccugccccccagccccacacaacgcccccacccacccgaacauccagucugacuggagacagccgg\n", + "cggcccagugcgcaggcgcpaaaguugaacuaauaaaguuuguacgaguucaguggaggagaccgcaaguugaguggaggaggcggcggupccccggaccag\n", + "aguuuguacgaguucaguggaggagaccgcaaguugaguggaggaggcggcggupccccggaccag\n", + "ugagcccggcggagcccugcagaacccggccgaccuccaupcugcppcugcacccggaccccupcgcggcgcgccccuga\n", + "uccugcgccpcupuaccccuccuccpauccgguacacagcgucgcgcgcuccccccapugcc\n", + "aggaagcugcccgagcggcgcucugagcggccugagcccggcggagcccugcagaacccggccgaccuccaupcugcppcugcacccggaccccupcgcggcgcgccccuga\n", + "gaacccggccgaccuccaupcugcppcugcacccggaccccupcgcggcgcgccccuga\n", + "ggupucpacugcgcggccucagcagcugcpagacggaaguggcaagagcgcggccucagapucpcggacgccgccugg\n", + "gagcguggaaugacuaaccuggcaccauucuaapaaagaaagguuuaacgaagucacpauugaaggacccug\n", + "ggugcugcgaggucggcgcgcagcuccgccgcpucgcucpcgcuguccaggcggagccggccccgcccpcugcagcc\n", + "gugacggcggugcugcgaggucggcgcgcagcuccgccgcpucgcucpcgcuguccaggcggagccggccccgcccpcugcagcc\n", + "cggcggugcugcgaggucggcgcgcagcuccgccgcpucgcucpcgcuguccaggcggagccggccccgcccpcugcagcc\n", + "ggaggcpapugacggcggugcugcgaggucggcgcgcagcuccgccgcpucgcucpcgcuguccaggcggagccggccccgcccpcugcagcc\n", + "cgcacucpaggcpapugacggcggugcugcgaggucggcgcgcagcuccgccgcpucgcucpcgcuguccaggcggagccggccccgcccpcugcagcc\n", + "acuugcacuaggaapauupccagguuugcccaaguccacupcaucuuuaguaaauuucucuuuuucuccuccuauuggcacucucugaauuccauuugcugcccccupa\n", + "gacaacaacagcaucaaaacaaggcuguuucugugugugaggaacuuugccupagauaaaauuagaccuagagcuuucugacapagucugaagcgupac\n", + "gaugacaaggaguaugupcuuugcaacccuccccaaccaaguccaccgaaaguccgugaagaaaggcuuugacuuuacccuc\n", + "gaggcpapugacggcggugcugcgaggucggcgcgcagcuccgccgcpucgcucpcgcuguccaggcggagccggccccgcccpcugcagcc\n", + "gacgucacgccgcacgccccagcgapcgugcggaguuuggcugcuccpuuagcaggugagccugcg\n", + "gacgucacgccgcacgccccagcgapcgugcggaguuuggcugcuccpuuagcaggugagccugcgaugcgcpaagacguuccgcuuugaaaugcagcpauuug\n", + "acgccgcacgccccagcgapcgugcggaguuuggcugcuccpuuagcaggugagccugcg\n", + "uuucggaaguuaacuugguauaagaguaugaaaagccucuguugcucuacuucugaggaaaugcucuccuuuuuccuaauaaagcuuuccacagaagacaaacucuguacacaaaaaacaag\n", + "apaagccgcguggugugcgacccupcguugagcuccaggcuuccuggcaaagaggacuguggauuccuggcccugugaccuugg\n", + "acaagcagagcugcugcucccupcugaguuucaucacuaugupaggaccuacggaaacccauguu\n", + "acaagcagagcugcugcucccupcugaguuucaucacuaugupaggaccuacggaaacccauguuguaagguccccacaucccuaccagcuuccacaggccuuggccccccauguggacuuug\n", + "acaagcagagcugcugcucccupcugaguuucaucacuaugupaggaccuacggaaacccauguuguaag\n", + "uagcupccauggagucugaucaaaugauuuuuccuccccaggagagcuaagcccugugucuccaau\n", + "auuaugacuguaccuuuuaacuuuguagcuggaacacaagaaguguuuguuuaaugaaugacguacacauuuaagaucuguuuggacgcggaggauaauccugugaauug\n", + "ccggccggacugagaapagcgcgcugcgcgucgcaggaguaaccuacuuggucuccugcuuucgcgac\n", + "ggacugagaapagcgcgcugcgcgucgcaggaguaaccuacuuggucuccugcuuucgcgac\n", + "gupuuuggaggauuupacaacaucuacaacugcagguucugcauucagcuuuucugccccaacuaacacaggcacuacug\n", + "cagaaaggaggcggaacucggugaucugacuggcgguuucccggccggacugagaapagcgcgcugcgcgucgcaggaguaaccuacuuggucuccugcuuucgcgac\n", + "agaugaagucuugcuauguuacccagacugaugucaaacucccggccucaagcuauucuccugccucagccucccaaaauacupauugcag\n", + "pcggcgagcaauaagaacccgccgcacccgguccucagcgacucuucugaccuccgcgcgacguacccgccgccgccguuggcuggag\n", + "ggcuuuguuuggugguaaaaapuuacuagacaccccucauuccacugccacuggapcgcauuucucagcucuugcucuucaaaccugcugaaaggaauuccuagaucuaaacaccag\n", + "puguuuaaucgucgccaagcpacuuacugcaagcuaucaaaucugaggucuuauuuuguugagucgaaagugaaauuuuccuuuggccaacgugacag\n", + "gacgcagaugcgaaaguggcggccuccpcaccauuucugugcacggaaacagaauccpuuugaag\n", + "aucuucuuugugaagcuuucauucaaugguguaccacaaaagauugaaggucauuucuuuaaaaag\n", + "guuuuauggcaggaauucuuccuauguucaugguggaguagaugcuaguggaaagccccaggaagcuguuuauggccaaaau\n", + "gauauacaccacaaaguauuaucucugaacuucagugaaugucauacuaaaauucgucauguggaugcucaugcaaccuugagugauggaguaguuguccagguc\n", + "gcagaagcgacgcagaugcgaaaguggcggccuccpcaccauuucugugcacggaaacagaauccpuuugaaggcagccgccgcuucgcuuaccca\n", + "gagcccpagccggagguguagcggcagagacauuguucuugccggcucccuacggugccgugugugcgugagagaagaccagucuuuccucuag\n", + "gagcccpagccggagguguagcggcagagacauuguucuugccggcucccuacggugccgugu\n", + "ggcgcgaggcaaucguccggugugugagcccpagccggagguguagcggcagagacauuguucuugccggcucccuacggugccgugugugcgugagagaagaccagucuuuccucuag\n", + "gauaaaaccacuggaauccaggaauguaguagauuuugguccccaaaggaaaaaggcacugugaauagaaggacuu\n", + "agaagaccagucuuuccucuaggugapupaggccgccupaapaggugacccgcgagcgucuugcpcagapcuccgagugcacag\n", + "gacgcagaugcgaaaguggcggccuccpcaccauuucugugcacggaaacagaauccpuuugaaggcagccgccgcuucgcuuaccca\n", + "cccgcggugcucgcacaccugagacucaucucgcuucgaccccgccgccgccgccgcccggcauccugagcacggagacagucuccagcugccguuc\n", + "acucccgagccccgagagcuccgcgcaccupcgccauccgcccuggcuccgcugcacgagcuccacgcccguaccccggcgucacgcucag\n", + "auucccaccuccuccagaagccccgcccacucccgagccccgagagcuccgcgcaccupcgccauccgcccuggcuccgcugcacgagcuccacgcccguaccccggcgucacgcucag\n", + "gcuuugacaccagcaccucucuaugaagaaaagaguguguugugaacgaagucagaauuuccuguguucccuuugccgcuccuggaguucacug\n", + "gugcgugcgacgaccupacgcuggaaacccggagcugcgcgcupcggaaaggacuccuagupcccggcugagaaggcggagguggcgcgcgapcpcucgugccaacgcug\n", + "gaguupacuuuucccagccagacaccucuccggacaccaaugguggaggcaguacuucugauacccag\n", + "gaguuugagagcuacccggagcuccaagacapupuuccagcugcccgcacgccccgaccuuccaucguag\n", + "gaccugugccguggcccgugagaaggaggucupugcggaaacuccaggccaggupuccpaggccggucgcgcccaggaaaugcccuauacgcgcaggccggacc\n", + "ugacpaaapugcgcagccucgaguuugagagcuacccggagcuccaagacapupuuccagcugcccgcacgccccgaccuuccaucguag\n", + "agccccagcgcucuagagcucagcugacpaaapugcgcagccucgaguuugagagcuacccggagcuccaagacapupuuccagcugcccgcacgccccgaccuuccaucguag\n", + "pcgcuuccggcacagcggaacuccpugccgguugagguugcugguggaccugcucugguggucuuggaugaggcccc\n", + "gcuuccggcacagcggaacuccpugccgguugagguugcugguggaccugcucugguggucuuggaugaggcccc\n", + "gcuuccggcacagcggaacuccpugccgguugagguugcugguggaccugcucugguggucuuggaugaggccccaugagcgcggcgccccuggupcuacagcagcagcggcuccgagg\n", + "acagcggaacuccpugccgguugagguugcugguggaccugcucugguggucuuggaugaggcccc\n", + "gcaucuuccggaapapaggagaggagcggcugcucupuggaggcagcagguugcuugagcaagcag\n", + "gcgcuuccggcacagcggaacuccpugccgguugagguugcugguggaccugcucugguggucuuggaugaggcccc\n", + "gaguucucagccugaaguugacuggaacuuucaguuaacaaguauuuaucgaauaccugaucuguaguguuggacuuagaccu\n", + "auaccaggagccccgugaggugcguguggccucagcuugcagaggagugcacuugccagacacuucpcuuugaagagcacagcucaucuaag\n", + "cpcpcggagcpcauggupugucpccgcaggcguagcgcucucgcccuggcc\n", + "agucugagaggcguggagaauuuugcuugugcaagauuauuucagagcaaggucgugcgguguguguagaag\n", + "augaacagacuagccacuuugcauugacuggaaacaauggcauuuacagaaagagucaacagcaguggcaacag\n", + "uuuguacaaugacgacagaaaccugcuucgaauuagagagaaggaaagacgcaaccaggaagcccaccaagagaaagaggcauuuccugaaaagauuccccuuuuuggagagcccuacaag\n", + "ucauuuggagcaagaaagauucagaucuguaaggcgcccucaagaucaaaaaguuauuaacagugcupag\n", + "ugcugcuuuugacacaaaaacpuuacguguggcagugaagaagcucuccagaccauuucaguccaucauucaugcgaaaagaaccuacagagaacugcgguuacuuaaacau\n", + "guuugcuggcucuuggaaccgcgaccacuggagccuuagcpcgcagcagcuggaacpaguacugcgacgcagcccggagucggccuuguapcgaag\n", + "gagcugaacaagacaaucupaggugcccgagcguuaccagaaccugucuccagupcucuggcgccuauggcucugugug\n", + "cuuucuguguuccuggcccgcggccgucpugugagcugcgccgaccgcucugapuucguggcccaccgcuccuucgcggucccugccgccaccguccacgcucagcguuguagagaag\n", + "guuagcuuuauacgucuacgaauauuuacugcacguaggagcacagaaaucugcacagaccuucuuaucggag\n", + "uguauuuupaccuuuacugugcagcuccugaaaggagagacacuugugaacauucaagugaagcaaaagccuuucaugauuau\n", + "cuuuuacucuggaaagaacaugacagacauccucugcccuucagccugugccccagaaugagagacccaupacagacucaagcuguacccugaagcagagcugcccaguugacugcagaccu\n", + "acucugcaguugauccagcagcaggaggcagcuguacccaucacuguccucagaguacuuuuaagaacaaggaggucucugcccacggcagcccaagcag\n", + "pugccgcccaccucugcuccgacagccucccggagucccagcagcaagacggcaaccacgcacccaacuucuccagccacggcucaugccgccgucgccagcggcgccgac\n", + "acuggccapcccucauccaggagccaggaaacaucuacuaccacgagucgcguugcccagcgugugucagccuccuuauccaaacggcaaggcagccuccccpaugu\n", + "caacugccacuccaaggagaacagaaaugguuccguuauuaguggcugcugupaccacgacagucugup\n", + "gaucgcuucagguuccaaaaguacaacauguuuacagucgucguagcaucagauuaaguuggcagccugagucucucu\n", + "agugcpcpcgcgccuaggcugccgcccagcgcccucgccgcggccaugcccpcccuagagcgccugccgcagcuugcgccccgcagccccgcagccccgcgcccgccgccgccucuuca\n", + "gguggugauuccacugaagcaacugccaaaccaaagagaaguuuuuaugcugccapauuuguacaaguaccgacaccaguaccca\n", + "cagaacuucaaagauauccgauaucaaaaugacuugagcaaucuucguuuuuauaagaauaaaauuccauucaagccagaug\n", + "guguuuacauugaagaaguucuaaguaaauggaaaggagauuaugaaaaacuggagcacaaccacacuuacauucaaug\n", + "gcuuuucccccugagagaacaaggcuugaacuucuaugccaaagaacuaacuacauaugaaauugag\n", + "papaaggaggcaapcuccgcggcgcugucgccgccgcugccgcucacucucpaagag\n", + "aaggcaccuuccucugucagaauggccaccaugguaccauccguguuguggcccapccugcuggacucugcuggucugcugucugcugaccccag\n", + "ucagaauggccaccaugguaccauccguguuguggcccapccugcuggacucugcuggucugcugucugcugaccccag\n", + "cucaggaaggcaccuuccucugucagaauggccaccaugguaccauccguguuguggcccapccugcuggacucugcuggucugcugucugcugaccccag\n", + "cucugucagaauggccaccaugguaccauccguguuguggcccapccugcuggacucugcuggucugcugucugcugaccccag\n", + "gaucaccugucccuuucacuugcuaacuccuacuuagccuucaguuucpcugcaaugguccccgcuuccaggaagccuucccugacucaccuccuccu\n", + "accuggaguuucuucagacuccagauuucccugucaaccacgaggaguccagagaggaaacgcggagcggagacaacaguaccugacgccucuuucagcccpaucgccccagcap\n", + "cuuuucacauugcuuugcagucccpcguccccaguucucuugcuguccuccgcuccacucugcagucccggupcgaagg\n", + "agaaucuucuuccuucaucacaggaucaacacauuucaucupcuucuuaaaucuaaaucuuuaaa\n", + "uucuuucuccaaccucagcuuuucuuagugccuaaagugucugcacauggaaauccagagguagacagagagaaacugaguuccggaca\n", + "gacucgucaaaaaucugcauaauggaaaauugcaapuuuuuccugaucuacuuugaaaugcaauuccgcuuaaag\n", + "cuuuucuuagugccuaaagugucugcacauggaaauccagagguagacagagagaaacugaguuccggaca\n", + "ggcgcacgcuuggcgacgucgaagguccguccgcaguuaaggaagcuuuugcagccggacaggucgcgaagcacac\n", + "gcccgcguuucuaaacuuugucuggauaaggcgcacgcuuggcgacgucgaagguccguccgcaguuaaggaagcuuuugcagccggacaggucgcgaagcacac\n", + "agaugccucauucccaccugugaugcucagagagaaaccaugagcccugaaaaacaccauauuguuuugug\n", + "acggaaacagaaauugcuuugcggcccgcacggaaauugcuuuccuucggcuuccguucuugguccaugugagagaagcuggcugcugaa\n", + "augaagacacagaagcauagagaggauaaguaaucacuagcaaguggaagaaccpauucagauccagaacaggcugacuccagagucacuggcugucauguaguuuccucaacuacugccucag\n", + "cggcugcggcggcggagcuccuccgagguccpucaccagucucugcucuucccagccucuccggcgcgcuccaapcuucccgucpacc\n", + "agcaguagcaccagcggcugcggcggcggagcuccuccgagguccpucaccagucucugcucuucccagccucuccggcgcgcuccaapcuucccgucpacc\n", + "cucggcucggagaggcccuucggccugapagccucgccgcccguccccggcacacgcgcagccccggccucucggccucugccggagaaacag\n", + "apagaggcagagaggcaggcagccugcupcucuuccugcuguugaaaacuuacccggcccuuacagaggaaaucuuccuccucucuucugcccugaauguuuucccaaac\n", + "agagcapagaggcagagaggcaggcagccugcupcucuuccugcuguugaaaacuuacccggcccuuacagaggaaaucuuccuccucucuucugcccugaauguuuucccaaac\n", + "ugguggagccacaguguuaaagaacagagaagugauccuuaaucauuuagaauuuugccuccaccauccaccagaaa\n", + "cccgugcagccugccaggacucuuccagacacpauuugucggugaacaacgcagagcugaugcagacau\n", + "aauauauacagcccugcucupacacaccuccauuggauuuaaaagacaguccucgucagcacugacuuucagcu\n", + "cacagcagucaccgugaugaaagcucccuucugcucucpuccugccguggaggaacaaggccag\n", + "cgcggccgcpcugcaupcagcgcccgcgccccgccgcugagccgucgcggagccgcgcagcccucggagcacg\n", + "aauauauacagcccugcucupacacaccuccauuggauuuaaaagacaguccucgucagcacugacuuucagcuauggaaucg\n", + "gcggccgcpcugcaupcagcgcccgcgccccgccgcugagccgucgcggagccgcgcagcccucggagcacg\n", + "gauaaagauaaaguuucucuaaccaagaccccaaaacuggagcguggcgauggcpaaggaggugapagcgagccagcaagcggaagcugcccuucaccgcpcgcca\n", + "cggccgcpcugcaupcagcgcccgcgccccgccgcugagccgucgcggagccgcgcagcccucggagcacg\n", + "agaccccagagcacaacuugaapaaaagguacggcaggaaccguccaaugcguuaccugcaaagacagcggccggcuuugguguaggcuuguguguagc\n", + "uauacagcccugcucupacacaccuccauuggauuuaaaagacaguccucgucagcacugacuuucagcuauggaaucg\n", + "ucugcgcaagcgcgaccgaccgagcagcuccgaggaguccgcccggaaacaaacauuccccapca\n", + "gcucugcgcaagcgcgaccgaccgagcagcuccgaggaguccgcccggaaacaaacauuccccapca\n", + "ggccgcucccaagcccagagcugcucugcgcaagcgcgaccgaccgagcagcuccgaggaguccgcccggaaacaaacauuccccapca\n", + "aggagcagugacaucacaggaaaaaccaccaaccaaggccaaggagaccagagcccagcaccucacccagaggaccccagucagaggccccaucucagacccgaggcuagc\n", + "gucaucccuccucgcuggugaauggaggcaguggucacaacucuccccagagaagguggugugaggccaucacggaag\n", + "ucuccagaucaagauguugcagaggcuccgcguucuugugagaguauguuccgagcucucugaccugucaccaupaucacucuuuugaagagacuuccuggaggacacugaugac\n", + "aucaagauguugcagaggcuccgcguucuugugagaguauguuccgagcucucugaccugucaccaupaucacucuuuugaagagacuuccuggaggacacugaugac\n", + "cagcucupapaacpagauguugcaggcgccgagapcpccapccgcacuccggagacucgcgguugcuacgcgcacc\n", + "gaacpagauguugcaggcgccgagapcpccapccgcacuccggagacucgcgguugcuacgcgcacc\n", + "agugguggcguccgaggccggccgaacucccgcgcucucccgccgccucgccucgccuggugucucucccgacc\n", + "gcgcagugguggcguccgaggccggccgaacucccgcgcucucccgccgccucgccucgccuggugucucucccgacc\n", + "agaaccuggugccugccucagcccuagcucupaaaugaaagccaggcupuucaaaugapcaguuucccuuccugupcugcug\n", + "agcugcgagcgagcacccaggccccgccgccgccgccgccaccgcugcccgccugccgccgcccgccuccgccugccuucugccgccggccggcgcgucguccccacag\n", + "gcuaaccgapagagcugcgagcgagcacccaggccccgccgccgccgccgccaccgcugcccgccugccgccgcccgccuccgccugccuucugccgccggccggcgcgucguccccacag\n", + "gagccpccpccugugcgcgcggapacpupcgcgccguccccuucccccaccgagaauaacgugacccacuucugccugccauucccucggcaaaaugucuccuuuuug\n", + "cgccuuguagacguguucgcuuugcguuugccuucugcgugauuguaaguuucccgaggcuuccccagcc\n", + "gcaguggcuggagcccupcgcugcaaagcgugucccgccpuccccgagcgucccgcgcccucgccccgcc\n", + "gaccgcpupcggccccgagagcgucccgcaguggcuggagcccupcgcugcaaagcgugucccgccpuccccgagcgucccgcgcccucgccccgcc\n", + "guggcagccaagagccuccuggcacagcggcaccaggcaggugacgccuauuggaccccagaggucaucccagcuccagacguggacacauuuucuuccaaug\n", + "augucuacggaugaggaaacugaggccuggagagguuaaagagacccguucagaguccuacaguggcag\n", + "cagguggcagccaagagccuccuggcacagcggcaccaggcaggugacgccuauuggaccccagaggucaucccagcuccagacguggacacauuuucuuccaaug\n", + "gaggagaggcuccagacccgcacgccgcgcgcacagagcucucagcgccgcucccagccacagccucccgcgccucgcucagcuccaac\n", + "acauccagagcuggccgacpugcgcpcpcggcggcaccaugcapaagcugccapccgupcagcgccgcuuucugccgcccaccuggcgcugugagacuggcgcugccacc\n", + "cugaccaggccccauacuccagucuccccagagaccccaagcugaagauucugupucugccccauugcupcacagcagagccugg\n", + "agacccuccugaccccugaccucugcccccaguggcccuggccccupcagcccuuccuggccgccauguguacccagagccupacuggcupcupcagugacccag\n", + "ccacauggaagcuggaggagcaacpagcgcupcgupugcaaauugcccggugccuucuguuucccaggcagcucuguggcc\n", + "gcuggugaupcaagccpuguaccaaguccaugaugcacaugaggagcauuuguagccaucacugaaucaccucaugacuagcpacaagccucaaauucaccgcaggauuuccg\n", + "aucucacucuguugcccaggcuggagugcaguggcacaaucacagcugaccgcaaccuugaccucccaaggcucaggugauccuccugccucagcccccagguagcupaccuacag\n", + "gauaguaggagaaggagaagcccacagaggaggcaggagaagaaccaggaaguagcguguccuugag\n", + "ggaaagcuaacagccapagaggaucagucucuugcuggacccuggcagcuuuguugagagcgac\n", + "uaguuaaauauaggaggagaaagaauacaucgguuguuaaagcaggagaggaagagagaccugcccuguagcgugacuccucuagaaaaaaaaaaaaaaagccggaguauuuuacuaagccccuaaa\n", + "gcuauucugcuguupucaccuucugccuacuugugacauuccuucugcucuuccuugcuccapauuguuccapcccccaguuauucuaaauggau\n", + "auuucucgaguuugauccugugucupauuuuuucaagucugccucugaaacuuagaccuguguugacagagagcacaugcaauauuaaau\n", + "gaucugccucugucacccaggcuggagugcgguggcgcgaucucgccucacugcagccucugccuccucggcucaag\n", + "gaggaagagagaccugcccuguagcgugacuccucuagaaaaaaaaaaaaaaagccggaguauuuuacuaagccccuaaa\n", + "agagagagaapcgccucagaggugacuuucagccugcgagccuucuucccpcgccauaaacgcccccaauuucccagcugcuaaaggaagaggaag\n", + "aggagaggaagagagaccugcccuguagcgugacuccucuagaaaaaaaaaaaaaaagccggaguauuuuacuaagccccuaaaaugucgagauuuguacaag\n", + "gacuuucagccugcgagccuucuucccpcgccauaaacgcccccaauuucccagcugcuaaaggaagaggaag\n", + "cuuuucguugaauugucaucugagcugccuugagcugcupuugacguuccagacgcguauaauuu\n", + "agcagcuggcgcaaguagccuagcuggagaggcucaccccaggaaggapaggccaccgaccuacupccgacggacucccacacag\n", + "gguggcgguggapaapccpcggccggcgccgccgupagguccgcugccccuuugucccuacpccuccuccaagccpagagugucagcgcucgagagaaa\n", + "puuuaucaaguccucggcgagcugcccaacpcagcagcuggcgcaaguagccuagcuggagaggcucaccccaggaaggapaggccaccgaccuacupccgacggacucccacacag\n", + "gagcuguucccugcuuuacccaaaugcugucguuucucuggaucaapuucuucacgguguacagg\n", + "pcagcagcuggcgcaaguagccuagcuggagaggcucaccccaggaaggapaggccaccgaccuacupccgacggacucccacacag\n", + "ggcccggccccgccccgcccgccggccgcggcaaagccgcauccucccggagcagaaccgcuccccgccggcuguccgcaaccuccgccagcgucggucccupcaggugugg\n", + "ugcagcuggaaaaagaaaggcugcugcucggcgcccucgcugcgcccgccugccpucggacgucggcgaugcuguggcuccag\n", + "guggaaugcauccuupacaucuuugcauagccccaucuaggaagaaguucugugaugugugaacugugaguuuacucaaacaaguccaacucuuuauaagacauagguagacgucaggucugga\n", + "ggcccggccccgccccgcccgccggccgcggcaaagccgcauccucccggagcagaaccgcuccccgccggcuguccgcaaccuccgccagcgucggucccupcag\n", + "ggcaaagccgcauccucccggagcagaaccgcuccccgccggcuguccgcaaccuccgccagcgucggucccupcaggu\n", + "gucccuucccupcaccaagagaupcuccccuugccuggcagagaaacagcuggaaacuggcucccugagacaagaag\n", + "cucgcgagaguuagcggccuccggugupauggccgcggagccpcggagcuggcuugcggcucccpccggcucuccggccggagac\n", + "cpacggugcguagcgcuggaaguccggccuuccgagagcuagcuguccgccgcggcccccgcacgccpcagccgucccucgccgccucpcgcgccacc\n", + "pagccapcugcagccucaucuguuugcggaucagaacccgagcugugcuuguggcugcggcugcuaacuggcugcgcacag\n", + "uuuaccagapagccapcugcagccucaucuguuugcggaucagaacccgagcugugcuuguggcugcggcugcuaacuggcugcgcacag\n", + "aagaaggaguugucugacauugcccugcggauuguagccccpcaaaggcauucuggcugcggaugagucuguag\n", + "auuuaccagapagccapcugcagccucaucuguuugcggaucagaacccgagcugugcuuguggcugcggcugcuaacuggcugcgcacag\n", + "agucucaucucucucucaggcucucuacuccuuucagccuugguccucugcccucccgucupugucugaguugupaauugaagugcuuccuauugcuauccuccugccaaacag\n", + "agacaaggucauacucugucaccuaggcuggauugcaauggcaugaucauagcauacugcagccucgaacuccupcucaagcgauccuccuacuucaaccucccaa\n", + "aaaauaauucuuccpccpugcgguggcucauggcuguauucccagcacuuupaggccaaggcpuggaucaugaggucaggaguucaagaccagccuggccaacaug\n", + "gcugcuuuguuccccaaccauaacauccaaguccagugucauuuuucugcucacaaguuuaaagucagcacuuaaaagaacagcaacagaugauugagaaagaaauguaaagaagguucucuuugu\n", + "agagguccaggcucuguggcccugugacccgcagguauupagaucuacagcuaagacgccaggaaccccuggaagccuagaa\n", + "cuguucuccgcugaggaggagcpcagaggapaggcagcpugagaguucagaguucagcagcagcagcccgagccc\n", + "augcguugcccgcapagagaaggaaaagaaggaacugagugaaagucccuccugcuuuccgccpccagcuggacccgucggaccugau\n", + "aagagucuuaaagacaggucuccguauuagaccuuguaauacgcuuaccuagaucugagaaggacuuucaggauagaac\n", + "aguaguugauggcpuagugcuagguacugcagugcuguacuccuggugacucagugguggccagcaggcugagauccuccpcugugcacaucuguggag\n", + "gguucagcggauuccuacacaagcaggccgucugacuccgaugucucuuuggaagaggaccpaagcaauucgacaggagagagaacagcaagcagcuauccagcuugagagagcaaag\n", + "uccaaaccuguagcauuugccgugaagacaaaugugagcuacugcggcgcccuggacgaggaugugccuguuccaagcacagcuaucuccuuugaugcuaaagacuuucuacauauuaaagag\n", + "gccuuuucucuuuaagcuguagcugugguuucugcagcaauuuuguuuuugccuugaaagaggugcucuggauuaucacaccucc\n", + "guagcugugguuucugcagcaauuuuguuuuugccuugaaagaggugcucuggauuaucacaccuccauguaugacaauuuguaccugcauggaauugaagacucggaggcu\n", + "ccugagcaucauauaggaaaaagauucugaccuucuacguuauuacucuauuggcagcuuuguugaaaaguuug\n", + "gcccgcagccucccccagcggaugccpacucggaccccgcacccugagagucuuuguuaauggaugug\n", + "guggcccgaggcaccacaacccggaggagcagguugaaaagauccgauggcagcaccacuucgaccagcuucauccucagacag\n", + "ggagcccgcagccucccccagcggaugccpacucggaccccgcacccugagagucuuuguua\n", + "cacgucugaggcauugguuuuucauccuuccaaacuuuuggucuacagagacuauuagaagauuaag\n", + "caaauaaaaagaaagagaaagagcggccagagauuucucucccuucagauuuugaacacacaauucaugucgguuuugaugcugucacapaguuuacg\n", + "guugguggcgauacaaaaauugaaacuggccucaguuguugcucucaaaugcagaucaaggaauguggacgcucaugug\n", + "ccaccgucugcugccuacauccgcccgcccggcguccgaccccuucagcggcgacpcggagcuggagccccpccupcgccaggupcuccupapug\n", + "gcuccuuccucaccpcugacuagccucuccuuucccugucccccuccaucgcugcucugcaggaagccagcccccapccagucccggapcugauccgcaucuacagc\n", + "cuccuugcugcugcugccgccgccaauccugguccgguugcccgaguucccggaggucucucgcpaccucucucaccgccaccg\n", + "ugguguggcugcuuggugcagcccacaccuggucagcucccaccuguggagaaacuccaaacuagagccuccuacupaugaagcagaagcagaugccuggagucccag\n", + "agacucgcucugucgccapuggaguccaguggcgccaucucggcuuacugcaaccuccgccucccagguucaagagauucuccugucucugccucccgaagagcupacuacag\n", + "ggcaaauccagguaupaaggcugagaacuuuucuucaugcaguaacugacaucucccugucacaucucaccccaggcacagccucc\n", + "agauuguucuugaugaacugaaugcagcuaauacauuuucagugccguugaugccucuaugacuccguaaaauaaucg\n", + "aaaagucaaggcapuucgcuagaaggaagcaggcaggcpagacagugaggaaagaggaggcgcccggugcgcagaggappcgucgcggucgcgg\n", + "gagaugcucuggcccucugcagccugcguccugcuccauccagaggacaucguuagcaauggccuucugcucgacggugacucaucuuapugaaaacccggccug\n", + "uugcaggaaccuucccucuacaccaucaaggcuguuuucauccuagauaaugacpcgccggcugcuggccaag\n", + "ggagcgcapcgcapcuggacccggcgcggagcuggcugagucggagcgcagcguccuuugugcccggcggccgccccpaugcguccgagcuaggagccag\n", + "cggcggcggcggccgagaagaggcupcucgcggcgcggcugcagccguccugugcgcgcggcgcgcggcuccggagaggcgcccgcaguccapcggcgcgcaccgccucgcuggcgcucagag\n", + "aupcapcggagcgagcgcugcggcuaaagcgaaggcpacccuacccaucccuaguccugucggcuccucccaccccgg\n", + "gcggccgagaagaggcupcucgcggcgcggcugcagccguccugugcgcgcggcgcgcggcuccggagaggcgcccgcaguccapcggcgcgcaccgccucgcuggcgcucagag\n", + "agaaguccaggaupaagagagaucugcagacucccapaaccuacagcuuucuccuucacagcauugcaggag\n", + "ccaggcuggagugcaguggugcgaucucggcucucugcaaccuccgccucccagguucaagugauucuccugccucggccuccugaguagcupauuucag\n", + "gccaugaaagaucacuguuuuagucugcguggugcaguggaacagauagaccucgguuugaaucucagcucuacuguuuacuagacaugaaaupaaaucuaaaauga\n", + "ggaggcaaaaaaauuugugagugaaaaugaapcucuupaaaggaaaaggaaaacggugguuugcauuuaag\n", + "aupaucuuacucuguugcccaggcuggagugcaguggugcgaucucggcucucugcaaccuccgccucccagguucaagugauucuccugccucggccuccugaguagcupauuucag\n", + "gacpuggagcaaaggaacaagaagccaaaaacucucapcacuuacuaugauuguguaaaagagagacucaucaauuaacacag\n", + "ggugcgaucucggcucucugcaaccuccgccucccagguucaagugauucuccugccucggccuccugaguagcupauuucag\n", + "ggccgcguagcgccgcpuuugaugaacgcgguucccpagacugguacgguugcugugugcu\n", + "gaugcaggcupuguggapugcgaguaggcuggaguacaccapaguucccagcaggccacuaggagccacccagg\n", + "agauacugauacuuucuuuccaaacagcauaagaagugauugagccacaaguauacugaaggaapcucccucgaguucuggugugaagagauaaaucaccag\n", + "agagcugagauccuacaggaguccapcuggagagaaaaccucugcgaggaaapaaggagcaagccgug\n", + "aaaaaaaaaaaaggacaugcuacagcauggaugcaccuugaagacauuugcaaagugaaacaaaccagucgcaaaagaagaaacacugucucauuccacuucuaggau\n", + "auagccccpuuuggccgccccagccccgccuuccccgccccpagcccgcccccugccccgcgucccugccgacag\n", + "gaaacaggugagcagauugccaucaagcagugccggcaggagcucagcccccggaaccgagagcgguggugccuggagauccagauc\n", + "aauguuuucappugucauagccccpuuuggccgccccagccccgccuuccccgccccpagcccgcccccugccccgcgucccugccgacag\n", + "gagcaggaaguggcugcggcgcggccuccucgcggugcaacapcpaggcggccgcagcccgagccggagcccgagcgccpagcgagaccuc\n", + "gcggcauacucagcggcagagacggaagaacagcgcucccgaggccgcpagccugcagagaggacagccggccugcgccpac\n", + "gcaguggcuucgucccgcggugacggcggcggcggcggcgguagcagcggcggcggcggcpacuggcaucpccccgagccgagcggagccggaccccpcgagcgc\n", + "gucugcagccaccccagcucauaccucucugccuccccgcucucaaggapucugccgcaugug\n", + "gugauucacagacagacuucauacuuugcagcucucuagcucugcuuugaguagacaccuccagcpccguccuacccaapcacugupacu\n", + "cgccagagccgucggacaggucccagcgcpuagcagcccagcucuaucccugcgcccggcuggccgcacccagcagccccaaggcpuupcppcc\n", + "acagagugcuccacugaccugcagccuccagapaguuccaacaucucaagcugagagucacucuggcccacugaauuccaugauuccuguuucucuuggucag\n", + "gugguccccgaagaaggaaacapccaaagguggacccagaaugcagcguggaggacucaaaacucagccugguuuuagacaaggaugaaguggccccgcagucugccauccac\n", + "agucgcuccuaacgcucccuggcccggccpccgcgcaguuapcaucugaggcpagaagcggcpagacgccggcugccagc\n", + "ggcgaacggcugcggcgcuuugugcuccagucgcuccuaacgcucccuggcccggccpccgcgcaguuapcaucugaggcpagaagcggcpagacgccggcugccagc\n", + "uuggcuacucacuuuccaucggaagauauucucuugguaacagcuucuccuguuauuaaagcaguuacaaauuucaagcag\n", + "gucggauuaucugguaaggcaccggaagugaccgccucgcggcugcuuccucuccuggaguccagagucccguugcuccgccgcgauauucaguaaaccacupaguccggcagc\n", + "ggcugcuuccucuccuggaguccagagucccguugcuccgccgcgauauucaguaaaccacupaguccggcagc\n", + "accgccucgcggcugcuuccucuccuggaguccagagucccguugcuccgccgcgauauucaguaaaccacupaguccggcagc\n", + "gapuaaauauuccaguggauacaagcuuggacucuuuucuugaagcuuucuuucuaucagaagcauuugcugauauugcugacauugaaacauuaaaag\n", + "aguggauacaagcuuggacucuuuucuugaagcuuucuuucuaucagaagcauuugcugauauugcugacauugaaacauuaaaag\n", + "aagcuuggacucuuuucuugaagcuuucuuucuaucagaagcauuugcugauauugcugacauugaaacauuaaaag\n", + "aagaggupcugguggaggcpucgagauggcggcgccuuugaggauucagagcgacupcgcaagcccucag\n", + "gupcugguggaggcpucgagauggcggcgccuuugaggauucagagcgacupcgcaagcccucag\n", + "ggaaaccaucuuuguauggcagccugacuugucaaggaauuggccuagauggcaucccagagguuacagcuucagaaggauuuacugugaaugaaauaaacaag\n", + "aaaagcauucauauuucauguccaaaggaaaaugcaucuucuaaguuuuuggcaccauauacuacuuuuuccagaauucauacaaagagu\n", + "auaacaugccuggacauuuccagcagaggaggucuuggugugucuucuaguacugacpaccaugaaaaucuggcaggcuucca\n", + "paapcggaagaggupcugguggaggcpucgagauggcggcgccuuugaggauucagagcgacupcgcaagcccucag\n", + "acacugacuaaagauauuggaagagugaagaucagagaauuuuaagucugaaauuuggcaucacugcccugaacaauauaaccuuaguuggcauaaacuacucauacag\n", + "acaaaggcauuauccaucacaauaaguaacuuuuugucuuuauuucaaccggacaaucgugauuagaaaag\n", + "cguuugugucuaaacggaggcucggccacaacgccacuggauuggugguapcpcpccacagucuccagccugaagcggaaguggaggaaag\n", + "acauucacuacuuucacugccuaagaauccuggaccuucucaaaggcacagaggccuccacgaagaauauuuuuggccgauacucuucacagcgg\n", + "aauguagguguucucuuupacgucucaccgacucucuuccuuccccuucccugcccuaaucgcccaacacguugcaggugcucaaccaugucuauuagagaaacuga\n", + "aacgccacuggauuggugguapcpcpccacagucuccagccugaagcggaaguggaggaaag\n", + "auuggcugguggacagaaggcacugcagccugaaauggcagagucuggugcugacgauccgcgagaagaucaaugcugccauccaggac\n", + "cucccccagagccucugcagucagcagaggcagguucucucccagagccucuggcuuupacagccucccuggagucaguagcupcagaacuguucucaaacauccuucugcuccac\n", + "cagaggupuuucaccauguuguucaggcuggucucgaacuccugacuucgugaucugccugccucggccuccgaaagugcupauuacaggcgcaaaccaccacgcccg\n", + "guccaccupcuugcgaaggcacagauuccccguccacagcucacgaccagaugcaccagcaggaguccacaucgaggacguccuccpcacucccacgaccag\n", + "guccaccupcuugcgaaggcacagauuccccguccacagcucacgaccagaugcaccagcaggaguccacaucgaggacguccuccpcacucccacgaccagguag\n", + "cuuugugccgupacugcuggccucgccgaccucuugcuuuaucgacacagugaccaggaguuaaacuuupaugugcccgug\n", + "auaaggaaacugaggcacaguucagucaaagcacauguccuggucacacagcuapaggugcaagccugcccgcccagagcccaucuucacuccgg\n", + "agguccaccupcuugcgaaggcacagauuccccguccacagcucacgaccagaugcaccagcaggaguccacaucgaggacguccuccpcacucccacgaccag\n", + "auuupacaagcauuupcacacucgcuacaagauugguuagugauuauggaugaugaagucugucggaaaauucagaucuugauu\n", + "agguugauaaugaucccccpccaggagcugcauaggccacagagapcgacaagcaggaggaucaggaucuucuccaug\n", + "ggcuggccgupcagaggcacagcuguggccaaucugcugupcgguuccugauaaggaaacugg\n", + "gcuggagugcaauggugcgaucucagcucacugccaccucugcuucccpuucaagcaauucuccugucucagccuccugaguagcupaauacaggcacccgccacuacgcccggc\n", + "aagcpauuggaccaaaccagapacagagucuucupucucucugccugaggcccuggapagagaag\n", + "gagaaugucguguucaguuccagccpccguaugacuauggaucuaauuccuuuuaccaggagaaagac\n", + "auaaccaucuaguuccgaguacaaacuggagacagaaauaaauauuaaagaaaucauagaccgaccagguaaaggcaaap\n", + "gccaaacguaccaagaaagucpaucgucgguaaauacpacccgcuaupccucccuccggaaa\n", + "pccuucggagcgcgcggccagcccupcacugguuucguupuugaauuuapaaaacuag\n", + "uguugguggcggaggccggagucgcacgccuacgagacugcgcggacccgcccaaaaggaaaauggaaguaguggcgugaggcugcgacagugaag\n", + "ucaaguuuuccaucuggaaagcauuugcuucgcaaacagccacagcuuacagacuacaagcaguuuagaaacaagacuaccaccugaauauacuacacaugccuucaccugccuuuugaugauug\n", + "cugcggccacccggcuugcugccuuccupcgccacucccccaggcgacccgacgcgacgcgccagcagcgcagcaccgauuccucucpcucuupcgcugcucugag\n", + "cggapcagupcgccaucuucuucupcucacugapucuaccuguuuupaggcugcugcgacgaagaguucccucagccuccggccuuguguguccgacucggcagcagug\n", + "cuuccauguggugguguaugugcgcuucccapaucuugagagugaagaucucgaaggauuucauag\n", + "ccgacucuuccuuucccgucagcuuccauguggugguguaugugcgcuucccapaucuugagagugaagaucucgaaggauuucauag\n", + "pcgccaucuucuucupcucacugapucuaccuguuuupaggcugcugcgacgaagaguucccucagccuccggccuuguguguccgacucggcagcagugguguguguuuauugccaa\n", + "agccucagcucaaaggcaucgucaccaaacuguucugccgccapuuucuaccuccaggcgaaucccgacggaagcauccapcaccccagaggauaccagcuccuuca\n", + "cccacuucaaccugaucccugupccuccguguggucaccauccagagcgccaagcupucacuac\n", + "cucugaguaggaccpcccccacgugacucagccugccucuccaucuccucagcucccaccccccauauccuug\n", + "ucugaguaggaccpcccccacgugacucagccugccucuccaucuccucagcucccaccccccauauccuug\n", + "gagucpccugagcgucaagagcaugcccuagugagcpcuccucupagcccagcgcgcuccpcgccugccgguuupugucuccucccpcgcu\n", + "ggagcuuucuauugguccupuaccgagcaupcgcugcgucagugcgcgcuggcgcaagguugguggaagucgcguugugcagguucgugcccggcuggcgcggcgugg\n", + "agugcgcgcuggcgcaagguugguggaagucgcguugugcagguucgugcccggcuggcgcggcgugg\n", + "gucggcuacgguucccggauuccggccgcucgcccugcacuaaucuccupagaggcggcccpcp\n", + "ugauguupucaaucauguucucaauguauuuaaccauguguuuuuaaauuuuuuaauuuaguuaucaaauugagaaucugauggu\n", + "auacucguuuguaguuucauaaacauugauguupucaaucauguucucaauguauuuaaccauguguuuuuaaauuuuuuaauuuaguuaucaaauugagaaucugauggu\n", + "acagccgugcucaggaaguuucuggaaccuaggcucaucuccacagaggagaacacacaagcagcagagacc\n", + "gcacugcugagagcugugcucaggaagcuucuggauccuaggcucaucuccacagaggagaacacacagacagcagagacc\n", + "agaaggaggcaggacagcacugcugagagcugugcucaggaagcuucuggauccuaggcucaucuccacagaggagaacacacagacagcagagacc\n", + "caggacagcacugcugagagcugugcucaggaagcuucuggauccuaggcucaucuccacagaggagaacacacagacagcagagacc\n", + "aaagcuuggauggagagagugagcuacaguaggcuuguagcuggccagaapcuucucucuaaagccgcucagcuucucupaauuggaauccagacaagaaggaaaaug\n", + "ucaguuaauugaaccggaguuaaaugaucauauauaaacaapaucacuuuccuacaaaaggagaauaacaauacaauucaccuaaauaccauguuuuuucucuccccugcagaaacucaucaaaga\n", + "gguagaggcggcggcggcggcggcggcggcpcucggaggcagcgguupcucgcggcgagcggacpucgagucagugccguuugcgccaguuggaaucgaagccucuuaaa\n", + "gguuugcugaacuaacuccaagcuggugugccuagcguccgcgcggcugccggcccaagagcuggagucacc\n", + "uuugcugaacuaacuccaagcuggugugccuagcguccgcgcggcugccggcccaagagcuggagucacc\n", + "gcccpugacggcugcggagguggcggccpcupauagcgcgaguguccgcggccgagcagcag\n", + "ugccgcugaacaaaugaccauaaacugaguggugucaagcaacaaagauuuaauaucuucuaguucuggaggucagaagucugaaauggcuuucacugagcugaagucaag\n", + "ggagcggaagucacucccugaggcaguggcgacagcggcggcgagaggaugaacaacaaguucgacgc\n", + "aaggcugapacccgguggagcggaagucacucccugaggcaguggcgacagcggcggcgagagg\n", + "agagcupacuucgcuggagagauggcaccggccugaggucaaggagaaauugaacuaaacucuccuuugaagacu\n", + "guuuccagaggcccguucccgaagccggagucccgacccgaaaccguccccggccggcucgcucgcucagcapcgcggcuccagcgccacccggcucgccccgaagag\n", + "cagcgcupcagcggagagacagaggagccagcpuggccauggccuuggcgugacagagccuccccggcggccpcpugcggacggcp\n", + "ugauacgacacapcccaggccagcuggagccagagcupacuucgcuggagagauggcaccggccugaggucaaggagaaauugaacuaaacucuccuuugaagacu\n", + "aggcccguucccgaagccggagucccgacccgaaaccguccccggccggcucgcucgcucagcapcgcggcuccagcgccacccggcucgccccgaagag\n", + "uucgcagauuuccgcccaccuuccgccucgucuagccgcgccacagcuagcpugaucuuucccccccucugguaggaguuggugaag\n", + "auuucuaccgcaaagagaucgaaguggacucuucccccuccgugcuggaaauucuggacaccgcaggaacugagcaguuugccucc\n", + "gcuuucgccgccupagccguccggcgcagcaguuucuagguccccacuguccccgccgucccgccccuucgcgucccpaaccggcuggcuuccgagccgcacucgccgauccuccaggc\n", + "paaucuggcuugauuggcgugcugagacgcaccuggcgcaacccucccuucugaaucgaaguucaagucccgcggacacugcaacc\n", + "aguuggapaggcapaaucuggcuugauuggcgugcugagacgcaccuggcgcaacccucccuucugaaucgaaguucaagucccgcggacacugcaacc\n", + "caucauuucapuaccuuagcauguaugucauuaaaaaaauaaacucuucagguggagaaauuaag\n", + "paaacugacucuacucugugaugccaagacagaupaguuuccuuguacaccacuuucucuccuucuaucucaaag\n", + "cuaauuguaaagucugcuuuguggcacucauccaguccuucagccacuacaguaucgupacagaagcug\n", + "uguaguccgcagaggaucgacccpauuggacuggaggcuupcccgccgaaagupcuucupccaucucgcauauucucaacggcu\n", + "pauuggacuggaggcuupcccgccgaaagupcuucupccaucucgcauauucucaacggcu\n", + "ucuacucugugaugccaagacagaupaguuuccuuguacaccacuuucucuccuucuaucucaaag\n", + "cuaauuguaaagucugcuuuguggcacucauccaguccuucagccacuacaguaucgupacagaagcugguaaauauuuuggagcuccaugaugaggucccuga\n", + "auugcgcaugcgcgcuuccuugcgcgagccpcugucpuguguuuugcucuccagccuccgucgucucugcagcacuccpuucuccuccagagcgcuagucccaggagcucgga\n", + "ggcauugcgcaugcgcgcuuccuugcgcgagccpcugucpuguguuuugcucuccagccuccgucgucucugcagcacuccpuucuccuccagagcgcuagucccaggagcucgga\n", + "ucgcauauucucaacggcugugcguguccuuaaaagucccupaagcggccpcgcgguggcucaccccuguaaucccagcaguuupaggccgaggcpugcaucaucuaag\n", + "gagccaggccagcagcccuagcuucuggaaggauccuucaggcuccagacacccaaccuacccguggccg\n", + "gaugucugccugagccccaccccgaaugccagcccuucuucccugagcucacccagccccagcuccaggacugagagccccaggaagcuuggagag\n", + "agccaggccagcagcccuagcuucuggaaggauccuucaggcuccagacacccaaccuacccguggccg\n", + "aaacaaucucgauucuaaauugaaacgaacgcagcauuucapacuggaugaggagcuuacgguuuuuuacag\n", + "agacapucucccucuguugcccaggcuggagugcagugguacaauuauugcucacuguagccuccaacucuuguacucaaguaauccucccgccuuggccucccaaagcacupauuauag\n", + "gucacggauuggucgcggccgcgagcgcagugguguggagcgcgccpucccggagccggcugucugap\n", + "gugcuuggaacauucuuagccaccgaaguaupcaccaaaagcgauaaggagcauguguuccuuaauaaaugucacaucagaaaaugacuguuccaggacaguaaccaccucccgaug\n", + "gaaaauacugaaugaacuguccucugaugugccugguguucccaagauugaagaagagagaucagaggaagaaggaacaccaccuaguauugcuacc\n", + "cpacccgccugccuccucgcgaacuupacgaguuggaaaauccucccugagagagccgugcggcucapagcgguuuaacucggaaaaggaaaaggaauccagaa\n", + "pccgcugccggcuccpuugcupcggcggcgccgcugcugagcggcggucpcucgccgucuccaccuccucgcguccguaaucagugacgagguccgcuacguaaaucccuuugcggcgg\n", + "ggaacauucuuagccaccgaaguaupcaccaaaagcgauaaggagcauguguuccuuaauaaaugucacaucagaaaaugacuguuccaggacaguaaccaccucccgaug\n", + "uugcuauagcccaagguggaacaauccagauuucuaacccaggaucugaugguguucapacugcaggcauuaaca\n", + "upcggcggcgccgcugcugagcggcggucpcucgccgucuccaccuccucgcguccguaaucagugacgagguccgcuacguaaaucccuuugcggcgg\n", + "gauaaauaaagaaaacaggaaaggaggaaagcauugauuacaaauaucuuaacaaugagcaaaugugcaaggaaaaaauauauuaagacaaauccaag\n", + "gacccgccugccuccucgcgaacuupacgaguuggaaaauccucccugagagagccgugcggcucapagcgguuuaacucggaaaaggaaaaggaauccagaa\n", + "ggaacauucuuagccaccgaaguaupcaccaaaagcgauaaggagcauguguuccuuaauaaaugucacaucagaaaaugacuguuccaggacaguaaccaccucccg\n", + "cggucpcucgccgucuccaccuccucgcguccguaaucagugacgagguccgcuacguaaaucccuuugcggcgg\n", + "gccgcugcugagcggcggucpcucgccgucuccaccuccucgcguccguaaucagugacgagguccgcuacguaaaucccuuugcggcgg\n", + "gcgaacuupacgaguuggaaaauccucccugagagagccgugcggcucapagcgguuuaacucggaaaaggaaaaggaauccagaa\n", + "auucuuagccaccgaaguaupcaccaaaagcgauaaggagcauguguuccuuaauaaaugucacaucagaaaaugacuguuccaggacaguaaccaccucccgaug\n", + "aaaaucuuguauuauagguagcagcaauugcagagacagaugaaucugcagaaucagaagguguaauugauucucauaaacguagagaaauccuuucacgaagacccucuuauag\n", + "gucuagupacaaugucauauuauaaauuuggaaugcugaauagaaaauuauagauuuugauauugaaggaa\n", + "agccugauucccgcgcuuucuucgcpcpaapcggcgguugcugacpccgccuggacgacgguugacggag\n", + "gcpcpaapcggcgguugcugacpccgccuggacgacgguugacggaggcgapaaacugapcgaaaguugugugucguguuggcaggapccuagaapaaagacu\n", + "gucuagupacaaugucauauuauaaauuuggaaugcugaauagaaaauuauagauuuugauauugaaggaaaugaagcgaagccuaaaugaaaauucagcucgaaguacagcag\n", + "acagccugauucccgcgcuuucuucgcpcpaapcggcgguugcugacpccgccuggacgacgguugacggag\n", + "gacuuccpucgcggugcuugaapaguguuccgucguuuccguugccggcuguuugcagupaaaccgaggcagcuccugcucccccuaguucuuccgcuccugugag\n", + "uggagacupcuuupapagaaagapaccuagcgcpccgcgcaggcgcacggupcagcugca\n", + "gaaauaaagucuuugcuuuugcuuuuuggaggucaguuugccagcagucaagaaacuuauggaaag\n", + "gaaucuuuccuuuccggugaccapcccugcagaugucgccaggaaaguggugauccaggcaggaccaggcugcacugaapacagag\n", + "aaaaugaauguauguacauuuguuccugagauacagguugauggacggauggcuacauggaugugauggagaugguuuacuaucpaccuuccgcauccugcug\n", + "gaaauccagapcapuggccggcacagcagacguacccucccucgcugccugccugcagccugcccugcaugcagg\n", + "cuuucuccccguggaucuauaauuucucagaagaggagccgagacgccaccuggaaaaugaucaauucucgauaaapaagacg\n", + "cagupccupaagauguguuuccccuggaugugcacauuccuguuuguggcuuaucgccucucauuuauucugugugaguagguagaaa\n", + "aagaaccuugaaggcuaugupauuugccaaucucccaaaucaaguauacagaaaaucggugaagagagguuuugaauucacgcuu\n", + "caacagaagaaccuugaaggcuaugupauuugccaaucucccaaaucaaguauacagaaaaucggugaagagagguuuugaauucacgcuu\n", + "accuuccguuuuucugugcuuguacggccuacupcuuccucccuagccagagagcucuucugcaguggugcggccuucccpagccugauccuggcggacc\n", + "agauccggaaaaugaggcccauaggaaacaagugacuugcugaguccagauaacacugacugucaga\n", + "gaccuaccgaccauucuuccpuccagaaggugaucuccgcccgugcucagaauccapcccpcuguag\n", + "agugguguccgagaagucaggcacguagcucagcggcggccgcggcgcgugcgucugugccucugcgcpucuccugguccuucugccauc\n", + "ugcucuccuuccuuuaagccaaagagaccuaaauaacuguggcauauuauaaauuagugccuucuuucuccacaauuuuuuuucagacaagucagga\n", + "uucuccuaaaugaucaagaagauagagcuuaauugugagaucuacuuuaaaaacuguuaucaggcaaccuacuggccccuuuaaaacucuuaccapaaaauucag\n", + "agccacaaucucuggcaagcaccuaggaccuuguccccgccugccaaguagccgcccpccaugugugcccugucuccucggcag\n", + "gccupugacuccagcauggcuuuccucuccaggacgucaccgguggcagcugcuuccuuccagagccggcag\n", + "apcagugcugucacagaagacaacaccgcucccucguuaccuguggcccggccaccucagcggcccaaggag\n", + "cugucagccagucaguccgccaguccgccagcccaguaccucucucuccucggcccucguaagcuguccgcggucuguuuggcccgaacggcggcggaggcgcugauc\n", + "gagcgcaagucugucagccagucaguccgccaguccgccagcccaguaccucucucuccucggcccucguaagcuguccgcggucuguuuggcccgaacggcggcggaggcgcugauc\n", + "gucagccagucaguccgccaguccgccagcccaguaccucucucuccucggcccucguaagcuguccgcggucuguuuggcccgaacggcggcggaggcgcugauc\n", + "agucaguccgccaguccgccagcccaguaccucucucuccucggcccucguaagcuguccgcggucuguuuggcccgaacggcggcggaggcgcugauc\n", + "auugcuggagcgcaggcggcggagaggaugacugccgcugccauucucucuugagcuagcgagccgccgccacccuccacccucccccggcapcggagaggagcggccggagucagcg\n", + "ucupucaaauuguucucuauuuagaagccuuugugauaaccacagaaucagaacauauaaaaagcucugcpacuggugcugacugcaaccaugacaaagcuuauucuccucacag\n", + "ucupucaaauuguucucuauuuagaagccuuugugauaaccacagaaucagaacauauaaaaagcucugcpacuggugcugacugcaacc\n", + "gaaaccuccucgucugugcacgaacagguggccgacucuggagcccaggcuguugcuuuccagucugguggugaauccuccauagucug\n", + "caaagcuucaugaaaccuccucgucugugcacgaacagguggccgacucuggagcccaggcuguugcuuuccagucugguggugaauccuccauagucug\n", + "aagccuuugugauaaccacagaaucagaacauauaaaaagcucugcpacuggugcugacugcaacc\n", + "aaagcagugguguuuuaccacucugcagagaaagcuaagguugcuaaccaaacaaaauaacuuuacacugaca\n", + "pcuucaggacccpccggcagcaccggcugcgapuugccgaaggcgcacggaucupcgcugaaaaagccaggauuuggca\n", + "gcgccgucacccggagagcccggcggaucccggacucccgcccgccgcuccucccgccgcgcaccuccgcucaccgcucgcccggcuccagccgccgccgcacu\n", + "gaaguccpcuucaggacccpccggcagcaccggcugcgapuugccgaaggcgcacggaucupcgcugaaaaagccaggauuuggca\n", + "cuuacucaagcucpuucuucuccuaggcggaagccagaccagagagcgugcguguuuuucccapugccccgcgcugcuguuauggccgccuccuugag\n", + "aggaaacgcugccgaggaguaggcpcpcgcuuugguuccgapugcuucugcuccgacugcuuuucccacpcgucaucuauaguccggaggacagccccapcagaggccucug\n", + "acugacaggcucaagagcaaaaagcgupcaguuggagaagaagcagccagagugugaagaagcccacggaaggaaaguccapaggaggaaaagaagcag\n", + "gaggaacaacugacaggcucaagagcaaaaagcgupcaguuggagaagaagcagccagagugugaagaagcccacggaaggaaaguccapaggaggaaaagaagcag\n", + "ggugauacagaagaaaagacagucuccauuuucaaacagucccuccupagaacacagacaggcagaggauuacaacacaaggcagcaagcacupagacga\n", + "ggcggacpcpcgcuucgccguuugaauggcugcpcccpcccucaccucaccugagguccggccgcccapugcgcu\n", + "guuuaucagcuguuugacuguguguguggcauuuaaaccugaggccauuugauuucucaagucguuuuauaauuaauuuguagaaagagucpcaaauagguccagg\n", + "auucccacggcggcagcggaagapapccpcgcgccgcggcugcuugcagucuccgcaagcggcuacaucacagagcucagcgugcggugucacaggccccgcggucccgcccaacag\n", + "uucuguuuucucaaagcugaagucggcuagguuugcaaagcugupcugagcacucaggcaaucacacucucagaaacugcggcggcucuggacugcagccucccaaggcuccaugccagacaaagc\n", + "cuguuuucucaaagcugaagucggcuagguuugcaaagcugupcugagcacucaggcaaucacacucucagaaacugcggcggcucuggacugcagccucccaaggcuccaugccagacaaagc\n", + "cuguuuucucagucccggcacccgccgcgaccgcaaaggcggccgcgguucuaggaacuugacgug\n", + "aguucggccuguuuucucagucccggcacccgccgcgaccgcaaaggcggccgcgguucuaggaacuugacgug\n", + "agaupucacaaggccuguguaggcuucaggaggupagcugcccgcuucaggccucagaaucacucuuggaguuagauauuuaagaauccuuccugccuugacagccagucugugaa\n", + "ggccgapaggcggaaauagccgaaaggagcugagcaggagcgaggaggcgacpagagccagaaagagcugaag\n", + "acapucucucugucgcgcagacuagagugcaguggugugaucacaacucacuucagccuugacuucuupcucag\n", + "gcugcpccucucpugcuucuugucggcuugaaaggacuupcugaaauugccaagaaucucaucuuggcaggagugaaaggacugacc\n", + "uuugagccaccaucauccucccucaccuuaacugugacaucuuccuacccccauggcuuuccaucaugccucgaagaaaauccagaauccuuccauugc\n", + "acuccpcgugcugccggcggcgguagguggcgcgcpuccggcpcgguuggcuugagcpaccggagcugaggcaggaagagccggcgcc\n", + "uccgcggacgagguacugcgcaggcgupapucugcgcaugcgcagaagcacuccpcgugcugccggcggcg\n", + "gaaacugagacgguccggaaagagccgaaagcgguguccpupuggcaggagguggaaacagccgaaagaaaagcagccagg\n", + "ccpcgugcugccggcggcgguagguggcgcgcpuccggcpcgguuggcuugagcpaccggagcugaggcaggaagagccggcgcc\n", + "gcgcgcpuccggcpcgguuggcuugagcpaccggagcugaggcaggaagagccggcgcc\n", + "agaagcacuccpcgugcugccggcggcgguagguggcgcgcpuccggcpcgguuggcuugagcpaccggagcugaggcaggaagagccggcgcc\n", + "guaacuccagaagaucccggagcucaguucuugauucguacupucuguuggccgaaauapcugaagccucuuuggagcgagcucagaaucucaacccc\n", + "guagguggcgcgcpuccggcpcgguuggcuugagcpaccggagcugaggcaggaagagccggcgcc\n", + "acucccuccugagagcccaccgcgccacagcuuggaggaagagccugcpaacuggcugcaggacgcucucuucuugagugcag\n", + "cugaggcugcgucuupugcgcagcuccggcccagccucacccapaacgccucgcaggugcucacggacg\n", + "acucuccguagacagcucugcapaagucugugacaaccuggccagacauapcucacgaucugaucagaguc\n", + "acccuccucuuuccaccacugaggcccaaggcuccaguugcucugaggaguguggaggcccgugaggugupugcggaguggccguggaag\n", + "auucuguaccaupcccugccgucagucaaguccaagagcagacgugagucgaguggucagupuugcag\n", + "acagcgucuccaggucugcaccaggccccagcugcuccucugucuggaaugagcaagacgauuuuguugcugag\n", + "ugcaaacacagcgucuccaggucugcaccaggccccagcugcuccucugucuggaaugagcaagacgauuuuguugcugag\n", + "uuucucauaaaaucucugcuggaccagccacuccuagupagcccapuggucupagugcugcaugcacccagcugcuguaucaccaggacaucaggagguggag\n", + "agcagcupaaggcgcccacagagcpcgcgccaagcpacgcpagucgcagagapaccccpcgccugcugagcucagcuggcagaguuugcaaguggcggagacccuucag\n", + "ccaaguacaucggcugcuaccuggaugacacccagagucpcccuucgaggaguguccuuuuuugacuacaaaaag\n", + "gcauuuccgguagcggcggcpaaaucggcugupagagaggcuaggccucugaggaggcgaauccggcpuaucagagccaucagaaccgccacc\n", + "guggccccgucuggcuaguccugucuagcgcgcccauuucgagcccaaguuuccagcucpuuuccpcucagaauuuuccaggagupuucuupcaguggcugupagcagga\n", + "aupugccuuguaucaagcaggugcucaacaaaugucugcugaaaaaaugaugcapugcggugguucacgcag\n", + "uaaagaupuuucaccauguuagccaggauggucuugaucuccugaccucgugauccgccugccucggccucccaaagugcupauuacaggcgugagccaccacacccggccauauaag\n", + "agaugcgccacgguuucgguagcgacgguaucucuagccpccugagcugugcuagcaccucccccaggagaccguugcagucggccagcccccuucuccacg\n", + "ggcggcuggcgupcugcuuagaugcgccacgguuucgguagcgacgguaucucuagccpccugagcugugcuagcaccucccccaggagaccguugcagucggccagcccccuucuccacg\n", + "acugcauaguaauugcucaauugauugcuuuucuucccacpcuggauuguaccaguguccuuuacugcagugacugaacauucuaggcauaguggauucaagaaaucuugaguucauuggcug\n", + "agcugagccapacagucacggaggaagaagaucaagaugcgcuuuaacugagaagcccccaaggcagaggcugagaaucagaagacauuucaggaga\n", + "gcggucuugugaguuugaccagcgucgagcggcagcaacauggaggaauucgacuccgaagacuucucuacgucggaggaggacgaggacuacgugccgucgg\n", + "gucuucacugcuuuggccaguaggagcucuuucaggcuggaucuuguauccuuuuaauuugaucuuuuuuuauuauuauuuauuuuuu\n", + "cuuuugccucggaacuggacccpagacaucacagcgcupcuapcgcggcuugaacucgccuaaagagcugcgcccucuca\n", + "uuuccugcugcpugagccuuuugccucggaacuggacccpagacaucacagcgcupcuapcgcggcuugaacucgccuaaagagcugcgcccucuca\n", + "gaccgcgagcgucpucccagagccpcgcggcupcccgaggcuagcaucucucpagccgcaaggcgagagcugcaaag\n", + "gcauuacuagagacucaaaauuuacugcgcacucagguugcaaauuuuaccuucaaccuuggauuuucapaaguuuuaccacacag\n", + "ggacugaagaggaagaugaaggagaugaccuuuuacuucggucuguggaugaguucuggugguuuccucac\n", + "accaggapuaugcauapapcaagagcucupccacugcgaagauucaaaagcuccaaaaaccuacuguagacaucgaagaaccaauauauaca\n", + "cagguggcucugcagcagccucugccacccugugaccugcgaguauupacaucccuagcugacgccaggacacccpaagccgagga\n", + "gcagcagccucugccacccugugaccugcgaguauupacaucccuagcugacgccaggacacccpaagccgagga\n", + "ucuugauaaacugcuugaugcuggucucuauacuggagaagugacugaaauuguaggaggcccagguagcggcaaaacucag\n", + "gcpccuggagccpauccgcccuapcucggaucgccgcgcgcucgccgcucgcccgccagcccgcccgugguccguggcggcgcgcuccacccggcacpaggcgcpcgcacc\n", + "agugugauucgacuugucccugaggaguacagagaacacucuuccuguuccucugcagcugaagg\n", + "guuuacucuuacuguucuaucuccagcacugcccgucucugccucucuccacugucccuggagcucccupcccuucccupccucaggaccucacucaccaccccaucugcccugcagg\n", + "ucuaucuccagcacugcccgucucugccucucuccacugucccuggagcucccupcccuucccupccucaggaccucacucaccaccccaucugcccugcagg\n", + "agcgguguuugupucucuuacggcuauaacggaguugaaggcgcagugcggacugauugaauagcggucaucuuuugcagcc\n", + "cccguugcuucugcccuccggccuucccgccgccgucgccpaccagccgcucpccpcugauacagccgcuucaccgugccccugcccgcgacc\n", + "gcuucugcccuccggccuucccgccgccgucgccpaccagccgcucpccpcugauacagccgcuucaccgugccccugcccgcgacc\n", + "gcccuccggccuucccgccgccgucgccpaccagccgcucpccpcugauacagccgcuucaccgugccccugcccgcgaccauggccuccuccgagguggcgcggcaccug\n", + "ugacgucucuccagugaccuuaguuugagucacuuggacucagaaucaugaagucagcuucuugcagccucaccuuuucugcuguccuugcauuuacau\n", + "ucugcccuccggccuucccgccgccgucgccpaccagccgcucpccpcugauacagccgcuucaccgugccccugcccgcgaccauggccuccuccgagguggcgcggcaccug\n", + "cagagcuuagaggcaaaguuaagagacucaucagauucugagcugcugcpauauuuugcagaag\n", + "aguaaucguucuggucacupacacagcugcacucgcccauucuaaaaagucagcgcccucaggcccgcpuaaccaccuccuccugagcgcggugaccag\n", + "gcucacugaggcpugguacagccuggagcauccagccgcuggagcugcgapacccuggaccccucccacgccgag\n", + "cuuuccggagcgcpcgcgcgguggcpaauuucgccuguuugcgguuuagaccccaaagauuccuguugguggucupucacaggaggcagguuucpagcuggaaaugugagcgg\n", + "gaaucucuucacaccuucucuuuggagcccuuaaugauacgacgaaccccaaguguuucagaacaugaaguaaaca\n", + "agucuaacagcaucgcuccugacugaaggcagaacuugcuccugcuccccagcugcauggaugacuuuccugaggcacuuccuaupcggcaaguacuaaagacggucg\n", + "aacagcugcugcuggcucuuccucuugcggccuuuuccugaaacggauucuucuuucpaacagaaagcgccagcc\n", + "gcagacucuugugugcccgccaguagugcuugguuuccaacagcugcugcuggcucuuccucuugcggccuuuuccugaaacggauucuucuuucpaacagaaagcgccagcc\n", + "cccacpagaagcacccaccuacgucaacacucagcagaucccaccacaggccuggccggcugcggucagcagugcugagagcagcccaaggaaagaccucuuugac\n", + "guaaapucuucugagcugcaguggcaauuagaccagaagauccccgcuccugucucuaaagapaaapcaagg\n", + "gccucpccagcggccaggagcugccucccccagcccccgucccgcggcccccagccgcccccaacccugccccacpcccggcgcc\n", + "cggcggccucpccugacgucagcccugcaucccccaggccucpccagcggccaggagcugccucccccagcccccgucccgcggcccccagccgcccccaacccugccccacpcccggcgcc\n", + "gccgccgccgccgccgccgccgccgccgccuccgccgcggaggaagacagcgccgcccgcgcaccgccagcgaccuccgccgcagagucccaccgccacag\n", + "accaucgaagcupuguguguggapugugcgccuugupugaauuucaagaggcaccgccccuuuuaaaauuaggugcuuggapcggugccugugcpcupcagaagccag\n", + "gcgcacucuuggcaaaguuucagugcgacgagaggcgccpcgcuccauggccgcgccguaacpacccagccgccuccccgcccagcccagcccagcccuuccgcccgcccagg\n", + "pcagaapacguuguucuggucccuuuaaucpcuuucgaaacagcuucgaaguuaucaggaacacagacuucapacaugaccuuuaucucugg\n", + "uacaaaacuuuuuaccaacaaaaaaaagcaaguaguuauacucaggaagaacuucaagacacuuacpuuucuucuguuugauacugaaaagcag\n", + "gcaaaauugguaugucaguguggacuccguguuggcagcagugcuguuaccacucupugauccagccaaag\n", + "uauuacuuuuacgaacuuucaggcaacaccguuauugaacgacccagacagaucuguccuuauguaauuguagcuuuucgauacapaaucuaaaacu\n", + "guguauacauuuccaaauacuccgacugucuucauucaagaccaugguaucaupaaaucugguuauguuguaauuuuuaauauaauuaag\n", + "aguuccccgcucuggcgcacuggccuuggcuggcpapccggapcugccggcggagcagagacacagccacccuccccaacacacc\n", + "gcggaguuccccgcucuggcgcacuggccuuggcuggcpapccggapcugccggcggagcagagacacagccacccuccccaacacacc\n", + "acguacuuucucagugccuugcagagagaggaguagcuugcuggcuuugaacgcguggcguggcagauauuucagaaag\n", + "cuucaagaacaagcuggagaapaagaguuauuccuccauauucaccugcuucaacuacuauucuuauupa\n", + "ugccuugcagagagaggaguagcuugcuggcuuugaacgcguggcguggcagauauuucagaaag\n", + "agcuccuggugacaucgcaaagaauguugcagauuuuaucuucuucuaccucugugaguaggaggugagguucugaaaguucuccccagcu\n", + "gguguucagguauaaaaccagauguaaucuuuaaguuggaacauggaaaggacccauggaucauagagagugaguugucaagguggaucuacccag\n", + "aacaguaugupuuaugcaaaupaguuugupugaupaucugugcgguguuugaugaugucuguaagg\n", + "gcuaugccuuaaauupccaggcugaggcgcugcugcuggagcggccgauccgagacguggcucccupcggcagaacc\n", + "cacacgcuaugccuuaaauupccaggcugaggcgcugcugcuggagcggccgauccgagacguggcucccupcggcagaacc\n", + "aaaccuuucapcugcuccgapccgcagcuagagucggcgccacgapccgagcapugcggcggcggcpcgcuccpag\n", + "gccaggacagcugaugguuguggcagaaacaucucaagguagcugguccgcccccacuuccccaucuaccucuuguccuccccccaacaccaccaccacccuggcuccccucccuc\n", + "uagcuagaggaaaaaaaaauaaaacaacagccaaccaagugaaucccaacccaacccccugaapcugaaaauucucgccuucuucagagcpc\n", + "ggucaguuugaaaaggaggaucgagcucacuguggaguauccauggagauguggagccuugucaccaaccucuaacugcagaacup\n", + "upaccucccaggcccccuugccccccgcaacuucuggacucauauccgucagacaucacuugucaccuuccagcaucapagaacuggaucccuccuggcuccacacucuuaggcucuuu\n", + "accaccucccuccuuaacauuucuggagacuuggagaugcggcguugagauucpagaaaagaaaguucccuuggaucccgaguuauuuaagaucucaccaaguuauucgccgccgcug\n", + "augcucuccccuccucggaggaugaugaugaugaugaugacuccucuucagaggagaaagaaacagauaacaccaaaccaaacc\n", + "uuucaucuguauggaaaaggagcucugguaacuuuggccaagacuuuucaguaggaaaugcuucaaaauacaaagcaagagcuauuuucaagaaagaccuucuaaauuuauauuag\n", + "acauucagcggcugccaagaggagccgacpcgcucgcaggcucagcgcgcgcugcccgcggcaggacccggccgccuccgccgccgccgccgccccuaagccucccgaagcc\n", + "cuuuuauagcucccugguucaaccucaaggccuugagguuuuggcagcucuggaggaugagagagaac\n", + "cccagauucuaguggcaaguucacagacuccaucucuuggupuguggcaaagccacauuacagaagagcaaaugga\n", + "ggagaggccugcggcggcapagcggcpacupagcpcgccggagccgacccgagccgagccgagccgagccgagccggagcpcggcgaaggccggcgcggcgagcagcaacc\n", + "cccgcgccccgaagagucggccagccccgaacugccggaguapupaaccaaacuuuuuccugccccpacagacac\n", + "uuugcucagcccgccugcgccgcuupacgccucugccuuucccucccucccuuccccgacggcuucuggcggccaagugg\n", + "cggcgcccpcpcucaggugcpuupcggcgagagcggccgcggcpuguccgguguccgguguccgguguccggugucuggagccgcuggcuag\n", + "ccgcgguggcggcggcggcggcgguggcugccguggcggcugagaguccagagccggacguuccggccgcuucpcuggcggcuggagagcgcucpuc\n", + "agacaugcgcaguagccucccccgcgguggcggcggcggcggcgguggcugccguggcggcugagaguccagagccggacguuccggccgcuucpcuggcggcuggagagcgcucpuc\n", + "cucuggagucccpagcagugapccacccpcacaggaaapccgcuapapccpugcacucpugucupccgcpucugapaugaggapcc\n", + "cccpagcagugapccacccpcacaggaaapccgcuapapccpugcacucpugucupccgcpucugapaugaggapcc\n", + "gcauuccucapaggagacugguuucucauucagccacacugaucaagcagucgcuuugugugagauacugugcaccccgugcugcgcaucccggugaagacggcgg\n", + "cpagcagugapccacccpcacaggaaapccgcuapapccpugcacucpugucupccgcpucugapaugaggapcc\n", + "ucuaaggaaaagaagugaggucggaacaccaacgcaucaucucacugcauggcccuggaggcucugccguuuaaagaccccagaaccuuccccauucaag\n", + "guuugcuuapcguggcagcuucggauaaacgcaggacuccgccuggcagcccgauuucucccggaaccucugcucagccuggugaaccacacag\n", + "gcccgaguuucacccaguccccacuccacggugcagcugcggcuuaucucucagcccagcgagaugccagccuuccugucccgg\n", + "guucuccacaacugccagcaauccuuccaccaggcaaaacacaucaucuaaggaaaagaagugag\n", + "agguuugcuuapcguggcagcuucggauaaacgcaggacuccgccuggcagcccgauuucucccggaaccucugcucagccuggugaaccacacag\n", + "cuuaugcugagcaggucuaccupaaagagaaaguguuugcugucaccaggaacucugcupccuagg\n", + "pcaagguggaggaagugccagcucucgcuaucaaaauuauaacuaggccaggcgugguggcucacaccuguaaucccagcacugapaggccp\n", + "ggaaggaaccgagcccguccgaapagcggagcgcagccuggccupcccggucgagcccgcgcc\n", + "guucacupcgucuucugcccggccccuucgcccacgugaagaacgccapagcugugaggcagugcugugugguuccugccguccggacucuuuuuccucuacugagauucaucug\n", + "gccucacagcgccgcaggccuuccccgcguggcgccucuauauuuccccgagaggugcgaggcggcupcgcacucggagcgcg\n", + "auggcagcagcgcpccagagcgcagcgccgagcgcggcccpcgccaucgagccuuggcggcggacgugcag\n", + "auguccuguccugaugaguuggugguuccugcuguagccaucggccucgugugccccgagcgccuggcggugcccaccccucccacaggagguccucaggaagcacggagacaucg\n", + "acacaaaggccccgucuccauggcagcagcgcpccagagcgcagcgccgagcgcggcccpcgccaucgagccuuggcggcggacgugcag\n", + "ccaguguuuuagaaggaguauguggaapcaaggaguaccuauagaaccccggaggapugaggagcagagcugg\n", + "ugagaggaaggacugaguggcaguaacaucuguuapuuacupcagcauccccgcaacccagguacucagucucagccacaccuuacugaguggugaagagaagcaaguuuucuc\n", + "acgcuccgcuccpacgccgacggcggcpcgcuuccgucucgcpccucggcccggugcgagcggcuccgcg\n", + "cgcccauccupaapcccggagugugagagagagacucccccacgcccauccuggaaaggagcccggagugugagcugagug\n", + "cpccucupcggagcggccaccaucuuggaacpaggcggagcagagucgacupagcgaccgagcpccgccgccgccgcc\n", + "ucucgcguuuccggccggaagcuucuccagccuuucccggaagcugcgcucgcuacccpuaacpucccggcuguggaagcucccgcggcgccgcg\n", + "cuuucccggaagcugcgcucgcuacccpuaacpucccggcuguggaagcucccgcggcgccgcg\n", + "accccgaggacupcgccuccuccggcgcagcugapagcpccggucuccugcucgguugucgagccucc\n", + "uucaccccgaggacupcgccuccuccggcgcagcugapagcpccggucuccugcucgguugucgagccucc\n", + "ccucacgauuuugaugaaugucgauuugauauuaguguaaaugauaguguuugguaucuucgugcucaggauccagaucauagacagcaauggauagaugccauugaacagcacaag\n", + "pcacucuucgcuucgccaucccccgacccuucaccccgaggacupcgccuccuccggcgcagcugapagcpccggucuccugcucgguugucgagccucc\n", + "cgccaucccccgacccuucaccccgaggacupcgccuccuccggcgcagcugapagcpccggucuccugcucgguugucgagccucc\n", + "gacagcuaguaagauaggaagugaggccagguaccuugupcagugaugucauucggugcgacuccuaag\n", + "ggugcgacuccuaagaugucuccagagaupagagcucacccaaaccagguugcagaagaucuggauuccacacagcagcggcagcagcaggcugcaacggagaapcu\n", + "cauccauaccccaguuuaccaauucccccacaauggugaucauggupuuuaccagcucgaggcaagaccuauaucuccacaaagcucacacgauaucucaacuggauaggaacaccaacuaaag\n", + "gcagugcgcccuggcagcccugaaggauguucacaacuaucucagccaugaggaaggucauguugcg\n", + "guuuuugaugccaccaacacuaccagagaacgacggucacugauccugcaguuugcaaaagaacaugguuacaag\n", + "caagugaaacuuggcagcccugauuauauagacugugaccpaaaagguucuggaagacuuucuaaagagaauugagugcuaugaggucaacuaccaacccuuggaugaggaacuggacag\n", + "paaccaacgaacaccuccaggcuuccucuuugaugccacccacuggaccugccuupucuguaaaugcaagagaaccgaguguuggauaauuagcg\n", + "agucucacucuguccuccaggcugugagugcacugucaugaucuuggcucacugcaaccucugucuccupuucaagugauucuugugccucaaccucccaaguagcugagauuacag\n", + "ccaugcaggcgucuuuccuguuccupccgagguugcuccugccucaaggcguucaugupcugucccucugcuggaacucgcuggccccucagcugcag\n", + "gauugacuucuaaagacucuugguacgugaggaagaaacccggaagaggaagaggaaagcaaaggagucap\n", + "gaaccggccagcuccugcucuguccccucagguguccugcaggcacagcaucucppcccaggccg\n", + "cuuuguguuucucugcguccagagcugcaguucuccucuucacugcucuguguccucugcuccuagaggccaagccuauguguccuuguguccugcagguaucugcagauuu\n", + "gccugaucuuaaccccauggcagaucccgaagucuuuuuaggccccugaaucuccuuugucaagcccacag\n", + "gcugcucuuggagaggucacuccggagacggcguugguuuupuguppuugguggcacu\n", + "gagcgucagagucuccaccccgaggagcggccagagccccaugcpccugaccuguccgaccgaccccucguccaccaapapcucagaguggagaag\n", + "ccugacuucacccaguccaauccacagugcaaagagcgaguccauuauaacccagucagaagagaaggcagauuuugugauuauucccgcugaaggaauagagaacagaacag\n", + "aapacagauucuccauuaucucgagacuggcggccapagcccuggaaccuaucuggagaccucaupaagaacagcuguuggaacaacaagaauauuuagaaaaagaa\n", + "agaagaagauagcugcuaacugaguggcugacgguccugucucucgaguuggaggcaucuugacuuaguugcupagccug\n", + "uuuauaaguagaugcaacaccucauuuauaccuccuuaucucauacagaagagcuaagauuggcagaaaug\n", + "acacuccugacagcggcggcagcaggaggaggaucpagucgcpaggaupccgccgcuaggcucgcacuccggacgcgccucgcagugcgcagg\n", + "gaaaaggaaacuauuaauaagcuuggacgaauaugcuucaacucuagaauucugaaaaaaaucagaaaacuaaaaacuucugaagcucuauuugaaaucucucuucaaauug\n", + "uucuugccaaagacucgccucaguuccugagacccccagugugcuggacgugccuacuuuucaggcaggcccaggcugaggcguggcpacuugaaacacaguuagaacguagaugug\n", + "guccucaucaucaaucucuaaaugaaguuacuugaagcaauucuugaaaccauaauaauaaugucuccagaauugguggauucuuggucucacugacuucaagaaugaagccacggacccucgcg\n", + "aaggacuuuggacaacaauuucuuugacugaaacupucagaguugcagacucccuggaacaugaaaagucaauaaucuaguucccaaaaggcagacaagaaacuauucccaagaugaacaa\n", + "gaugcggccuuuaacaaaaucacaagaagccuucaagaucuucagcagaaagauauuggugugaaaccggaguucag\n", + "cgaggucccagcagcggacgapaggugccgccgucgcccaggaupcupaaugaagcgauguagccuuuuaa\n", + "apccagaucgccgcgcgapuggupcaucgaggucccagcagcggacgapaggugccgccgucgcccaggaupcupaaugaagcgauguagccuuuuaa\n", + "pcuauapccagaucgccgcgcgapuggupcaucgaggucccagcagcggacgapaggugccgccgucgcccaggaupcupaaugaagcgauguagccuuuuaa\n", + "gucuuaguacccugcaaaggaagccugucgagcagcauccagucuacuugucaguuugaguccuacauuuugauaccuguggaagagcauuuucagaccuuaaauggaaag\n", + "pupcuauapccagaucgccgcgcgapuggupcaucgaggucccagcagcggacgapaggugccgccgucgcccaggaupcupaaugaagcgauguagccuuuuaa\n", + "gccgcgcgapuggupcaucgaggucccagcagcggacgapaggugccgccgucgcccaggaupcupaaugaagcgauguagccuuuuaa\n", + "gcggccgcgcpaccgacgcgcpcugaccgagupccccgccgcpcgccucccucuccgcgccgcgcaagcccpacugcucgcpucpuuucccgccagcucag\n", + "aguacagaaguguccugugguacgaacggaggcaggcuppuuccauugugugccagguguuuccaugaaaauaaacuguugagugccag\n", + "ugugcaccugugucguccauaaacgcugccaucaucuaauuguuacagccuguacuugccaaaacaauauuaacaaaguggauucaaag\n", + "auugcagaacagagguucpaucaacaucccacacaaguucagcauccacaacuacaaagugccaacauucugcgaucacuguggcucacugcucupaaua\n", + "agccggccuggacacgauccccuuucaggacagcggcuuggccuaacpaagucpcapuccapcggucacccuuuccgcccagucuuugg\n", + "agaacucugcaugcuuaucpuguaaugccugccuccugcugcugcuccaagcuccuccaggagaaggacgcugcuucugccugguccaggaucguaucapucugg\n", + "augcuuaucpuguaaugccugccuccugcugcugcuccaagcuccuccaggagaaggacgcugcuucugccugguccaggaucguaucapucugg\n", + "ggcugccucgacuccugcaccugucccgapcuggccugagacpacucccgguucucccgcugcgaagcagcgcggccccccpccpcagcggcgccggc\n", + "guuuaaacucuauuuucuucuuucguguacuugcucuugauuugcugaccuucuaaaupaccagcaucuaaugcuua\n", + "ggcugcagcaggupauauuuuuuggauuauggagagcuguuugauuucacaucagupuucuucccucaaccuuguucagaucagugccuga\n", + "ccggauccaccgugccucugcggccugcgugcccggaguccccgccugugucgucucugucgccguccccgucuccugccaggcgcggagcccugcgagccgcpupccccaggcgcgcagac\n", + "gcccucccuauccugaagacauuagcugagagucuggcaccuuuuaaaggucugaucaucaauugucucucupcggccaccuaugagacuucaucugugug\n", + "auuguaaacuuuacuggacacaacugauggaagcuaaaaucagugaaugacuguuucaggagaaaupaggagaagcaggauuugcaugaucuccag\n", + "aacacuggaacuauuuupcugaugagaaucuugguccaguggcugugagcauucgaapaaaaaccagaugaa\n", + "cucuucaguugucugcuacucagaggaapcgguuggugcggccuccauuguucguguuuuaaggcgcc\n", + "gcaccpuuuuauupacacgccggcaagacgccucuucaguugucugcuacucagaggaapcgguuggugcggccuccauuguucguguuuuaaggcgccaugag\n", + "aucuuacucgguugcpapucacaggucagugccggagccuccgcgagugaaggaagacgaagugcgugacccgaccggcugugguguuccaguccccacugacca\n", + "agugccggagccuccgcgagugaaggaagacgaagugcgugacccgaccggcugugguguuccaguccccacugaccaguaggagcagcapcgucggcuugugag\n", + "cggagccuccgcgagugaaggaagacgaagugcgugacccgaccggcugugguguuccaguccccacugaccaguaggagcagcapcgucggcuugugag\n", + "aaagguaaggcacuggcuugapcugucgccguggugucuccauccuggauuaagcauuuccuccuccuuuucuagguggcuuuuccucpcaaccgaggaaggccccaagaggaca\n", + "uggugupagacgcugguccuccccguccucccauagcgcuuauugccucacccucacccccuapccggauccaaaggcgcugcacuccccaagccuupcaucagccaggaag\n", + "ucccuggcaauccagagaucccgauaucuaggacuguccauccauccacucccugaccuuuucccggcuccuggcugcagcc\n", + "acuuuaaccagucugcagaacugauccccagcccagcupccucaugccucugacaacccaacaguguggagcagacccacagagapagacccagagaggugugcaguggc\n", + "augccucugacaacccaacaguguggagcagacccacagagapagacccagagaggugugcaguggcauggaag\n", + "cauccagccucuacccugcugaacaucuagaucuaaggcucccaaucccauccucaucucugccccuucuucucagaagg\n", + "aaccgaugccgccpuacgagcugugcugcacgcggacgcgagcucgcgucccacccguuuuccccuuccaucuacuuuguccccaacccucuccccgagucucuuccuuuccccg\n", + "acccpagcguccpacgcggagcccggagcupcgacgaggcgauugcpccupcuag\n", + "agauggagucucacuauggugccuacucugauuuugaacuccuggcuucaagcaauccucccaccuuggccuuccaaagugcupauuacag\n", + "uuauuugcagugacuuaaaauuuggaggcaaauuuuccuuaagaggauaucaaguuccaguaucuucagauguugauaagccguuag\n", + "agacccpagcguccpacgcggagcccggagcupcgacgaggcgauugcpccupcuag\n", + "gaugccgccpuacgagcugugcugcacgcggacgcgagcucgcgucccacccguuuuccccuuccaucuacuuuguccccaacccucuccccgagucucuuccuuuccccg\n", + "gaggaucuccuuuccucuucucagacccpagcguccpacgcggagcccggagcupcgacgaggcgauugcpccupcuag\n", + "gacggcggcgguggcucuagaapagguggaggaucuccuuuccucuucucagacccpagcguccpacgcggagcccggagcupcgacgaggcgauugcpccupcuag\n", + "ggaauaaggapagacugauuuggaaacaucugugaggagcaaagaggacacuuacucacccccagguccagugguaugagag\n", + "gugcugcacgcggacgcgagcucgcgucccacccguuuuccccuuccaucuacuuuguccccaacccucuccccgagucucuuccuuuccccg\n", + "ggcgacggcggcgguggcucuagaapagguggaggaucuccuuuccucuucucagacccpagcguccpacgcggagcccggagcupcgacgaggcgauugcpccupcuag\n", + "guggcucuagaapagguggaggaucuccuuuccucuucucagacccpagcguccpacgcggagcccggagcupcgacgaggcgauugcpccupcuag\n", + "gcauuaugucgccagcugagaaguaaguggcagcugagaaguaaguggcaguccgucuuaggucucagucuggaagugguggauugccggcacucacuagcagauuuggc\n", + "ucuccuaccccuugucaugcapugugagcapcugagaupcaccgcggaucupccguccucag\n", + "auguuuucugaaagagugaaggcaagaagaaauguupuauguuuuguaaaaagcccugcacaccccagagagcagaguguugaugaaacugga\n", + "uggccauaauauaauugugauaauguaauaaaaucaggaaacauuaccugaagcagaugcuuuugaagucaccagaaaauagucuucuccaauuccaauuuaaauauggag\n", + "agugacguaaggccpcuggapcagugcupcuggucccgcaggcgcucpuuggagccagcgaccgucgguagcagc\n", + "gccuccugccgacgccggcacagaccccggugacggaagugacguaaggccpcuggapcagugcupcuggucccgcaggcgcucpuuggagccagcgaccgucgguagcagc\n", + "uugaacucgucgguugccuuucuccugccucuucccugguugccgccacaacaaaucacgccgcuuguuuuuccgacucuu\n", + "agucauguapaggauauuuugauugaacacaggcuugacagaaucuucuuuucuucuuagaaauccuagaaaacagaaagcaacaggaagaugucuuauupaacuacccccaucaacuucacc\n", + "uguapaggauauuuugauugaacacaggcuugacagaaucuucuuuucuucuuagaaauccuagaaaacagaaagcaacaggaagaugucuuauupaacuacccccaucaacuucacc\n", + "gccaccuccgccgcgcucuguccggacggacgcucgccgcccgcagccugccgcccgccgcapcgcugacggucccgcacgucugccgcugccaccggcgcgcccga\n", + "gcagucagccgccgccaccuccgccgcgcucuguccggacggacgcucgccgcccgcagccugccgcccgccgcapcgcugacggucccgcacgucugccgcugccaccggcgcgcccga\n", + "gugccgagacucgccacugccgcggccgcupccugagugucgccuucgccgccauggacgccaccpcgcugacagaccu\n", + "gaaaauggcgagaaaauaaagcaugaaauaaucaaugaagaucaagaaaaugcaauugauaauagagaacuaagccaggaagauguugaagaaguuuggagauauguuauucugaucua\n", + "ccugcaaaccauuuuaggugugccaucccuagaagaagucauaaauccaaaacaaguaauuccccaauauaua\n", + "pauccucuugguguaugacaucaccaaccgcugguccuuugacggcaucgaccgcuggaucaaggagaucgaugag\n", + "caugcacccggagucccccggaucuugguuggaaaccggcugcaccuggccuucaagcggcaggucccgacggagcaggcccgcgcguacgcagagaagaacugc\n", + "ggauuucucupaggcagccgcapaapaaugaucuuggugaacuuauaaucgaaccaaugguuccpaaagcaggag\n", + "gcgaaucuuucugcauugaauuugaagauuucugaacagaaggaaauauuaauaaaagaauuagacaccuucaaaaguguaaaacuagcuuuagaacaucuucuuagaaagagagacuacaaacaa\n", + "agcggcpcguaaguacgccuuuupuupcgacuuugupagccuagcugcugcupcguuuaccgcpagcccuuagcggucuggag\n", + "pcgacuuugupagccuagcugcugcupcguuuaccgcpagcccuuagcggucuggag\n", + "gcuacagauuguuuuagauugaaguuuccugucauguucacucaucuuuaaauccucauagugaaaaag\n", + "gugcggcccpcaugcccagugcpcgcagcggccccggcccuggaagcgccccggcggagcuggccugcggupcuapcapccggagccgcggcggcggagcugugg\n", + "auccuucaugaugagagauuupacacuucucucuccuguguguaguugauaguuugguggugaagag\n", + "gcggccccggcccuggaagcgccccggcggagcuggccugcggupcuapcapccggagccgcggcggcggagcugugg\n", + "auccuucaugaugagagauuupacacuucucucuccuguguguaguugauaguuugguggugaagagauggcugacagugucaaaaccuuucuccaggaccuugccaga\n", + "uucagucuccucuuguuuuaucgaguauuuauuccugugcuucagucgguaacagcccgaauuaucg\n", + "gugacccaucacuacauggagauguuuggucguggcuggaauucuuccucacgucaauuuucagugcucuuupugcuccccuuguuugugcuuagcaaaguggugaaugccauuugguuucag\n", + "gauauagcugaccuggcauuugagguaucapaggaagccucacccauucccuagugucagcaaaauaauugcugac\n", + "agugcpcgcagcggccccggcccuggaagcgccccggcggagcuggccugcggupcuapcapccggagccgcggcggcggagcugugg\n", + "guuugagagguuauuuguccaupaugcucguguuaaaacaaaaaucuucauugcaaagcuuaaguaaaaacaagucucgaccgag\n", + "aguugugccuapagaccaguuuucugccgaauugccuaggagcugupagaupccugaauggacccguggacucagaggcagcccguggagccccgupaa\n", + "aguuuucugccgaauugccuaggagcugupagaupccugaauggacccguggacucagaggcagcccguggagccccgupaa\n", + "gaucauugucuauuguucuccaaacaguaaaccaguauuucacacugagauugucggcugcpuauauuccaauuccccgucuccucaugaauaugaagugaapcucugacccuggaagug\n", + "gagagagagagagaaaaaaaaggucagguaggaagaagaaaaauagacuuucugugacuguauacucuugaaaucucccgcagguucuaagcapcaaa\n", + "gucuuacuuugucacccaggcuggagugcaguggaacgaucucggcucacugcaaccuccgucucccag\n", + "uaaaccaguauuucacacugagauugucggcugcpuauauuccaauuccccgucuccucaugaauaugaagugaapcucugacccuggaagug\n", + "gucuccugcgagagccgcpccgcggagcuggagccggagcugaagccggagccpuuggagucupcpccpccggagcpcuccagagac\n", + "ggcgcgccgcuugucuccugcgagagccgcpccgcggagcuggagccggagcugaagccggagccpuuggagucupcpccpccggagcpcuccagagac\n", + "aauccagcccaaggaggcccccaaccagauacccaacuccaaggcaccucccaccugcccapcgcaaaucgucaacggucccagcuaca\n", + "auaccauggaguaguuugaaacaggaacaaaaucuucugaaagcucggagcagaagccuuuuuggucaac\n", + "aaacagauaccauggaguaguuugaaacaggaacaaaaucuucugaaagcucggagcagaagccuuuuuggucaac\n", + "uggaaauggaucgucauaaaggucuucauccucaucaucauguugaguaggcugaagaggaggaggaaaaggagcaauuggucuugcugucucapuggcagaggcaaaagaaaauccaugu\n", + "uuucgauacaagcggcgaguuuaugcccagaaccucaucgaugauaagcaguuugcaaagcuucacacaaag\n", + "ccuggcugcccauugugugguugcagcugupucgcgupccuggccggcuaacucucucucucauugcucucuccugcccaucugc\n", + "acuuuaaggapcuguccaacugcaaggacgcuguaagcaggaagugaaaccacagagcuucaaaaaaagagcpacapacaagcguaucuaagaggcugaac\n", + "cuugugaacaccuucuucagcuuccuucgacgcaaaacagacuuuuucauuggaggagaagaap\n", + "cuucccgaacuuuggcuuacccucagcuugagccagcgcacaucuccuccuuaacagccucuccugagaauaggcuggcuucaag\n", + "gcggaaggcggacgacuagagucguupcccggcgcgacccgcaggagcguagagagcgcpacuagagugcagagcuccpacguggaucggagccggcgcg\n", + "cucugucaguggcggcugcugccugcucuggaggcaggcupcgguggcggccgagacuggcpuggacgcccpccpcugcgcccgcuucuugcag\n", + "cugugaauuccuuuggacaauugaugauauuuaucauugugcccaguuucuacaaauaaaagaupuggauuauuuucucg\n", + "gucucucugucaguggcggcugcugccugcucuggaggcaggcupcgguggcggccgagacuggcpuggacgcccpccpcugcgcccgcuucuugcag\n", + "ccggcuugucucucugucaguggcggcugcugccugcucuggaggcaggcupcgguggcggccgagacuggcpuggacgcccpccpcugcgcccgcuucuugcag\n", + "cugugaauuccuuuggacaauugaugauauuuaucauugugcccaguuucuacaaauaaaagaupuggauuauuuucucgauggagg\n", + "gauggacauaaagccaaaaagccagcauguaaauuugaagapucaggauguccuagcuagauggucagauggcuuguuuuaucuuggcacuaucaaaaag\n", + "auaaacauauugaaacagagcugcuucaucauauuugaagacaguucuaaauccupuucucuggaaggacauucaaacag\n", + "aagupuuuuucagccuccugcaccggugucgcgucugagugcgacugaugagccapcgucgguggaagcuup\n", + "ggagaggcuagugguaacaggccgagcuggauggaupuaupagapcaggacguucagcccupauucuggccgacccucgccuuccuucucugcagcuuccccgcag\n", + "agaccuagacaacucggaagupuuuuucagccuccugcaccggugucgcgucugagugcgacugaugagccapcgucgguggaagcuup\n", + "accucapuuuuccggagcugaagaaugacacauuccugcgagcagccupagaggaaacagacuacacucccguuuggugc\n", + "cgacgcucuugguucccuacagaaapcggagccuggacuppcaggcucagauucagguuaaauuguggauugagcucgcaguuacagacagcugaccauggaagcgaaupuup\n", + "acggagccucggagcgcccgcagacuagcccgugucugapugapauacugaggcccaggc\n", + "gcgcgagcggcggcgguagcggcggcagcggcugcggccaagcupuccgagcaucccgcggcucuggagccgcccggcccggac\n", + "gccccgcccguugcgccgccggcaggaggcgccgcggcacgcgcpucupcgccggccccagccaacggcpupagcagcgcpaacguggcggcgcggcpuugugccggag\n", + "ggaagcpcagcgugugaacaagupcacccucuggucuggccaapaggaugaccaaacggagagaaaugcuuucugaaaaucccaaaacagauaag\n", + "agaagguggcgaguuucgcggccagaggcuuacagguccagguggagaggccpcuggccapcuucggccuccggcgucpaa\n", + "accaaagaaaaaagacaccugugccuggcaggucgauacgcuacuaauuugcccgagguacgaacgaaacagaagaugcugauuucuggauaaaacguucugcagugccag\n", + "gcugcaguguguucuacugaaugcauguaccauaauuuacuuaauuaucupcugauucugaauuucuauu\n", + "uggcgaguuucgcggccagaggcuuacagguccagguggagaggccpcuggccapcuucggccuccggcgucpaaauggcggcppcaggauggaggac\n", + "acggugucuugcugugucacucaggcuggagugcagucgcacaaccucagcucacugcaaccucugccucccpuucaagugauucuccugccucagcuuccugaguagcupauuacag\n", + "gccccgccgccgccaccucagaagcaggaaccgaagucgucgccgccgccgccacugccupucuucggucpcccgcagcc\n", + "cugcuagagaggcaggcggaggcucaguccapaccaguuucaguuggagaagcugcgcuuccuggagaacuacaccugccuggaccagupcc\n", + "gcuggagugcaguggcacggucucggcucccugcaaccuccgccucccagguucaagugauucuccugccucagccuccggaguagcupauuacag\n", + "cugccpuucuggcgcgcccuuucaguucugcuugcugucggcaccgcugcguuacccggaaccgccpccgaacagc\n", + "cucacuucccuggagccgcccgcuugcccgucggucgcuagcucgcucggugcgcgucgucccgcucc\n", + "gccaacugacugcupcagauuuguggucaugaacaugugcuuuguguccucugaccauuagacagauu\n", + "gagaugccaaggaacuugccaacauccugaaauaccacauuggugaugaaauccugguuagcggaggcaucpcccuggugcggcuaaagucucuccaaggugacaagcuggaagucagcuug\n", + "aguauuggaguguuacapagacauacaggauuuaagaagcccaucauggagaagaccuucaauuacag\n", + "agauaaaaaguuuuucuugugaacaaguuacacuagauggaagauaacagacugaggagugagcugcuucugacucgauuaaaaag\n", + "pcpagacaugccguggcuguugcccccgcaacguaacupaggccaguauuuguaaaucggugcuucgacuucuaaucccaaagccggcag\n", + "guugcuauggaaauacaugaccacgcaaaaggaaguccauucugauaauucugauaccugagauguaacuggacugaagaguagaaacaggaaaaauuuuagugccaacuuuaauuaca\n", + "auauuuuggaguguauacaauaauaucccuccugugacuagccugccuuugagauguaguuaucauuuaaugagaggagagaggcgaccacuuug\n", + "uccacaguuuggaaagaguugcuguuagcaaccaucpaacaguucacagacugugccgcagcag\n", + "cuucccucuguguguugcaguccuguggcauuaugcaugcccccucccagugaccccaggcuuuuuauggcugugagacacguuaaaauuucagg\n", + "acaggauauugcuguguugcccaggcuggagcgccguggcacgauuauagcucacuguaauuucgaacuccupcucaagugauccucccaccucagccucuguuguagcupacuacag\n", + "gcagaccggcccagcgacucucccpcugccagccpacgcgcggccgccgccgcugcagacgacgaguccgcccucgucccgcgcccccpcucgcggagccag\n", + "acggaauguugcucuuguugccgaggcuggagugccgugaugugaucuuggcucacugcaaccucugccuccaagguucaagugauucuccugccacagcuuccupuagcupauuacag\n", + "guacuuucugagacuucauccucgaggccugguggcuaccggcucuuuucaucuucacggccacccacagaaaugaagcagaguggccuag\n", + "gcucacagugcacapcuguucagcaccacagugcupuggcuccuccagugccccgaaucuucaggacuacgcccgcagccauggcaaaaagcuaccaccugccagucugaagcaccgagaug\n", + "puagccaggcucpcaccugagcuggaggcggaagcgugaaauaaggacugagupcaaagagaaccupcugag\n", + "ugugugcccaupccccgcagacguggcagcuccpuapcugaauuapuggccagcccuccuuuacccagcuggcugccagucccaapagcccugugucggcccggaca\n", + "acucugcugaapcugagaggcgcacccpcggccagcupcucggagcggaacpucagg\n", + "agcggcgcgcaugcgcagcagcucacucugcugaapcugagaggcgcacccpcggccagcupcucggagcggaacpucagg\n", + "gcgccugccugguucccggccuuugccaggcccaaguucucupucgcucucccuccuguagcgccgagaaaacaccauuccgapccgccgcucggccggcag\n", + "guuacuuugcaucagcagacugcaaacuuuuucuuaaagagccagauaggaaauaguccaauccugaagupcc\n", + "gauacugcuggucaagagagguuuagaacauuaacucccagcuauuauagaggugcacapuguuauauuag\n", + "uuuaugaugucacaagaagagauacauuuguuaaacuggauaauugguuaaaugaauuggaaacauacuguacaagaaaugacauaguaaac\n", + "cugagaggcgcacccpcggccagcupcucggagcggaacpucaggauggacgaggacgugcuaaccacccugaagauccucaucaucggcgagagupupcaaguccag\n", + "aguuugcuucauagcucugugaagaagcuguggcccacacupuccccucuuuuccuaaauccag\n", + "gcuucagcacuggaagcuuuugcucgcaguuugcuucauagcucugugaagaagcuguggcccacacupuccccucuuuuccuaaauccag\n", + "agacgcguaggcuggcagcccgcugagcccgccagacuccgccgccgucpagccggccgcupagcccgucgcuaupaccgcgcugagccgcccgcuggcpagcagcgcggucgagg\n", + "gucuuucauuucuuguucgcuuacuuucgugaaauccucacaucguuuuaaugguacuagucaagacaagaaaaucaacaggcuuucagccuugaggcaacauuggauauuauugag\n", + "gugccucccpcccucgccagcuccagaugcgugaggaggacuucagaaacccgacugagaaguggagcgacccccapapucggaccugccucaauaccgccaag\n", + "gugugaacccacaucccugcccccapccaccugcaggacgccgacaccuaccccucagcagacgccggagagaa\n", + "ccaggcagauggagaugauccuugacaggucugguggcugguucpucuacugaaggcugucuugaucaggaaacugaagacucucugcuuuugccacagcaguuccugcagcuuccuugag\n", + "gaggccupcggccugaggagcgcggaccccggcgcucggcucccggcgccaugugapcucpccgcppccpcgcuccccgccggag\n", + "cccggcgcucggcucccggcgccaugugapcucpccgcppccpcgcuccccgccggag\n", + "ccuuacacggccacagucggauucgcugccgcagcagccgccacccccaggagccgccpacccucgcgucgucgccgccgcggcccagauccccacacc\n", + "gcaugucccucccagcugcccuaccuuccagagcccauaucaaugccupucagagcccupaaggaacugcucaguuaggacccagacggaacc\n", + "auuucucaacaauuccucaccgcaggagccucugaagcucccaccaggccagcucuccucccacaacagcuucccacagc\n", + "agupcacaupugcpuguaggugccaagcgccauggcuuagacccgagauuggaguccggccgccccccgacagcagccgccuccugccccccgugcgcccuaggcgccacc\n", + "gaagccgcagccgcccggcuaggccccpcggcucuagcccapcggcccgcpcgcupccuggcucccggcuccgguuuccpccggcpuggccgcucacc\n", + "caugaagccgcagccgcccggcuaggccccpcggcucuagcccapcggcccgcpcgcupccuggcucccggcuccgguuuccpccggcpuggccgcucacc\n", + "auaacucaggcccggugcccagagcccaggaggaggcaguggccaggaaggcacaggccugagaagucugcggcugagcupagcaaaucccccacccccuaccupacagg\n", + "ugccupucucagcgcagugccgaugguggcccguccuugugguuccucucuaccupaaauaag\n", + "aggagaggaugcagapagcagacagapauppapucgaggcagugacuaauggaccauguggcuuccccucucaggagcggcc\n", + "aguguggugacacacgcuguagcugucuccccggcuggcuggcucgcucucuccupacacagaggucggcaggcagcacacagapaccuacpcag\n", + "gaaucuucaggucuuccupaagcauaaccuucggcaaapagaguucccaggagcagaguucuguuguccpcugugauccacccugacuaugaugccgccagccaugaccaggacauc\n", + "pagcgguagcggcggcggcggcggcggcggcggcggcggcggcggcggcguguggagcgapagcggcgcgagcggcggc\n", + "gappaaccpcgccgccauauuggcuguuguccugugapagcgguagcggcggcggcggcggcggcggcggcggcggcggcggcggcguguggagcgapagcggcgcgagcggcggc\n", + "auauuggcuguuguccugugapagcgguagcggcggcggcggcggcggcggcggcggcggcggcggcggcguguggagcgapagcggcgcgagcggcggc\n", + "gcagacacugcaucpcagcapacucupaggcuggugcagccagaaggcauggcucuugacagccuucuaguagaaucucuggaauugugcau\n", + "cccuuucaugaccuucaccpaggcugaggucggagucccgauuuucuccugcugcuguggcccggac\n", + "agacucucagguugaugcaguguucccucccacaacucugacauguauauaaauucugagcucuccaaagcccacugccaguucucuucpacuaacugcaacggagagacucaag\n", + "cuuuuccgcccgcuccccccuccccccgagcgccgcuccggcugcaccgcgcucgcuccgaguuucaggcucgugcuaagcuagcgccgucgucgucucccuucagucgccauc\n", + "ccgagcgccgcuccggcugcaccgcgcucgcuccgaguuucaggcucgugcuaagcuagcgccgucgucgucucccuucagucgccaucaugauuaucuaccpaccucaucagcc\n", + "guuucaggcucgugcuaagcuagcgccgucgucgucucccuucagucgccaucaugauuaucuaccpaccucaucagccguga\n", + "agugacgucacgagauuuggagcucgcpaaaacuugucucugcguugupaggacgcgcgcucgcgcpauuuucaagcguaggcccccpaacucgagcugcc\n", + "ggauagcccaccucauguuccuguaccugaacucucaacagacacuguuauaaaugugaucacuaau\n", + "gucuucugucuccgccucacccucaggccugacgguccgaguggagcugcpacagcccgaaccuccaggucagccccgcggcccucc\n", + "gcgcuggcugcpcggugagcugagcucgcccccpagcuguggccggcgccccugccgguucccugagcagcggacguucaugcupapcggcpuuggaagcaggugccacc\n", + "cucupcuuccguccuccgcccgcgcccgacggagccuguucgcgucgacugcccagaguccgcgaauccuccgcuccgagcccguccggacucccccgaucccag\n", + "gacggagccuguucgcgucgacugcccagaguccgcgaauccuccgcuccgagcccguccggacucccccgaucccag\n", + "cpacgugcggaggcucucacuuuccgucauggcgcugaagguagcgaccgucgccggcagcgccgcgaaggcggugcucpccagcccuucucugccgucccupag\n", + "auuaaugauguuuugcagcaguuuucuacgucugaaauuuuuuaugucucuggaacccagaauuugcuaagag\n", + "cucuuccucugcucccgcpucugugcugagaauaauggcccgguuggcccpacgaguggaaug\n", + "ccgguagcgaagccucucccucuuccucugcucccgcpucugugcugagaauaauggcccgguuggcccpacgaguggaaug\n", + "uccgguagcgaagccucucccucuuccucugcucccgcpucugugcugagaauaauggcccgguuggcccpacgaguggaaug\n", + "agagaguuugcacagagacucugaggaagcagucaccucaggccucuccauccuagagacggcagaaggacaaacaucuccugcuggcacaag\n", + "aaugaugaacgacauaccugagagccagaccagcaugaugguuaaugcucucugacucuggaaacagccuacuuggauuugaauccugucucugcuacuuacuacuu\n", + "agugucpucugcguggaucgguccuuccaggacaccgucgccuucccggccgcgucggaguccggcggcgaccugccucugaaac\n", + "cuuccccgcgcuuugguucgugcguccgcgccccagugucpucugcguggaucgguccuuccaggacaccgucgccuucccggccgcgucggaguccggcggcgaccugccucugaaac\n", + "accucauaguuauuccuaggagucaagaagaugaugcacacaauguacaagcaguaauugauucacuggccuuggacuacuugcaggucagcuugucucacauaacag\n", + "gagaaaauauagugaaaggagauaaagaaucuauuaagaaucuccuggaaauauuugaugguuuguuggaguaucuuacagaacgcaucagugaaacaucucaugagaaaa\n", + "gugacuuaagagauuaaaauuaauuugguugcuguugguucugaacaaauaaugaguucuuuuauuugag\n", + "guaugccauuuugaagacugagacguuggaguuuuauccuagaggauaaaggaaaucuuupaaagucaguauuuuauauagcaa\n", + "aaauaugaaccucaaacugaauccucuaaaggccccauacaaugaaguagacauugguggaaacauuua\n", + "ccucauuucgcgaggcuccacucucuupcuucaggcugccgcupccuccagcaccaaapcaauapucugagaguccpccucaggcaucuucaggccgcag\n", + "ggacucccggaagccgaaucccggcupaggaagcagcugagacccggccaacagacupuuaauuuagccagaaaapcpaapcuguapuacuugucaauucgccgcc\n", + "gaaucccggcupaggaagcagcugagacccggccaacagacupuuaauuuagccagaaaapcpaapcuguapuacuugucaauucgccgcc\n", + "gagacccggccaacagacupuuaauuuagccagaaaapcpaapcuguapuacuugucaauucgccgcc\n", + "agcugagacccggccaacagacupuuaauuuagccagaaaapcpaapcuguapuacuugucaauucgccgcc\n", + "paggaagcagcugagacccggccaacagacupuuaauuuagccagaaaapcpaapcuguapuacuugucaauucgccgcc\n", + "ccggagaagccgcugcggaccuucccupcaguggccpcggccccpcccgcaggagapaaapugucc\n", + "cagcuccaucccccaccaaccccaagcagauggcaguucccuuacaagucuaaggauauapaggaagacaag\n", + "uguuuguugguuuuauuucauuuuaaguuuaagaucuguuguuucuuuggaggagaacaaaguguaccagcaguuacagcagccgacupuuggcuugagaggag\n", + "cccgcccuuccpccgaaagcgaaagcgcgcucggucucucggugcucgcuccaucpucuggcpcuggcagcggcgaggacccpucuggcgcugupccpagccgupcggc\n", + "aucpucuggcpcuggcagcggcgaggacccpucuggcgcugupccpagccgupcggc\n", + "gcuccaucpucuggcpcuggcagcggcgaggacccpucuggcgcugupccpagccgupcggc\n", + "acuggcgcaugcuaapuguguggcagauccaucugcuucgccuccaucccauccupagaaaguauuugcugcaguucagcaauucggagcac\n", + "aauucucucucgaaccugccaucgucccpcuucagaauccacupcuugguucaucaugguuuaaggugaaauucpcgaaggaggcaggacag\n", + "guggaauccgcaggcuggaggcucccapaggcaaacgccuggcccugcccugccccacgccgcacc\n", + "gccccgcgcggauggcgacggaapaggccgcucggccuggccuggapagaccucgcucugccccgcgucccagcc\n", + "aaccugccpcgacuccccaapccpaaggucpacggcgagagauucccugcupaccguc\n", + "agagauupcuguuuccucacugauacauaucccuucacacuucuauaauuuaacucucucaacugcaugugaaagaucuuagcugaag\n", + "cuuccucuuccaggccuucuuguucuugccuuguggcaauagcuuupcuucugacugcaguucuucugagugugcugcuauaccaguggauccugugccagg\n", + "cugucuugguaccugcgguaguagccuggcuuugcucugacggcgaucucgcggcccgagagccuuuuauag\n", + "guugcuuuucccpaugugaaggauacagaaaugacugugaaucaacccauaucaucaaggagcugauaaucuaguggaagaguuagacgugugcauacuucacuaugauaugaggcagucucug\n", + "gcuuuuuaauucccucgguuuccuguuccggaggcgcpcggugccacugucuugguaccugcgguaguagccuggcuuugcucugacggcgaucucgcggcccgagagccuuuuauag\n", + "acagcuccuucagugucucuguuuccaaaccgcaaccgagaagagacagacggagaaaagagaguuacuuuuccag\n", + "gguuuccuguuccggaggcgcpcggugccacugucuugguaccugcgguaguagccuggcuuugcucugacggcgaucucgcggcccgagagccuuuuauag\n", + "gcuuucguugacgcgccaaucaccgcgcacaaggcccugcggupcugaagaguuuucccucccuuggcccagcuuucucag\n", + "auauccucugagagccaagcaaagaacauuaaggaaggaaggaggaaugaggcuggauacggugcagugaaaaaggcacuuccaagagupcacucacuacgcacagacucgacggugccaucagc\n", + "aagugcugcgagcaggagacggcggcggcgcgaacccugcupccuccagucacccucgucuugcauuuucccgcgugcgugugugagugg\n", + "ccgcgugugugcgccuaaucucaggugguccacccgagaccccuugagcaccaacccuagucccccgcgcggccccuuauucgcuccgacaag\n", + "cggccucccuuuagcugccaucuugcguccccgcgugugugcgccuaaucucaggugguccacccgagaccccuugagcaccaacccuagucccccgcgcggccccuuauucgcuccgacaag\n", + "ggaacugcucgcagaaagaagaaggugguucauagaacagccacagcagaugacaaaaaacuucaguucuccuuaaagaaguuapuaaacaauaucucugguauugaagag\n", + "agccgaacccgcccuccgaauccagagaggcgcugcugacaccgccgccacaccgccgccacaccgccgcugccucaguc\n", + "cucuagugcgcacucucggaagcgcagccgaacccgcccuccgaauccagagaggcgcugcugacaccgccgccacaccgccgccacaccgccgcugccucaguc\n", + "gagcacagugacaauccagacucagcgguguuuagagacuuggaaagaguuugagaagccacuuagccacuuuauuuucag\n", + "agacuaggagccpaucccuuccugccuggccuccaacccacupaacccaggcaauccuuucuuucccuggacccagaugcugccucugagaaugcggcccuugg\n", + "aagucccapuggccgcuuucagcucggacugaauuaccugcgcucuuuucggcuggcpcuggcpcggugcuggugauguuaacuuuuuaucuccag\n", + "acuccaaaccccaugaugagcucuugcagaacaacagaauucagauugupuugacagaacuucagagucuugcag\n", + "aaccccccaggucugccuagcauugcugucugcugguucgupcugccuuuguggaagcaagcucgucauugacuggcacaacuauggcuacuccauc\n", + "cuuuccupupucucuagguauagccggcguuaaucuugccacgugucagaaguguguuaagugaauccauugcguggucucacguaauucuccuaguaaguggaacccag\n", + "uupccccgaguuuuccaguacggagucaaaguuguacuucaggcuauguacuugcuguggaaguugauguggapagccaggugccuauaucuuucuccag\n", + "ucucuaucuuuccuagaaccccccaggucugccuagcauugcugucugcugguucgupcugccuuuguggaagcaagcucgucauugacuggcacaacuauggcuacuccauc\n", + "guuggcggcgcggcccpcgcuucagguagccucucggcucucucugcuccgcuccgcgcccag\n", + "aggauugcuccugupucacuugaggcaggcuccaccuuccccaggaggaguggcagaguccagccagcgcucggagcuggaggcccacgupagcagugagcggcu\n", + "agugcccagcagccccgcuccgcucugcccagcgcguccccuuugcuccagcccugcggccgucccuuucggccggcggc\n", + "cacagagaggaggacaucagcauggagagacugcagaucagucccagcaaaccuguggaggccaguuaaaugccuggagcucauccccugccauucaa\n", + "uggagguugcugugagccgagaucgugcccuugcacuccagccupcaacaagagugaaacuccaucucaaaaaaaaaaaaaaaaaagaaaagaaagaaagaaaucucaccuuucug\n", + "apacupcaccgaucugcguagaaacpuggcpaagagapaggagagcucugagupaagcggagccpccupacccgucgcgucagagccag\n", + "cugugcuuuuaggagacugaagccaaggauaccagcagagccaacauuugcuucaaguuccupccugcugacagcgugcagg\n", + "ggucucacugucaaccaggccagagugcagugaagaucauaccucacuacauccgugaacucccpcuccucccaccuaagucucuugaguagcupacuucag\n", + "gagacugaagccaaggauaccagcagagccaacauuugcuucaaguuccupccugcugacagcgugcagg\n", + "aacaagaugcaaggacaaucugaggacugagagccauuucaacgugagcccccagucugagaacaagaaagaagaacuucugucucgag\n", + "acugaagccaaggauaccagcagagccaacauuugcuucaaguuccupccugcugacagcgugcagg\n", + "uggauuuugcucugaagguucuccaguggucugacuacgagauagugcggcuucagcugupauauugcag\n", + "ggaggaapagagagaggcgcgcpapcgucuapaaucgaggugccggcugcuccuuccucacaauuug\n", + "aucacuauaaacaaaauuuccacaagagaaaauguugaaauaggaguugcggauacauuggauauacuggaugaaauacaagcgguuaauuuuuguaac\n", + "gcugucuuuugaagaagaucagaaupaagaguuuuguaaauuagccauuuaaaaacaaucugccauguugauuuugguccauaggaag\n", + "aucacuauaaacaaaauuuccacaagagaaaauguugaaauaggaguugcggauacauuggauauacuggaugaaauacaagcgguuaauuuuuguaacgugapaaaagcccacauugcugguuac\n", + "ccpuapuccucgcucgcuagcuugcuguuucucggagaagcucccgaguguccggccuagaggcc\n", + "cucucgcuuccagcugupuggcgcuaggcagcuucagccggaccpuapuccucgcucgcuagcuugcuguuucucggagaagcucccgaguguccggccuagaggcc\n", + "aacccupuucaggcuucugcuguaucauauuugcuaaagacaccaaaacuagauagagcuauuugauccugacuaag\n", + "gauaaauccugaugauucucucapaccucuaguagauuagcucaacacucgagaaucauugcagcuucaag\n", + "ggaccacugacagcagcuguuugcaauaguugacaaggagaaggaauagapaaaagauagagaaaagaagagauuuuguuuccucucagaaaaccaaugguccaagugaaaacacaaacacaa\n", + "agauacacagaagcacacauuggcuccapcacuuccucugauuuaggaaggcaagucccuggauaagaaugacaagaugaucauuccaaaag\n", + "augugaggcgccgcggucgcpcgcuucgcpucgcuucccgaagcugagaggccggccggcgcggagccccgucuucccaccucccucgcggaccgug\n", + "gcuaucagcugcaaaggucaacacaguauauccuacacuuugucaaggaaucagacuguggugguggaguacacacaugauaaggauacggau\n", + "aaccuguacauugauccaaagapaagaaggaapaaaugauggaaaaggaaucccucacuuugaagaaauuacagcucgcaaa\n", + "uugcucacccaauccggcccaagccucccucagccaccagcaucccggccauucugaaagcuuugcaggaugagugg\n", + "ccuuuapccaggauggagccuccuucacugcuguauccccagagcguggcauagugccuggcacaaa\n", + "gcugacaaaaucaggaaguguguuguuaacuuccugacuucuuauauuucagagaacgaagaguugaaccauuuaac\n", + "guaaaaggcuguuugucaugguacagcuacggugauuuuacuugagauauuugacuuugagauggagaugaagauaaguauauaaugcagcugccacauucauucucauacaag\n", + "gauuccucauguccauaacauguuggaugaggcucugcagcucacccccacucucagaguggucagucuccauuaauuggaccccgugauuuccaaucucugcuguguuggacguc\n", + "ccguggcgccgcguupccuaacucgaguccugccgccucccpagugccgugcgccgcagcccpcccaggccccggcagcgccupacaag\n", + "pccuaacucgaguccugccgccucccpagugccgugcgccgcagcccpcccaggccccggcagcgccupacaag\n", + "gucuucagaacuacuagcagauaauuuppacuucauauucagaagucuauauaaaggugacugacccaa\n", + "cuaagagcagcuuuaggaauucagaguuuguccaaaggcccaaucccuaaaauuauacucucaauucuugaagaauguaa\n", + "cuaacucgaguccugccgccucccpagugccgugcgccgcagcccpcccaggccccggcagcgccupacaag\n", + "gcguupccuaacucgaguccugccgccucccpagugccgugcgccgcagcccpcccaggccccggcagcgccupacaag\n", + "aggaaacgccguggcgccgcguupccuaacucgaguccugccgccucccpagugccgugcgccgcagcccpcccaggccccggcagcgccupacaag\n", + "cucgaguccugccgccucccpagugccgugcgccgcagcccpcccaggccccggcagcgccupacaag\n", + "pacccucagcgagacgcapacuggcccgcaccucuggccgccgccucccgccgagaaccgaguucuaguupaaacgucugacaucuggacaucaag\n", + "ugcaaccaccauuacggcgugauccacuccuuuuccucuaagaaugcugaacgguaccacucuagaggcag\n", + "gugcaaccaccauuacggcgugauccacuccuuuuccucuaagaaugcugaacgguaccacucuagaggcag\n", + "uccuaacccagcgcagccguuucugcgccugaucucagcggacgcagugcpacuucucccuuuauuucugcagagcugapcaggcggcgcaacaaaucucag\n", + "gacuccpcugcaugucagcuccuugccaguaggcuggcgcuucgaggccauucuggaggccagucgcuuacugaaaaggcaaaacugacuuuaag\n", + "ccuuuagccccgcccgccuccguagcugccugaaguagugcapucagcccgcaaguugcagguc\n", + "agcccauccgcapagcugacuccpcugcaugucagcuccuugccaguaggcuggcgcuucgaggccauucuggaggccagucgcuuacugaaaaggcaaaacugacuuuaag\n", + "cuuacaguggucccugcuggcccuuggugacpucgccucaguuccgacccggacccguacgcugcugcgcugacguggcucccggaaguapcuggcguapccgcc\n", + "acauccaguagcaucguuuuuccacuuauucuuucgagucagugcaaucaucgucuaucuucucugupuugcucagcagcagcuuuauuaccugu\n", + "gcucuuacaguggucccugcuggcccuuggugacpucgccucaguuccgacccggacccguacgcugcugcgcugacguggcucccggaaguapcuggcguapccgccauguugcagcag\n", + "uugcugacagguggaaccugaggcagcaggacagccuggcauuggccacpacaucggccacaaccauagcaacuucggcaucaaaupcaggagagagaacauuaag\n", + "caggugcupcuaaagugcccagaggugucccuggaggccccugugagcccagccagcgcagugcgcaccacccucuuaggcaacaggagcagcacaagaaccugcu\n", + "cuuccucccucccucccuuccucuuacucucauucauuucauacacacuggcucacacaucuacucucucucucuaucucucucaga\n", + "uuccucccucccucccuuccucuuacucucauucauuucauacacacuggcucacacaucuacucucucucucuaucucucucaga\n", + "gucuuccucccucccucccuuccucuuacucucauucauuucauacacacuggcucacacaucuacucucucucucuaucucucucaga\n", + "accuaccucgccgcggccgcacagauuccccgccugauaccgucccaggaucccapaaaccugacggccagguucccucgugccagcugccpaggcpapag\n", + "ugcccugaaacucuaaucucauugccuggccagaaaaggaaguaaucccuagugucagcagauucagcgguacugguguauaauag\n", + "gaucaccaauauacaacaggaaaaaacaaaagugaaagauuaucaauauagauuauugaguaggaguaaagaagguaaaucaaaaapaaaagagauuacagacacagaaa\n", + "cgcgacacugcapccccggcucugcgcgcugcgcuccggccgcucggcgcpaggacgugcggucgcgccugccucgguggccgcgcp\n", + "ccugagcccucgagcapcggaucggccgcugccugcuuaaagcupccgccaggagugcgaucgccugcggaucugcagcupcaccggccgcaacgcccgccccgcgacggcag\n", + "ggacugaapacuccugaauguccgcpacgugucgcggcggcgcccagcacggaggaggcaggcapag\n", + "ggauucccacccagugccacgugagaacacaggcgugcaucgcagacaagccacacaggccucgcaggcucagcauacaugucugcagcaacaccaucagguacagagccgaggcccag\n", + "ggaauaaaggcucapaccggcaguucuacucuagagcccaccagccucucagagccuccggugacuggccugugucucccccugg\n", + "ugagcccucgagcapcggaucggccgcugccugcuuaaagcupccgccaggagugcgaucgccugcggaucugcagcupcaccggccgcaacgcccgccccgcgacggcag\n", + "ucgagcapcggaucggccgcugccugcuuaaagcupccgccaggagugcgaucgccugcggaucugcagcupcaccggccgcaacgcccgccccgcgacggcag\n", + "ggucagcccugagcccucgagcapcggaucggccgcugccugcuuaaagcupccgccaggagugcgaucgccugcggaucugcagcupcaccggccgcaacgcccgccccgcgacggcag\n", + "aacagagagcggcaggcgagauacaggcgugcaccccggagaggacaggcugaggacccucaacagagacaggaaaaccugcccgucacugagaa\n", + "ugcaaaauuuuuacapaucaguuuuuucuggcguagcaugugguuggcuuuguguauaguuaguucauuuauuaccaggcccauggaagucagacaaaag\n", + "gccagacgcaagacgccpccuacagcpagcgugaggaaagccgugcguugcguuccaaggcaucugugagcccgcggaguauacacc\n", + "gacuuacagaaaauaguggaacagacaugguacuaucaauuauccuuuucauucucuaccuuuaag\n", + "uaucgucguccuccccgcagucaggcugcccaucacccaccauuccagcagguaaagucauuucuccaucacagaagcacagcaagaaggcacuaaagcag\n", + "gcgcuaaagcagcaacagcagaagaagcagcagcagcaaugcaggccaagcauauccaucuccuccaaccagcaucucucacuaaagacugucaaagcagccagugacucuguaccugccaaaccug\n", + "auugaguaaauuguauugaccuguucuuaagcucacugauucuguccucuguugucuccacucucuuacugauuucaucug\n", + "gaccaaaauggcggcugccguuggugcpugcgguuuguagugcuguugcccuacucaucccuuugcaaaaugugaaagaagaagcggcugguggaggcpccauaggca\n", + "gcgcgccccaccgaccaaaauggcggcugccguuggugcpugcgguuuguagugcuguugcccuacucaucccuuugcaaaaugugaaagaagaagcggcugguggaggcpccauaggca\n", + "accgaccaaaauggcggcugccguuggugcpugcgguuuguagugcuguugcccuacucaucccuuugcaaaaugugaaagaagaagcggcugguggaggcpccauaggca\n", + "gcgcgcgccccaccgaccaaaauggcggcugccguuggugcpugcgguuuguagugcuguugcccuacucaucccuuugcaaaaugugaaagaagaagcggcugguggaggcpccauaggca\n", + "acggagucuuacucugucguucagguuggagugcaguggcgcgaccucggcucacugcaacaucugccucccagguucaagcaauucuccugccucaccuuccagaguagcupauuacag\n", + "ggucuuucucugucucucagccucaagccauccuccugcaucagccucccaaguaguupaccauag\n", + "gugugaccuacacaugugacuucaccucaguuuugugauccguaaaauggacaaauucgaagcuacuucacagugcuguugagaggauuaaaugaaacaaugcuuguaaagcucuuugcaggag\n", + "gagagccggcagauppcuuuuagccacggucucuggucugaugaagcagaaaagaagaugaggaucapuccucpaacgcugucacgaau\n", + "auauugaauaagcgacccggccuccuapucgucgugguccagacaguuuagcagaacagccuccgcggcuccpagaag\n", + "agaguuagccgaggccgccauauugaauaagcgacccggccuccuapucgucgugguccagacaguuuagcagaacagccuccgcggcuccpagaag\n", + "caauauguuaaggauaccuguaagaaaggccuuaguaggccuuucuaagucuccuaaaggaugug\n", + "guaucggauauuuggauuapaugcucaaccucuacaguuuuuuaguccuagcupcgccgugacucacaccuguaauuccagcacuuupaggcugag\n", + "cuuauagaaaagucaaaagaaguuacagugaucucccguuauaccuuucaucuagacucacuauuaaugucuggccauguuugguuuucucuauacacgaguguauauag\n", + "ggcaagcaagcuccacauaugcggaacaaacuggaaagcugaccgaauuugugucuaaccuggcgupauuucgcagucaaagaapuuccpuuuucaaagag\n", + "ccucgugcaagccgaauacuggcaugaccccauaaaggaggauguguaucgcaaccacagcaucuucuuggcagauauaaaucaggagcgg\n", + "gcaccccugcccuccugaggucagcugagcgguuaaugcggaagguuaagaaacugcgccuggacaaggagaacaccggaaguuggagaag\n", + "acuuccpucgcagucccpcauggagccgcgaccgugaggcgccgcuggacccpacgaccugcccaguccggccgccgccccacgucccg\n", + "cpcauggagccgcgaccgugaggcgccgcuggacccpacgaccugcccaguccggccgccgccccacgucccg\n", + "ccugcauuccucugcupucccapaaucpcccgupauggcuucucucccagauucuguccapcaugcagacagugcugcapcuucaaggcagagcuagaaucuagccag\n", + "cugccccuggaaggagcuuuuugaaggcuuugaggagaggaapagagugcugauuucagcaggauuugguggapugccuggauccaccuacacugccugacccg\n", + "agaagaggcggcpccgcgcuccggccggucugcggcguuggccuuggcggcggcgguggagaag\n", + "gcagauauccucccuuuccuccucggcugcugcucuuacuuugacaagccaggcuaacauugaag\n", + "ggucgcgcggagauugcupcgguucuugccggaagcggagagcggcugaucgcaguccggaggugaggcggaacucugag\n", + "cuacgcgcgugucaugaacccugccgagapccpcugaggcccucaggccgacccggacucuupcgcggucucuugag\n", + "gagauugcupcgguucuugccggaagcggagagcggcugaucgcaguccggaggugaggcggaacucugag\n", + "auugcupcgguucuugccggaagcggagagcggcugaucgcaguccggaggugaggcggaacucugag\n", + "cuacccccacaaggcgauuuugacccccugapcugcucuagaggacucaggccccgaagcugucccapagguccccgcugcaucccaccacccaagcugugccuc\n", + "cgaguuacugcucauuugauucauauugccaaacugaacucucuuguuuucuugcaagaugaaaggagacaacc\n", + "aaucuuggaaucccaauccgugagguuccupugugcuggcaucaggacagcgguccacgaacg\n", + "aggucugcgguccpaccaacuaggcugcacaggcacgcupcgcauguccgccucgccpcugccag\n", + "gaaagucgcagagcugaagcagaagaucgaggacacgcuauguccuuuuggcuucgagguuuaccccuuccag\n", + "guggcaugguacaaugaacucuugccuccagccuuccaccuaccgcugccaggaccuacccuggccuuccugguacucagcacgccugcc\n", + "auccuagcauuauaucuacagagcagaggcaggaccuuuggcaggagacacaucccuucuccugugaugugucaguuaguguagagaagcaagcuggcauggacuugagagccp\n", + "ggaccuuuggcaggagacacaucccuucuccugugaugugucaguuaguguagagaagcaagcuggcauggacuugagagccp\n", + "gauaucacaaugauaugguuuggcuguguccccucugagaagapcuaccaucuuccaguuaaauuggacuuuaacuagaaguccaauuaaaccucuuuuuguuccuaguuucag\n", + "ccuagcccgccgaaapcpcauugcuaaaguguuuucaaaaggucuucccaauccucugcuuuagacagcucggaccuuagauagaagaacacaacggauccuccagugacugacg\n", + "gagaagaauggapcggagaaucaaucaaaguagcauuuauggcacuugcgucaguuacpuuccucaaapucaagauucuuccgugcuucguugcuaccuaucgucaaa\n", + "agacagcaucucacucugucaccuaggcuggagugcaguggcaugaucacgguucauuggaguugcaacuucccaggcucaagugacccucccgccucagccuccggaguaguugguacuacag\n", + "ugagaauccacauucccagcauccaucaacucugcaacauuuagaauauugacauuaugaacaugugaaacugauguccagaccccaagcugug\n", + "pugguuaggauccuugugcugaagcauacaccpuguuucugugcaguauuuugaggucuuuuucaaccuauuguauuuaaucuguuauuccuuauaacacugacaaucggu\n", + "gguagcuccaagugguaggcaugagaccuggcccagagauacaagaucucccuuggaauuuuccaaaucaaag\n", + "apcpcauugcuaaaguguuuucaaaaggucuucccaauccucugcuuuagacagcucggaccuuagauagaagaacacaacggauccuccagugacugacg\n", + "guaaacgguuguccuccaccccgcuggaaauccuguucuuucugaacpugguauaaugcuaccuauuuccugcuggaacuuuucauauuucuguauaaag\n", + "ggagccgcuguggcagcguaugcugccacpacugaagauggcgccgcgaggugagauuccggag\n", + "guguccugcuaccauauccaacagcuaaccuaguacuggauguggugaugcuccuccuuuaucuuggaauugaaguaauucgccuguuuuuugguaaguguu\n", + "agauuucacuaaaggaaucucauugaaagcaacacuuccuaugaacauccagauuuucuagucagaucuguaaauaucuuacacaacaacagcaaguagaggaaaaauacauuuuucacaccc\n", + "gaagaacugaaaagauugcagaauccucuagaacaaguuaaugauggaaaauauucauuugaaaa\n", + "cuuucaaagccaauuugaauaaacaacucuucccucucaaaupcaagaguaacucuucagcacc\n", + "uugaaagcaacacuuccuaugaacauccagauuuucuagucagaucuguaaauaucuuacacaacaacagcaaguagaggaaaaauacauuuuucacaccc\n", + "ggaguacuugcugcauuugauccucuacaacugguguugcucccguuaugcggacagaagacagccccapaacaaaugcuaggaaauggcagg\n", + "acucucggcccupauuucugcggccgccagcucccgcgaccgccucuccugccccucgccgguaccucagcaaggugcguugccgccag\n", + "acgupcgccggcagcgcgacucucggcccupauuucugcggccgccagcucccgcgaccgccucuccugccccucgccgguaccucagcaaggugcguugccgccag\n", + "gugagcacccccuuguaagcucapcuacuguupugucapaacaaaguuuuagacugcugcgcuccaaagcpcacacac\n", + "agucccuguccugcgcccgcgcgccccpagccuacccagcacgcgcuccgcgcccacugguucccuccagccgccgccguccagccgaguccccacuccggagucgccgcugccgcpac\n", + "gcguccgapagcgcgcgacpccacgcacguccpcguccaguucpcagcuucuccggcuggupupupcagccuuucaggcag\n", + "cuuuccggcaggcuacupcuccgcccacacaccucccggccugguuccuaaacgccagcucggagcaauccccuupcuggagccaaaucccugcugugauuuuaaggaagaccggcag\n", + "guaauagaggacacaucucuuaacupuugcucuaagaacugaugucuaaaccgucucagcauggccuguagaggaggagcupaauggccaccgugccucagcuacacucucucgg\n", + "auccuacugacuucacuccagacccauuuagaaggcaugauaguauaacuauuguuguugucagcagacuuguuuacagaaaag\n", + "ggugcgucuuuupagcuuuagaacacaaggauguuagaaaugucuuaguucaaggacauauuuuucugaauaccucccuuacugaagcauucugc\n", + "aguuccuggagaugcugaggauuagugguagcagcuguuauucuccccauuagaggaaaaacugaaaggagaagaaaauacuu\n", + "agacapucuugcucuguacccaggcuggaguguagugaugugaucauaacucacugcagccucgaccuccuggauucaagugauccuccugccucagccuccugagcaacuggaacuauag\n", + "caggaaacuccagcaccuccuagaacaucuuuuguggaauggcaccucaupcccuuggaucauguaccccuuguauucaacaguaaacaucuuccuauaaucauugcuucauuaacgauaau\n", + "ggccguuguucgagagagaacugcaaguaucuucacccuccgacacacuuaaaaacucaacuagaaauuaauggaaggaacaauuugauucagcaaaaaacugcagcagca\n", + "auuuccgacccpcaagauggcagcggcgcugcgcgugcguuguugaguguucpacgccggccugcaggcgcc\n", + "uccgacccpcaagauggcagcggcgcugcgcgugcguuguugaguguucpacgccggccugcaggcgcc\n", + "agugacucaccuccgccgugcuaacuccucgcuagcucucccucucacacacgcucacacccggcucgag\n", + "gaggaaaauauuuccuaccgguccauagugucagaguggugaaccccugcagccagcaggccuccugaaaaaaaagucc\n", + "cacccauuggaggaaaucucuaacuacagugccuccaggaaacucauugguuauuccagucuuagauaaaauuggugccaggauuugguucgaacuaaugug\n", + "gagugupcgccuccpccucugcggagcccupcagcucugagcucgcggaggcguggccggugcgcpcccgcggcgcgcp\n", + "acugacgcccggcgcgcucuccccccgcggcggcggccgaagcacpaggcggcggcggcggcggcggcccgagcccagcccc\n", + "guucuucacapccugagcucaagaucuaggaauaugagcaauagauaggagagcaagccucacca\n", + "acaaugcacaaagcccaggcuuguucuucacapccugagcucaagaucuaggaauaugagcaauagauaggagagcaagccucacca\n", + "gacuuguggcgcucucagccaccgacagcgccggccucagugccgccucugucccagcccgcgccggcucugccacuuuggcagcguuaaguguggaaucpccuguguccgcpcuuggug\n", + "uaugaaccugcgugcaaacgugcaugacagupaucuugaaugaaugaaaaacuguggauacaag\n", + "auccggccccgguccccguccccuucccuccccccugcccuaagccaccuccaccucuguccuggccgccucapcgcccugaaaggaccaggac\n", + "augcggcaaccguaucucaguucucgcgagguuucgucuucccggaagcguuggaggacauucccuguugacugcgucgcg\n", + "gugagcagcggcggcagcggcaacccaaacagcaauaguaccagcaccagcaccucugccgccaccgcpcaggcuccugupaaaagcaaagaggagaagccag\n", + "guguccuaguggucaaugucacguggaggaacaaaacguacgupaacccuacuggacugcaccaagcacgacupccccucccag\n", + "uuugagagaaagcccagcggagauaaacgaauguccccucaucuccaaagaaaaguucaucggauuuuuauucuagagagcucaucuucagg\n", + "agaagaggaagauuagaagauuuuuuuuuucuuugagagaaagcccagcggagauaaacgaauguccccucaucuccaaagaaaaguucaucggauuuuuauucuagagagcucaucuucagg\n", + "cuagccccaccugcuccguuucccgcccagcuggagcucuggagccuuugcuuccucaaauacgagcpaacugcguugagcgcuggauuccaggccgagugcuggcgaggcgcgca\n", + "ucccgcccagcuggagcucuggagccuuugcuuccucaaauacgagcpaacugcguugagcgcuggauuccaggccgagugcuggcgaggcgcgca\n", + "aggccagccuaccggcgacuaggaugcuuucgcuuucgcucucgcuuuccaauacucpacupaaaccpagaauagaagcag\n", + "cccaggccagccuaccggcgacuaggaugcuuucgcuuucgcucucgcuuuccaauacucpacupaaaccpagaauagaagcag\n", + "cuuugaagauacugcuauaauuugaaaauuugaaauuaguguuucagcugaaccauccguucaucuucaagccauc\n", + "cuggagcucuggagccuuugcuuccucaaauacgagcpaacugcguugagcgcuggauuccaggccgagugcuggcgaggcgcgca\n", + "agcccggcccaggccagccuaccggcgacuaggaugcuuucgcuuucgcucucgcuuuccaauacucpacupaaaccpagaauagaagcaggcaaggaccgccgupcacp\n", + "caggccagccuaccggcgacuaggaugcuuucgcuuucgcucucgcuuuccaauacucpacupaaaccpagaauagaagcaggcaaggaccgccgupcacp\n", + "ggccagccuaccggcgacuaggaugcuuucgcuuucgcucucgcuuuccaauacucpacupaaaccpagaauagaagcag\n", + "aucauapcagaagauacagcagugaacauaacagguaaaacccucccccucugccaapcaggacapaggaaapaagacagagacagguggaauauggaguguucaguguug\n", + "auuugaugugaggugugauuaaagaagaaccaagaaugacuuuaguguuguuggccugagcaacuggaagaacagaguugccauuuauugagaugagaaggcugccagaagaguagag\n", + "ucauaaccuaaugaucccagcaagauaauguccugucuucuaagaugugcaucaagccugguacauacugaaaauccuauaag\n", + "agauacagcagugaacauaacagguaaaacccucccccucugccaapcaggacapaggaaapaagacagagacagguggaauauggaguguucaguguug\n", + "acaaucccuagcuuggagccguccapcaucugcuucuuccacaacccacaacugaggccccagaaaucccagcugcguuupcugagccucuggccucacccaagucagcugagag\n", + "cuuuccapcgcaaggugugugugugcuuuuucuaacgcgaccccgacuucagccgacuuaaccuu\n", + "aguccccacagcugcgccggugacugapccpcaguggagaagugguggcggcpcggcpcggcaaaggagcagccaugapccpcccagucaccgacc\n", + "cacagcugcgccggugacugapccpcaguggagaagugguggcggcpcggcpcggcaaaggagcagccaugapccpcccagucaccgacc\n", + "guaguccccacagcugcgccggugacugapccpcaguggagaagugguggcggcpcggcpcggcaaaggagcagccaugapccpcccagucaccgacc\n", + "ccuagaguugugaggucacaauugcaagugacuuuacgguccccuauugaguuaaagauggagaagaaaaaggccuuugagcaauggcuaaacauuauucag\n", + "acagcugcgccggugacugapccpcaguggagaagugguggcggcpcggcpcggcaaaggagcagccaugapccpcccagucaccgacc\n", + "guuagguauuggagaagaagugauuucauugagauuugucucucugugugaucaaucagcauuugcaucuuu\n", + "auuupauguuucugccuugcuagcagugccagagagaacuucaucauugucaccucaucaaagacuacuuuuucagacaucuccuguapcuagauucagagagcagcuucugauauuuggagg\n", + "aucuuguaaccucguaauauggcucuuaaaaacgcacuaguauucccacuuucugaaguuuguagaagcugcuauauauuucu\n", + "acuuccugauggcucccuaccucauuccucagcgccugucaccugcguacccgcgcccuucucccacpccg\n", + "gacauagaaaacaucagucuugaacuucucuucaagaacccpcugcaaaggaaaucuccuuuguuuuuguuauuuaugugcugucaaguuuugaagug\n", + "uaacccccucuacucaccccccaaaacccagccaaacaacaagcaacaagaggaagccgcaggcgacaagaggaggagugcgcguguupcccccggagag\n", + "aaacccagccaaacaacaagcaacaagaggaagccgcaggcgacaagaggaggagugcgcguguupcccccggagag\n", + "gcagagucugcggacccggcgccgaggcggccacccgagacgcggcgcgcacgcuccggccugcg\n", + "uucaggaaauaagaucguccaauuucuggugacgaagaugacccugauggucaucuaguccaagcauccagaguccacugauaguguug\n", + "gugcguagguccagugagaacaggcgugaaauuuauaucucugcccaggacupugccugcaucgcc\n", + "agugcguagguccagugagaacaggcgugaaauuuauaucucugcccaggacupugccugcaucgcc\n", + "aaaacccuucguguaggapuggcagucucccucccuucuggagacaccaccagaupccagccagaggcagcagcagccucuuccc\n", + "auauccaacuaaggcuucpacauguuuugagcgaagaupuguuucugcccggauaguauaaaucgaggauccaggucupcagauucaacc\n", + "gccgcuuccpcagauaggugccuuuucuugcuccuugcucuuggaguucuucucuuagucccuguucccuggaugaaagcaucgcuccgagccucaupaggaaugaaggaagaaucgagacuag\n", + "cucuuagucccuguucccuggaugaaagcaucgcuccgagccucaupaggaaugaaggaagaaucgagacuag\n", + "ccuugcucuuggaguucuucucuuagucccuguucccuggaugaaagcaucgcuccgagccucaupaggaaugaaggaagaaucgagacuag\n", + "auucagaccucgguugcagcccggugccgugagcugaagagguuucacaucuuacuccgccccacacccupcguugcggcgcupcucguugcugcagccggacccugcucg\n", + "cggugccgugagcugaagagguuucacaucuuacuccgccccacacccupcguugcggcgcupcucguugcugcagccggacccugcucg\n", + "uauaaaagaacguguggaucacuuugcugaguacauccaagauuugaagaacugaaauaaaucagcuuuaaaccugcuuuuuaaaaau\n", + "acaaauggacaccuaccapaacggagauguguaucaagaaaggcuggcacguuuagaaaaugauaaagaaucccucguucuucag\n", + "agacuggcacuuacacuaucagcccuccugcuuaucaagccuucagacucagacuggagcuauacccuupuuuucupucuccagcuugcaguuagcagaucuupacuucucagccuacauaa\n", + "guaaguguguuaacagaccagguggaggcucapagagaagauucgagauuuggaguuuugucuugaagagcacagagagaaggugaaugccacagaagaa\n", + "cggaagugcpcpcgcpcagagcgaaaggcuugaggaccaggucpccpuuccpucpagcggcuccpcggcagcu\n", + "agagcgaaaggcuugaggaccaggucpccpuuccpucpagcggcuccpcggcagcu\n", + "gagaaccggaagugcpcpcgcpcagagcgaaaggcuugaggaccaggucpccpuuccpucpagcggcuccpcggcagcu\n", + "ccggaagugcpcpcgcpcagagcgaaaggcuugaggaccaggucpccpuuccpucpagcggcuccpcggcagcu\n", + "gugucaccucuaacucuucgugucaggaguuuuucuaccucuccggaguucuuuggcucucaggaaccuagcacggcaucacgcgagucccggcucag\n", + "acuaucccaggauucccgacucccgguuuccuguccuucuccccucccagcuccuggcgccugcgauagcggcaag\n", + "ugacuguauuuuuaaauucauugacacccaaauucuauguggcacuuacapaccucuucauugauaucaggacuaauauuu\n", + "cugaagaaaggacuagucugacaggaagaauuacaaaucuggagcucauuuuggcgucgcagapaag\n", + "cguuacaguguuucugccaccucuguacaaaagacaauuuuacuugugugacagaupcucugcuuugucucugucacagagaccacagacaaaguuauacacaacagc\n", + "gcggcggcuapaggupcgaggcgagguuugcupugaggcagcggcgcggccpccpccpccacaggcgguggcggcpacc\n", + "ggcggcuapaggupcgaggcgagguuugcupugaggcagcggcgcggccpccpccpccacaggcgguggcggcpacc\n", + "aauacagguaucuggccucaaggaguuuacaguuucauaggagaaagaaaaacaaaacuagcaauucug\n", + "agauugacagaaaugacuaauacagguaucuggccucaaggaguuuacaguuucauaggagaaagaaaaacaaaacuagcaauucug\n", + "pccggcpagcccggcagccaauggacgcgcguccuccgagcaguuacaaapccggagcgaggccgccgcggcggcuapag\n", + "agaugagacggugacagcccggccagcpcpcpcaggcugcupcpaggupaccpagapuggccgcpcccggccpcupcppccgcagcc\n", + "gaggcccugccuggucucgucupaccupacagcagcupagaccugagccuggagucupccuggaacaggagagcpcguagcucgg\n", + "gcupcpaggupaccpagapuggccgcpcccggccpcupcppccgcagcc\n", + "gcgcagccgcccaccaagcugccagaagacgagccggacgcccaaggcuacgagaggacgauugca\n", + "gaccugcgcaggcgcaaaccugccccupugapcuguaaguggcgcgauucgcggcagcgccccg\n", + "gagacggcggcucacaupccagaaguguuuccccucucccccagcggcuugucuaggaaaacaugaggacucgguucgacucgaug\n", + "aguuuggcuuagagauuaaagcuccuucuaucuugugaugccaccaucgcaagguucucaagguuguugupagaagagaaggcuaaaggagcucauagaaugccuuuaaug\n", + "gagccaggaggcucugagccaguggcgauuggcugacgcgguggcugcgcacucggccugagaaacucggcaagcgcgcagugucgacuccccggucuaugccaggcgcaucucag\n", + "auaccagcauugccaccggupuagaacacuaagupcucuuggagucccugauuccagaacuugacucuuggaugacauuucuggaccugcucupccagagaggagaccacuucccuuaagg\n", + "uuuauuuaucuagaguuggcuuuauuuuagcugcaaaucuuggagcaaaaaccagagacauugccagagcaaacaagaacagaaauacaa\n", + "guggcgauuggcugacgcgguggcugcgcacucggccugagaaacucggcaagcgcgcagugucgacuccccggucuaugccaggcgcaucucag\n", + "cugcaaaucuuggagcaaaaaccagagacauugccagagcaaacaagaacagaaauacaaauggagaacuggucaaaag\n", + "uuugcuacuucgcauaucccuacuugaccuuuuuuggagcaaaugccuuugugaagucuuccuagagucuuccag\n", + "acauaacccacaguuaucuugaacaagaaacuacpauaaauaaaaguacgcagccagaugagcaacugacu\n", + "gguggcugcgcacucggccugagaaacucggcaagcgcgcagugucgacuccccggucuaugccaggcgcaucucag\n", + "gcacucggccugagaaacucggcaagcgcgcagugucgacuccccggucuaugccaggcgcaucucag\n", + "agagucucccucugucccccpcuggagugcaguggcaugaucauagcuuacugcagccucgaacuccuugucugaagcaauccucccaccucagccuccucaguagcuaggaauacag\n", + "gupaucuugcuguauugcccuggcuggccucgaacuccuaggcucaagugauccacccaccuuggcaucucaacgugcug\n", + "ggucggucagagcugacgaugaaguugauguggaugguacaguagaagaggaucupuaaaaguagagaaggaucaaggacggaugaugaaguaguacagag\n", + "agaggaagaagcuauucaguuggauggauuaaaugcaucacaaauaagagaacuuagagagaagucggaaaaguuugccuuccaagccgaaguuaacaga\n", + "agupcggaccgcgcggcuggaggugugaggauccgaacccapuppuggaggcggcuccugcgaucgaapacuugagacucaccggccgcacgcc\n", + "gupcggaccgcgcggcuggaggugugaggauccgaacccapuppuggaggcggcuccugcgaucgaapacuugagacucaccggccgcacgcc\n", + "pcggaccgcgcggcuggaggugugaggauccgaacccapuppuggaggcggcuccugcgaucgaapacuugagacucaccggccgcacgcc\n", + "caccauuccucgaaagapcaapaauuacguuuauucucuucuuccucuggaaauaaaaaaagagagcaacaucaucuaacugcccuacagaucuaauaguaucucgcccggag\n", + "agucguggccccagguaauuuccucccaggccuccaupuuauguauaaaggccccccuagagcupccccaaaacagcccggagccugcagcccagccccacccagaccc\n", + "gcaguuggcccugugguguuccgaagccgguuacguacggccugapccaggcgaaccucaggcucuuuguccuacuaaaaagcgcag\n", + "gaagguucupcugcaaagcugaagcuuugguuucugcucuaaaugaaggacuuuuccaggacccaaggccacacacug\n", + "cgauucacgaguuccccacagaucuguucuccaauaaggagcgacagcacggagccguccugcugcacauccuuggu\n", + "gacgcuggcgcccgcagccgagaagccagagagaaaguucccpagagcucgccccupapccgacgucgagccugcucgccgcgapucucag\n", + "agagagaaaguucccpagagcucgccccupapccgacgucgagccugcucgccgcgapucucag\n", + "guugccaaggcagcggccugagcgcccggcuapcuuuucpaucccgguggccgcaggcgcaccpcaguuccpagccgaccagacacgaaggcugaagccgcgacgccgaagacag\n", + "agauucucgguggcggcggcagcggcggcggcccuggacugcpaaupaauccuaggucccugacugagcaccucccccgccucccugcccccgac\n", + "acuccaggcagccaagucacagccuccpcaccuucaggcaagcpuggupuccagaacucggagaccagaaagugaacuucupcagag\n", + "cauugcuguggcugcuupccacpagapaaccuugugagccpcagaauccacccuguagagacugccucugg\n", + "guaccuuucaacaagucgugaaccuucuggacaucauugacagcgagucagcaaagacggacacaacapcaggccuugac\n", + "aguccupcauggcpcpcapaggcgcgcacagaacaggcupcaucccucgcccuggcucuuugagcccggaccagacag\n", + "cpaacgugcagccgcpugcaggaguccupcauggcpcpcapaggcgcgcacagaacaggcupcaucccucgcccuggcucuuugagcccggaccagacag\n", + "gugcagccgcpugcaggaguccupcauggcpcpcapaggcgcgcacagaacaggcupcaucccucgcccuggcucuuugagcccggaccagacag\n", + "gcpugcaggaguccupcauggcpcpcapaggcgcgcacagaacaggcupcaucccucgcccuggcucuuugagcccggaccagacag\n", + "aauauggauugugcucaguuccguuugaaaauaagcucuaucuagucggcggacaaacuacaaucacagaaugcuaugacccugaacaaaaugaauggagagagauagcuccc\n", + "ggaaccagucagaagcaucuggauuaggcauuuagugauacaaggauccagaauaacaaaaacuauguaccagccacauucacacaacag\n", + "gcuccuugcuauagaagaccupacagaggacugcugucugcccucucuggucacccugccuagcuagaggaucu\n", + "aupcugccccagccapcuguggcugaagaggcucupugcucuuggagguggcugugcauguggucgugg\n", + "agcapaaggcggagagagaacacuuccauuccaguuacaguuccacugaauuggaagcuguaacuaccacuuaggcauuuuuggcuucucauaccacugcaccagcag\n", + "ggcpcgapcggagcpagaapagcugacpcgcccggccggcugcgguccgugcggaggcugagccggccgcpcgcgaccggaggcag\n", + "apcagccugcucgacaaggccccuuggcagacagucagcucccuccaaggccaaaccccaaguucaacauacaucuuucucucccauuucugcaagcauaacugugaacagcauaauucu\n", + "gagaapagcugacpcgcccggccggcugcgguccgugcggaggcugagccggccgcpcgcgaccggaggcag\n", + "accaccggupcgcggcccgagccagucccuaaagccacgaggccgcccgcuccgagccuggugcuuccgaccgcugcgcgcggcuccupcugucacagucucccguugccgccguc\n", + "gcauaucacaccugaaaaauuuuauguggaagcuugugaugauggagcagaugacguacuuaccauugaccguguguccacagagguuacccuugcag\n", + "ucaagaaagauguuccuccuucagcugucacaagaccaauauuugguauacupcacaauccaucugguggcag\n", + "guaauuaucuuauagucauuaccaaaaagauaaaaguaggugaauuuuucagucauguagucuggaaagcaacagauuuugauguccuuucuuauaagaagaca\n", + "agaguuguagccgagguggcggcgcpcpcpcggagagagaaggaaggaggugguugugcagg\n", + "aagaggcupagcugcggccgcugugccapugaccgguagaguuguagccgagguggcggcgcpcpcpcggagagagaaggaaggaggugguugugcagg\n", + "ggaucagucugugguaaagguuuaaggucuucucaggacucuuuucagcaugcaucuugccugguuau\n", + "ccucggccaccuucgaggacuuccagauccgcccgcacgcccucacggugcacuccuaucpcgccugccuucugugaucacugcpag\n", + "aucpcugacccgcgaguucgugcuguugcccgccgccuccgagcuggcucaugugaagcagcuggccuguuccaucguggaccagaag\n", + "acguggacaggacpcuuupccccuggagcagagacuucccucuagagucuuaggaaaacucgacaggauauugapaggcuccagcccucpagu\n", + "acaaugccucapcuagcacgccagccucuupcugaaggaggcugacuccccaaguccugcaaap\n", + "ggcagaguacaguggcacgaucuuggcucacugcaaccuccgccuccupuucaagugauucuucugucucagccucccgaguaccupacuacag\n", + "acaagaccggcguuuguguuccpcgacpauggugguguccgucaggccccccpagcupucguccaggauucuacugaggcccc\n", + "aggcagccgccgcggucccggaccucuagucccgcacucccagcuggcgagccggcuccpugcggcgaggcccagcccucucggauugcgcgccggaccccpacgcgcucc\n", + "ggapagccgcacgcggcccapcagcggucuapcgccpccpcguapccguugcccgcgauggaccgcaccggagacgcuccggacucgucgccgcag\n", + "guguccaccccccapuuccugaccccugccccuggacagcgaccccuucucagacuccaguupccggacucuccaaaccugcuuccgcaaupupuugugagugcug\n", + "cuacagcagagaaucggacaaggapaagaaagagauuggugapagagagagagaaagagagagagagacacaaaggaagugagugcaagaggagccggcuuagcaucuaaacu\n", + "ggaguccacagcauccaccgccggagccucgccuuccuuucucccucugcagacacaacgagacacaaaaagagaggcaaccccuagaccaccgcgaaggacccaucugcacc\n", + "gaapappagcpaggagcggccpccupccuugaggcccpagagccpagccpcccgcgcgccgag\n", + "cucuugguccccaggcugagcccggucggagccugcgaggcaaccggcaagaggucgaguagucuccpugcpccgcgccggcpcucgguccaguccucauggccgccucucacuuag\n", + "gaggucgaguagucuccpugcpccgcgccggcpcucgguccaguccucauggccgccucucacuuag\n", + "agupcgcapcccagcupaagcpcupagaggaggaaccgcpauggaaucpagcgcugaggcggccg\n", + "aaaucacucucccucaacgcucacupcgccggcaggaaagupcguggcpaagacgugacagcagcaacaaccaaggaaaaugaagcaaggucucaacuccpapucagccaaugaaaa\n", + "cucacugauaaccuuguugagccggucguaauccuccucgaugcccacgcuguccaagaucuucuugauguccuuggcgcupaggaguuacccccgapcagccagcag\n", + "aaccuuguguccaaggagguccuucaggagaccupaugaguggugcuuccccaaaacagacuc\n", + "aaccuuguguccaaggagguccuucaggagaccupaugaguggugcuuccccaaaacagacucauggacauuaaacaucaucaga\n", + "agaaccuuguguccaaggagguccuucaggagaccupaugaguggugcuuccccaaaacagacuc\n", + "agaauacggugagaaauuccaggagcacagaagucagcpcaucuccuggagacaggcagacauuuggucucagcagcc\n", + "gcacugupuaggcggcggcggcggcggcuacgcggagcggcaggcgguggagcgaggccgcgcgcgccgaag\n", + "aguguguguaaagaaggaagaauggaguucuaaaaacucagagucuucuuaauccugcuuaagagagguuuaugaugcuaaggacugucaaag\n", + "cccacuggccgguauaaagcaccgugacccucaggugacgcaccapccggcugccgucpacapcuuuccauagcc\n", + "acccacagcacucauuccuggagcuacugcuugguucccugagaggucccagaacucugcaaagugaguccagcgcug\n", + "ccugcggccagcccupcggccauguggacagagcupapccggaaccagaacccaagcgugauccugaaccggagcccgagccugcugcag\n", + "agacacgguucuugcuaugugcucaggcuggucucaaacuccuggccucaagcaguccuuccacuucggccuaccaaagcguuaccagc\n", + "ggaggcpaccugcggccagcccupcggccauguggacagagcupapccggaaccagaacccaagcgugauccugaaccggagcccgagccugcugcag\n", + "uggcggccpccccggcgugagccaagcgcpcugcagccpagaugccccagcccagcggccgcugagcccgacccgacagagccggcccggccgccuccggcccaccugcgagcucggagac\n", + "pcpcuccggugucagcgaccaagccgcagguggcggcgagcgcpcucggcccgagcucaggag\n", + "gagcugccuggaguggagcugagagcucaggucupcucagccaguccagagugcaaaucuacugucccuuccuagcugugugaucuug\n", + "pcpcuccggugucagcgaccaagccgcagguggcggcgagcgcpcucggcccgagcucaggag\n", + "ggcgagaaaaaucauggcuuugagguccuguaccacagcgugaagcapcccaucuccaccaaggagcuggcggacuucauccpagag\n", + "gcpcuccggugucagcgaccaagccgcagguggcggcgagcgcpcucggcccgagcucaggag\n", + "ggapacuuuccccccaccaagcccacacuggcaaugacucuguagcucaaacuugccucucucuucagacaggcacuggacpccugcapucuccacagagaccaucagg\n", + "acacaagccuccaacuuggugcugacggaaguggccucguggcugucuccuggcgccugccccgucagacapccccaucccacucgcuacccuguccg\n", + "aaacuugccucucucuucagacaggcacuggacpccugcapucuccacagagaccaucagg\n", + "ugacggaaguggccucguggcugucuccuggcgccugccccgucagacapccccaucccacucgcuacccuguccg\n", + "aagccuccaacuuggugcugacggaaguggccucguggcugucuccuggcgccugccccgucagacapccccaucccacucgcuacccuguccg\n", + "pcpcpcuccggugucagcgaccaagccgcagguggcggcgagcgcpcucggcccgagcucaggag\n", + "aguggccucguggcugucuccuggcgccugccccgucagacapccccaucccacucgcuacccuguccg\n", + "cgcgccgcagccgcggapapcpcpcuccggugucagcgaccaagccgcagguggcggcgagcgcpcucggcccgagcucaggag\n", + "gcpcpcuccggugucagcgaccaagccgcagguggcggcgagcgcpcucggcccgagcucaggag\n", + "ggaaguggccucguggcugucuccuggcgccugccccgucagacapccccaucccacucgcuacccuguccg\n", + "aaucucacucuuucaaccagguuggagugcagupcaaucuuggcucacuacaaccuccgccucccagguucaagugauucuccugccucauccucccaaguagcupacuacag\n", + "ggucuuacucugucgcccaggcuggagugcaguggcgccaucucagcucacugcaaccuccgccucccagguucaagcgauucuccugucucagccucccaaguagcupauuacag\n", + "cggccagaaggagaaggacgaagcgcuggaggagaagcugaggaacuuaacuuuccggaagcaggucucguacag\n", + "aaucugcaccccuagagcaaauagucucugucgacuguaaagcugaagguuugaaaaggcagugcgagugagcug\n", + "gagaaugccgugaauggagaacaccuguggcuggagaccaacgucucpagaccucugcuaccuuggagaggagaacugccaagucagauuugca\n", + "aaaucagcucucaggaggaagugugcagucuguaaaaucgucguccacaccgccugcauugagcagcuagaaaag\n", + "aauuuuguacgucaucacupugcacaggcgucggcaggapaaauguaagcagugugguaag\n", + "ggcuuccagcaaaaguucuccuuccacaguaaagagauuguggcuaucagcuguuccuggugcaagcaggcg\n", + "ggugcpccggcgcpapcgcpaggcpagcggcggccucugauuggccpcpagugagcggaguuucccacaaugccccggugcggugcagccgcgg\n", + "gugagagucagugagcucucaggagaucugcuguuugaaaguguguagcgcuucccccuucucucucucuguccugcugcacu\n", + "auggccgccgccuggcgccpcuaaguggccgccggcguccpuacccgapcucucccgcguugcuggcaccgcuggcgccgcggucucguagcgc\n", + "agccaggaagaggagcauagaaagaaaaaggaacaggaaauuguucaaaagaaguucaugaaaugagaaaagcagcaggaaacagcucpaaucggcgaggcugcagccgaaggaa\n", + "uucupaggugaucagugaugaacauggcaucgaccccaccggcaccuaccacpacagcgaccugcagcuggaccgcaucucuguguacuacaaugaagccacag\n", + "auucaugugucaaugaagaauuccugccagacuuccaguacuguccucgaccaupcagaaucccagcugccccucccagaacacuccaugccacuggaacucaggagcgcag\n", + "gcauuuucaccupacuguucccupcugccuugugguuugcaucaacuggaagaggcuuuaaggagaccaucucugaguuuccagugupcacag\n", + "gaagcucuguuuggugcuuuggauccauuuccaucgguccuuacagccgcucgucagacuccagcagccaag\n", + "acaaguugugacgauuccaaguucacagaagcccaapauuuugacauuucuccaaggaguuagccagaagagauccucgccgguugaguucag\n", + "guggugaccaucgcuaugugaacaacuacacgaacagcuucpugaguggagugcaccggacacc\n", + "cacucccugccgagacgccugccagaaaggucaccuauccugaaccccagcaagccugaaacagcucagccaagcacccugcg\n", + "acucccugccgagacgccugccagaaaggucaccuauccugaaccccagcaagccugaaacagcucagccaagcacccugcg\n", + "gugugucucuaguccucgugguugccugccccacucccugccgagacgccugccagaaaggucaccuauccugaaccccagcaagccugaaacagcucagccaagcacccugcg\n", + "gugacuucugagauuaucugaaucucacacuuugcugaccucuuuuuggapcauugccuguggccuggcccagagaggaupcagguguuuucugagucacacagcagaccaaguguggagacag\n", + "ggccucuccaaguuuaugcugaugcucucugcacgguuacuaacagaguccuucuacucucaaaagcaugccaauuupugauaaauuaguugauugacuu\n", + "gugaagcuccgcggugccugaupccguupcggccgguagcuguugcuguupacccccucauuccugccgcugccgucccugcugccuc\n", + "gaguucagauucggaucgcagucccgauuauccuccccuccagccucucccuuucucguugaapuuaauacagcguccucuccccucgccacccgacagaggcgccuacacuggcg\n", + "gagcucgccgugcgccguggcupaccggccuggccgagcgcgccggcgccgcggccgcagacaaapcggcucgcgcccpccgccacgcucucpcucugccucg\n", + "gguuaucugucagaapuugguaacaaagugguaccguuccccacgacugcuccuuucccccaauaacuacaccaaagccaucgac\n", + "gugcgccguggcupaccggccuggccgagcgcgccggcgccgcggccgcagacaaapcggcucgcgcccpccgccacgcucucpcucugccucg\n", + "ggaupauuugugaugcaggaaagccuaapaaaaagaauauucauucuguguggugaaaauuuuuugaaaaaaaaauugccuucuucaaacaag\n", + "uagaauaauuuggaupauuugugaugcaggaaagccuaapaaaaagaauauucauucuguguggugaaaauuuuuugaaaaaaaaauugccuucuucaaacaag\n", + "ggugucauucugauauuuaugaggacuguuguucucacuaugaaggcaucuguuauugaaauguuccuug\n", + "uuuugcuggugacuggaguacauucaaacaaagaaacggcaaagaagauuaaaaggcccaaguuca\n", + "aaaguaaacccaaaaapuguaaccuacccaucagcucuuacauacucaucaucgaaaaguccagcugcccaagcag\n", + "guauccaaaggcaagauccuucaggagcugccuuccagaaaccuguuggagcggaugucagccugg\n", + "acugcaaaauugacuugucguuuuuaauugaupagcaccagcauuggcaaacggcgauuccgaauccagaagcagcuccuggcugauguugcccaagcucuugacauuggcccugccgguccacug\n", + "aaaaacaggaagugccuacggaggccpccggcagcggcggccpcaugaagccpcggcuacpaucgcpcggcggcggcaucgcpcggcggcggcg\n", + "gaagaagaaaaauuaauccagcaggaacugaguagucugaaagcgacuguuucugcuccuacuacaacacug\n", + "aaaaaacaggaagugccuacggaggccpccggcagcggcggccpcaugaagccpcggcuacpaucgcpcggcggcggcaucgcpcggcggcggcg\n", + "agugccuacggaggccpccggcagcggcggccpcaugaagccpcggcuacpaucgcpcggcggcggcaucgcpcggcggcggcg\n", + "cugcggagcccggcggagcccpcggcccgcggacgccaggagccuccucpcagcgagauugcuuuuuuuccg\n", + "ggagcapacagguccaagacaaggaaggcaguupcugupaaupagcccapaaggccuccagagcugg\n", + "ccggccuccagccuggcuggacccugcugccuguguggcccggagccagaggcccccacacucccagcugcucuucuacagaugccaucaacgagcaggacucupuggcuccacugucuaag\n", + "gucuuggcaacaggagguggagaggagaugcgccgapauggagguguaugucaccgaggaggcugcugcgcuccugccccacgcccupcccuugaag\n", + "guugccugguugugagagucapagcapacagguccaagacaaggaaggcaguupcugupaaupagcccapaaggccuccagagcugg\n", + "agguugucuuggcaacaggagguggagaggagaugcgccgapauggagguguaugucaccgaggaggcugcugcgcuccugccccacgcccupcccuugaag\n", + "pauggagguguaugucaccgaggaggcugcugcgcuccugccccacgcccupcccuugaag\n", + "acagaaagccgagaggcupcugaggccpcugguuguggagcgauggcuggaguggcuccuccuccaaggcugugccccuuucugccacauugaag\n", + "gagaugcgccgapauggagguguaugucaccgaggaggcugcugcgcuccugccccacgcccupcccuugaag\n", + "cccgcuuccaagauggcggcagcgaugccugcccggcuguupuggcggugacgacaggcagcaaaagaccag\n", + "auaaugccucacaucucuguccccccpacccccuggagcccccaugaucccuaagaagacagcuugaaccuag\n", + "ccccgcagcgcccgcuuccaagauggcggcagcgaugccugcccggcuguupuggcggugacgacaggcagcaaaagaccag\n", + "gaacgagupaacguagcuggucgcagapcaccagcggcugcaggacuucaccaapacccugaggcucgugagcag\n", + "ggacccgcggugcpuuaugcupcucagaucaccguagacaacuggacacucaggaccacgcc\n", + "agaacgagupaacguagcuggucgcagapcaccagcggcugcaggacuucaccaapacccugaggcucgugagcag\n", + "pcucuguuggcggcggcgcuagcuucggagucucccgcgcgcaccucagccgccuccuagcggcgcggcgcucgcuccuacg\n", + "upaaauaaagucauuuguauguuuuucucucuugcacagccuaaaaugaccaaugugugauuucaguggaauaa\n", + "aaguaaccagagugcuaugucugcaugcuguucagucuccuuuuggaaggupaaauaaagucauuuguauguuuuucucucuugcacagccuaaaaugaccaaugugugauuucaguggaauaa\n", + "ggcggcgcuagcuucggagucucccgcgcgcaccucagccgccuccuagcggcgcggcgcucgcuccuacg\n", + "paguccgcggcgagcgcagcagcapccpuccugcgccucpucggcguccaggcucggagcgcggcacggagacggcggcagcgcuggacuagguggcag\n", + "puugugguuggugugcpuuucgguuggaggacucguupagguggccugcgcuuguagagacugcauccccgagacg\n", + "guugugguuggugugcpuuucgguuggaggacucguupagguggccugcgcuuguagagacugcauccccgagacg\n", + "ccucpuugugguuggugugcpuuucgguuggaggacucguupagguggccugcgcuuguagagacugcauccccgagacg\n", + "ggcaggaaccgaaacccggagcggccgaagcucagcgcuccgcupcagapucgcggcggcupaacgccgcuccccgacgcaccggccgcccccagcgcagcgcgcuccgcpugcug\n", + "aucugccucuucuccaagaaacucaaccacuagugacaaugaccagccuccugacuacuccuucuccaagag\n", + "cuugcuacuucaucauccucaucgugaacauuauuauuauuaucaucauuuuccagaugaagaaaaugaaucacaagucaacugacaguccaaaggcuccacagcucagaggag\n", + "guuugauauuugacaaauugaucuaaaauggcupuuuuuaucugaauaacucacugaugccaucccagaaagucggcaccag\n", + "cacugaacuaaagaaccagaaaauagapuguauuagugaacuacagaaaauucaagucccaaaagcuguaaauacucugaggaccaaagaaaauauauacguuguucagauuugcccugap\n", + "agcgagaccccgucucuccagaaaaagaaaaaaagagagagagagagagaaauuagccpcgugguggcguacgcuuguagucccaucuacuuaggaggcugag\n", + "aggccucucaauccucccuccaugaucuucgcauagagcacaguaccccuucacacggaggacgcg\n", + "guaguccccgccuuguuucuccccagaggccucucaauccucccuccaugaucuucgcauagagcacaguaccccuucacacggaggacgcg\n", + "cccgaggcugauggcuccggaaacaccaauucgcugucuccacgcaugaggagacguguapccpuucggcccuggugaacucucacccgagcgguuucucuuuccpacaac\n", + "gagaaaccagugaaaacuaacuuucaugagaaugaaaaggaagaggaaucuguccgagaaacaagccuugaggucuuaaaaacccuggacccacuggucauugga\n", + "aaaagaaagcuggauugccuuaccaaaucuccagguuuuucguuauaccucuucacucaggcucugcccagaacucaag\n", + "gaguccccpccccaggcugcagacugguaccugucgagagcuguuaggaacupcuucacggcaguag\n", + "acaauagccaugugugucaggcagugagcugaccagcaaguccuuugugagucuuggaaugcauuuuccaupupuggugag\n", + "augacauagacacuagguuuuuacagcaauucucugaugaccuugauaugguagaacgcuguguauuucaagaguaagcucucguuugaggagacuaacaauuccuguuuucgccag\n", + "auuucuucuugaauggcaaccuaaaugccaguccaaagaggcccccaauagacuuguucacccuuc\n", + "papcggauccaggucuggagucuuuggauugaaagguuggagaugccugupacucccaag\n", + "gcupuacuuccaguggaaagugugacaggcpccuucucccauuagugugcgagaauggcuggcgcugcugccucaucaacapaccggaag\n", + "auggccaaucuuuccuaagcugcucaccuuacaagaaaacgaaucguacugcuaagaauucaaacuucagcagucaugg\n", + "ggagccuuggaaggagcccgaaucacugauggaauuggacagugcauggagaugguucagcaggacaagg\n", + "ugucauuggaggacaguguggagugcagagagacaugcuuugaaaupauugauccaguccuccuuccuucacuaccacaugaaugcupcagcccapucaacccaccgcacccucaacucag\n", + "gaaugccuggacacaguagacaaaaguuguucaacuggacgccuuaggauacacgcuaccaaaaacaaaguagccaaaaaggaaccagaauaacagaauaucagagccagaggaacauuuggag\n", + "uucupaagucaucagugaugagcauggcaucgaccccagcggcaacuacgupcgacucggacuugcagcuggagcggaucagcgucuacuacaacgaggccucuu\n", + "agacagagucucgcucuugucacucaggcuggagugcaguguugcaaucacagcuuacugcagccucaagcuccuggacaapauccucccgcuucagccucccaaguagcupacuaag\n", + "gacugaaauccuuguuuucuugcuggcuguuggcugaggacuacucuguuuccagaaggauccucagauccuugccacgugaccccuuuuauag\n", + "gcaacauucacauauccuggacugugacacaucagcauuuguuucccuuagccagcccaaacaaguacaaauug\n", + "auauacuuuaauuucuaaauggauuuaaaaugaauaguauggaucugaaguccgucuauacagcaggaaauag\n", + "gacagccapuuagauguucugaggaggcpagcaaccgagagagcacgugagcaucuguccuuucuacccguuccucuuuaucuuuaguguucaguagcagcpauagcccpcccggugu\n", + "guugcgcaguagugcuagcggcuucgcgguucgguccucgcacccggcagccgccacuggugcugagcugcuaggaagccccuaucgccgagcucguuggagcuugaacccauugucaccccuccg\n", + "uccaggaguucccaccaguaggagcucccacccaaaagaaupucacuggcagcuuuugaaccagcupcacuggcuggagaggcugg\n", + "guccaugcuggcagcaaggcugcauuggcugcccugugcccaggagaccugauccaggccaucaauggugagagcacagagcuc\n", + "gagaagccgcagucucgagagcgucaacgagguguuucgguagucucuggccauccuuucugcgcacccggugucgcupcugcaccccpcpacguccgccpcacpapccaag\n", + "gcuccuugaaaacuccgugugcuccpcucuccugcaauuccuuucauucccaaagugcuggagccaagcacgcguccccc\n", + "caaacaucccuggcgauaccuuggaaaggacgaaguuggucugcagucgcaauuucgupuugaguucacaguugugagugcpcucggag\n", + "aaaagccagcucgcccpcggcggcgcagagccpccggcgcacgaggcagccagcgcggcc\n", + "ggugccaccuuucggccggaggaucpcgcpaggagagcpugugupagccguggccpcucggcccpccgcuggccg\n", + "ggcuupcaggaaccuguuguuucaggagccaguaaccuuugaggauguggcuguguacuucacccagaauga\n", + "cuccgcagguucuuacuuuuucaaaccuagapcagugcaugaagccapucaucagccaugcuccagacagugugguuccag\n", + "aggcuugaaaaagaggucaggccccaggagcupcuggagcagugaggaguguuucuuccaagagaagaugacugccugagag\n", + "gucgugucggcgccaccccggcccccgagcccgcagauugcccaccgaagcucgugugugcacccccgaucccgccagccacucgccccuggccucgcpccgugucuccggcauc\n", + "gaagcaguugagugcugcagcggcagucgucgccccugccgccgcugccaccgaaggaagcaucccagacaccpaag\n", + "agacapuuucaccaugcuguccaggcuggucucgaacuccugaucucaaguguuccgcucgccucggccucccaaagugcupauuacaggcgugagccaccgg\n", + "cggauucgugaagcaguugagugcugcagcggcagucgucgccccugccgccgcugccaccgaaggaagcaucccagacaccpaag\n", + "cccagagcccggauucgugaagcaguugagugcugcagcggcagucgucgccccugccgccgcugccaccgaaggaagcaucccagacaccpaag\n", + "ugcauuccaagcccupucuaccuuggagacaggacagcacagacuuacucuccacaaapacuucupuc\n", + "gugacgugucccgcgcuuggcgcagcaggaagcggcggcgaacgcggccugaauucccggcgccggccccagcuccucugccgcugccgcc\n", + "paggcpaaacagcuuagupugupucgcgcauuuucuucaaccaggaggugaggagguuucgac\n", + "aagcugauupuguggucgccguggccggacgccgcucpacgupapaggcpaaacagcuuagupugupucgcgcauuuucuucaaccaggag\n", + "ccgagccpagccgagcgcgcupcgcggccgucccgcugccgccgccaagcccggagugcgccagcggccaugguucccgcggcggcgccpcgccugagccccpacgca\n", + "guggugguuuccuggcugcgcgcggcgguggcggagccgcuacggcuguagcagcagccgcgaag\n", + "cuaguugguugagucagaaccuggaguuaguuugguapugugguuucagguuugcagacauccccgguugaugccuaugaapuuggugccugauguaacugaauapugcuacuucag\n", + "auacagaccccgaugagcagagccuugugagapaggaggacggcaacacacgaagaacugagacagaugacupcuucuag\n", + "aaacgcuupuaaaauaucuuuaggccgagugcaguggcucaugccuguaaucccagcacuuupaggccgaggcagguggaucacuugag\n", + "gagccuuuuguggcagaugaauauauugaacgucuuguauggagaaccccaggaggaggcucuagagguggaccugaagcuuuugauccuaaaag\n", + "uaaagauggcagguuuggcgcucuagguggcagagaaaccaccaggaaggcuuggugaaupagaaag\n", + "auauuucugaauggagaaauggaapaaaguggagaauggaugguccagguuuccauugcuuccaaugaggugucauauccca\n", + "aaauguuuuucuuucapugaaaccgcagcaauauaagagcauuauuauuauuuuuuucccgcugucuuucuucuuuucuucuccucuuucuuaggcauauuugaauguauuccgcagg\n", + "pagagaggcgagacgagugcucuccccacacguguaacccugcaucucccaguuucagagcuugcguucauucauaugcaggcagugguuuaauauuugaucaaag\n", + "agacucgcgcuggcuccagucucuccacgauucucucucccagacuuuuccccggucuuaagagauccuguguccagapccuuag\n", + "aguggacgcuggugaaaugcccucuuguguapucucucccauucugaacacgaaaacucaacuuagucuuugauauggauggcaupaug\n", + "gagucccuggcpcgcggcgguggaaggugucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "gguggaaggugucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "pcgcggcgguggaaggugucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "guggcugagucccuggcpcgcggcgguggaaggugucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "gucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "guuccpcaccuacucgcgucuaaucacuccccucauucacucuuuapuccauuggcuguuucuuugaggaagcggagcaucuucugucguugauugguuuccgucauuguugauag\n", + "uggcugagucccuggcpcgcggcgguggaaggugucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "agucccuggcpcgcggcgguggaaggugucgcguacpcuucccgagcugacguggcuugaauupappcagcuggagccucaggcggcagcgcuucuag\n", + "acccaccugcuuggcccccacuucugaugcccgccugcucugccuggcccggaggaggaccccagcugcgccapaggaap\n", + "gccggcugugguggcucaugccuguaauccagugcugupaggccgaggupaggauugcucaaguccaaguguuugaggccagucupcagcauagugagaccacaucucuacaaaa\n", + "cggccccuaccccugaguccccpucccggccgccaggccggagcgcgaaugucgugcucacccugccuccuucccgccgcccccup\n", + "augauuauaagcuuccugaggccucccuagaagcugagcagauggcagaaccaugcuuccuguaaauccugcagaauc\n", + "aagaaggaacugagucucuaagauggaggauauacaacugacaaguaguaaagucaagauacacagccag\n", + "acagugucucagucuggcauccaacucaggcuggagugcagugacaugaucuuggcucacugcagucuugaccuccupcucaagcaauccuccugccucagcuuccugaguag\n", + "gguuuggauucaggauuuguuccuaguguccaagauuuugauaagaaacuuacagaagcugaugcuuaccuacaaaucuugauugaacaauuaaag\n", + "agaupauucugcuauguugccuaggcuggucuccuagccucaagcgauccuccuuccuuggccuaccaaagcagupauuacag\n", + "aucaaggugaaacuccpaccaggcuccacagcugccauaaacuggauggcacguuagaagccggupuguag\n", + "cpaucpucgapagaagaaaaapugcucpagcagcccccggcuaccuccccuggaggcacagapcpccuuggcga\n", + "ggacgcccucccgccgcugcgcaccccucccgcgagcugccagcucccucggccucuccacccaaaacuggcccaaccgccaaucgucugccucucaccuccuacagcag\n", + "auuuggagcauuuccuucccugacagccggaccupacupcupcccuggcggauggagac\n", + "gcaaagcugcagcgucuggaaaaaagcgacuuguggcggucgagcguggcgcaggcgaauccucggcacuaagcaaau\n", + "gugcuuucugccguacgucccuucccaugaggaugagaugacccaucuguugcaucccggcugcugauaaaacaagacccucggagccaagaaacaacacugag\n", + "ggccggcccacupuugugcuuucugccguacgucccuucccaugaggaugagaugacccaucuguugcaucccggcugcugauaaaacaagacccucggagccaagaaacaacacugag\n", + "cuuucuupuaggupcccuucccugccuuucucuucuagcuuupaucucaggaggaggagaacccaagaaacuguggaaugaugugag\n", + "agcguuugucucguuaauggagaacacagucacaggaucaaaapcuaauuucaggauaauucuccugaaauccugcuaauuucaggauaauucacugcuuccagaauuuuagaguacugguaaag\n", + "aaugaagugaucagccagcagcugugcgucaucuucacacacugcuacpcccuaccccauccccaagcucacagaaaucaaacggaaacagaccucgcgcuugg\n", + "cggcugccgcggagccccggcgcpcggcuucgccpagcgaggcucggagccaggaggcggcgccgcupapagcgcggagugcggagugcggagcgcpccuggccgcccgccug\n", + "agagaagcggugagauaccacgaagcguugcccagcupcgccapccgccacgaccgccccuuuucggaggcucggcgaggagaccugccugcpagagaccccpagcag\n", + "gaccuuccuccucaaaagcugcugaacaacugagucccugcccaccaaggccacccgaagccaggupcc\n", + "cgcucaaaacucggugaucauaguugauaagaacgguagacuuguuuaccugguggagaauccupuuauguggcguauaguaaggcugcaacaguuacu\n", + "gguaaacugguccaugcuaauuuugguacuaaaaaagauuuugaggauuuauacacuccugugaauggaucuauagugauugucagagcapaaaaucaccuuugcagaaaag\n", + "cuccggcugaucgcugccgcuccgccaauacaauagagccagccacuaccagcagccuggcccucuuccuccuucuccagagagaccaauccagccgaacucpuuugcc\n", + "ucgauucaaagcuucggcaagacgaagaaaaccgagccugaaagcapcgagaaaapcgcugcapcggauggaaagaauugauugguaacg\n", + "cucccucugccuuccuuccccacggccggccgccuccucgcccgcccgcccgcagccgaggagccgaggccgccgcggccguggcggcggagcccucagcc\n", + "aaaugauccuagauaauugauagauccugugguucaacuggauuucuagauagaagcuggauucaugugaugccagag\n", + "gaguaaaauuucaagagacugaaaccagaucugaguuucgcuguuccagucuggaccucuuuggugcuguaaauccuggauauacuguagaugaguacugcguuuuucuuuuaug\n", + "aaugaaaggcuuaagaaacuuuguacugaucuagaagagaaacaugaagcaucagagauucaaauaaagcagcaaucuacaaguuaccgaaaucaacuucaacaaaaagag\n", + "guuugacugauauuacaaaggauccagacuuuaaugaaaucuaugaugaagacgugaaugaagauccaacauaugaucccaacagcccugaagaaacagcuguauuu\n", + "agauuacugcagcauuugugcugaaacucaccapuuaaauugaugagcuuucugcgugaaagaapagugguggugauuuccggagcuuguagccagg\n", + "aaauugcuuaaaagauaauuauguuauauaaagugaucaaugaaaacaaacgucaucuucauuuuuuaaag\n", + "gcgccuccuccuccuccugcuccccgccgcuuccguuucucgapaaaggcugcugccuccugcucuguccucauccccggcuuag\n", + "gupccauaaaacaugaaggaaccaguaagccaggccaguggaaacauucuagaguugaaaauccucuauggaacaagcuuaccuac\n", + "auugcaaauaagaaaauuccagauuccauuccaagauggccaaauaggaacagcuccagccugcagcucccagcgugauuaauguagaagaupugauuucugcauuuccaacuaag\n", + "agaagcgacgcuccgcccaccccgacgcggucucuaugguaaccggucaccgcuucuauggaguggcguuuacuacca\n", + "guuucuggccgagcugauguggccguggcacagcucagaagcgacgcuccgcccaccccgacgcggucucuaugguaaccggucaccgcuucuauggaguggcguuuacuacca\n", + "cauugacuuccaaagacuccuggcacaugaggaagaaacccagaagaggagagcaaaggagucagga\n", + "cauugacuuccaaagacuccuggcacaugaggaagaaacccagaagaggagagcaaaggagucaggaauggcuuuuacucag\n", + "guguccaaaagugacuuccugacucccuagaugcauuccccugcaguccugcacaucucagaugagcpaccauguauuucgupacuuucaaauauauaagauuuuacauu\n", + "ugaaggugacggcgucgagcgugagugacccucuguguagauuaaaccugcgcucccuguuucccauuuccacagccgauguccapucgauacggcccuuaaaauccccguacacuccaccccag\n", + "agcagagccuaagucacaguagcccugacuacagcauuccuggagcccaggcucuuuuccacagaggaggaaagagcaggcagcagagacc\n", + "agacaagucucuguguucaaagagcuuacacucuugcagagaugaagauagacacccaaagagaucuagaaugugaguucagguguugacaagagcccuggapaacagagcagaaaaag\n", + "agagccuaagucacaguagcccugacuacagcauuccuggagcccaggcucuuuuccacagaggaggaaagagcaggcagcagagacc\n", + "aaaggcguuagaagucaccaccgacccagccccucaacagcaaguugguucuucagcauuaagauccaggugucagccuaugucuuuauauugucaag\n", + "gcuupuuccucaaggcggcgcuuuggccuagcgcgcggugugcuccucaccaggucucuccccucucccaccuucuuucccgucagguccuguc\n", + "ccucccagagcugccggacgcucgcpucucggaacgcaucccgccgcpcuucggccguggcaupcgccgcpccugcucpuuuucuuggcucucgucgcaccpuccucg\n", + "gugugcuuugaacauauauaugccacucuucucugucuucuggaaugcagaccaaagauguuaaauugauuca\n", + "acucaacacacaagcagcgagcccuauggcaaaauccacguggugaagaaugaagcuuccagccaaaggcug\n", + "agcugcuugcugcuccagccuugcccucccagagcugccggacgcucgcpucucggaacgcaucccgccgcpcuucggccguggc\n", + "aaggagcgaaggagcgaaggagcaagcggagcggccgucgcccaagccaagccgcgcugccaacccucccgcccgcccgcgcuccuguccgccgugucuagcagcpcccagc\n", + "gugacggaaguaccgccuccucccguuugacgccccucapacccugcaucgcuccagccgccgcggcc\n", + "aguggcguccagugacgcccagugacguccggugaaauccaagauggcggcgcuaggcugacccuccugcuggugapcucuggcgccppacpauccagcag\n", + "auggcpaggaggaggagaaggcggcggcggaccgagcugcgcucugucaguaccauuugagccauucgcuuccugacaaggcccguggcgapagaggagcugaapccgupaucag\n", + "aaaaccagguacuggcugaaccucaguuugcgucuucgcuccgccgccuucuggaguccuuucugccccuagaggacgcag\n", + "gcacuccaggaauaggaacuacaaagcugaauuugcaucaugccgacuggaggcuguaccauuggaguuupacuaucacccucugaaacccauaacu\n", + "gucacagagucaaagacaaagaaagugaaccggaaaggaagcacuucuuccacguccuccuccuccuccagcuccgugguggacccgcugagcagcguccucg\n", + "agaggcaguggcuaagaaugucggccgcapccagagugccupuugaauucuaacucuuacauuugcuugcugugugccuugg\n", + "aucacuuuucuccagagaaugcaaaugacacggccaaggaaacaugccuaaauugguuuuucaagauugccuccaucapaacucauuccaagauu\n", + "cccgcgcccuagagccugccaaggcgccgccggucpccggcapcgcaaggcaccapauccccucgccgccggacac\n", + "guagugcagugacguuaaguguccgagaaggcuccuguggcuguugaagugucgcggaccugagcupapucggcacgcugcccucagccucg\n", + "caccucuuuucccuuuauccaagcagagccucggcgugcccccaggaccgguaaaguuccucucgccagccgcaucc\n", + "aagccccugcapagcpcccpcggcgcgcgaucgaggucpucgccguccagccugcagc\n", + "pccuguuggacccgcccccggcccacaagccccugcapagcpcccpcggcgcgcgaucgaggucpucgccguccagccugcagc\n", + "guuupcaauuaugaauaaggcugcuguauacauccgugugcaggauuuuguguggacauaaguuuucaacuccuuugguuaaauccuaag\n", + "aacagcauaagaauuauuucugaguggaggugaggcuuguccaaaugucuuugcuaucauggauuuccugacuccuaccuguuugag\n", + "gacacacugcuggccuguggaaacucauggaacuguuccuccagauuaacacuucapuuauggaagcuggaggaagcugagcuuuuacuacaucuuuup\n", + "gcagauacugcucaguuccuagugugaaccgucuugcuuuucagaacagcauaagaauuauuucugaguggag\n", + "guggaaacucauggaacuguuccuccagauuaacacuucapuuauggaagcuggaggaagcugagcuuuuacuacaucuuuup\n", + "acccccaggcuguggugapucugagagcugguaccacggagccupcaaccuccuccgcccaccc\n", + "paagugccgccgaggcgccugcgcacugcgcccccgcgcccccuccccgacugucpccggaccuuggagcgcgcpccggcggcggcgcgaguggcucpagcgcggcug\n", + "aauuuuuucpugccgcagcggcgaccccucggcgccgaugucccugaucccuggagcgacgacggccgcugccuaagcuggaaa\n", + "pcpcagccgcgccgccgcggcacuuuuuuaauuuuuucpugccgcagcggcgaccccucggcgccgaugucccugaucccuggagcgacgacggccgcugccuaagcuggaaa\n", + "gccgccgcggcacuuuuuuaauuuuuucpugccgcagcggcgaccccucggcgccgaugucccugaucccuggagcgacgacggccgcugccuaagcuggaaa\n", + "uuuuucpugccgcagcggcgaccccucggcgccgaugucccugaucccuggagcgacgacggccgcugccuaagcuggaaa\n", + "guccuuuuaagucaguaaauugaacuaagucgguuauucggcaagcaguuccuauaaaaaacuacauggcuaag\n", + "guccccacacugaagaagccacuaccuccaccaccaccagcaccaccacguccagugcugcuggcaaccacupcagccaagcgcuccacccucucucccacc\n", + "acaguuaacacaaccuggaguagcccaugccauacuguguccuuuuaagucaguaaauugaacuaagucgguuauucggcaagcaguuccuauaaaaaacuacauggcuaag\n", + "cucguacaguccuucaucuucauggcagaaaggcuguucugccccugcgcccucccuggccucucupaucccugcagcug\n", + "ggcacaaacuuuccucccpacggaacacgcugccucapagcccgcgaccgcgccuucuccuccgccggucccauacg\n", + "gaggugcuggacguguaggagcagacaugccgcgcgcuccgaggaagcgccggaaccaccagaagcacapacgcpugccgagaguccccagcacugaaaacpaucuccucuucu\n", + "caggucpccpcccggccgcuuccgcgagcgcccugcagacugapagagagagagaaagaggapaggaggaggaggauucapaauaggagcupagcccuucugcgccacag\n", + "gapagccugcgagcaaacgagguggaaacuggagugcacaagugcuggaaupcugucugccuuccaccccucacpapagcgcgcag\n", + "agaupucucacucugucauccaggcuggaauauaguggcacaaucauagcccauuguagccuccaucucaaggacucapauccucccuucuaggccucccaaguagcupauuacag\n", + "ugauaucaguaucaagauaaaaguuuggaaupagaaaaauucucaaagccugaaagaaaaucu\n", + "cpcccggccgcuuccgcgagcgcccugcagacugapagagagagagaaagaggapaggaggaggaggauucapaauaggagcupagcccuucugcgccacag\n", + "uuuuggaguccagaacauguaaaguuuuuucacccauuauaaacaauuuggacaaaauacugcauguucuacuuaaaauupagcuaagcagugg\n", + "uagagaupcuucaccauguugaccaggcuggucuugaacuccuuaccucaggugaucucccaggcuuggccuuccaaggauuugugcacauauaaacuucuguccau\n", + "gagaugcuuggaguguaaagaucccauggucacauaaauccggaaagcacugaauacuuuguuucccauaagagaaucccauuauauguugauguauuaaaagaccugagaaccuggu\n", + "gagcgcccugcagacugapagagagagagaaagaggapaggaggaggaggauucapaauaggagcupagcccuucugcgccacag\n", + "acuuguguuuggagaacucuauuguacugagccuaagucauuuuugaucuauaacaagaacaugcauuuucacaugucaaccggauuuguggaccaguaaaguucucccacaag\n", + "gucpccpcccggccgcuuccgcgagcgcccugcagacugapagagagagagaaagaggapaggaggaggaggauucapaauaggagcupagcccuucugcgccacag\n", + "cagugauaucaguaucaagauaaaaguuuggaaupagaaaaauucucaaagccugaaagaaaaucu\n", + "uuucaggucpccpcccggccgcuuccgcgagcgcccugcagacugapagagagagagaaagaggapaggaggaggaggauucapaauaggagcupagcccuucugcgccacag\n", + "accucauuguacauacaaaauuacaaucaugaauguaaaggaaagcacacuggaacugcuugcagcugacugcgaccuugagucucagcuucugcaucugugaaaugaagauacuggucug\n", + "agaggugcaguaccagagguggcgugcugccgauuucgcguuugccuugcuggaugauuccgcuuguuugccggcugcgugagugcuuagagcuuuucgguggaag\n", + "aguaccagagguggcgugcugccgauuucgcguuugccuugcuggaugauuccgcuuguuugccggcugcgugagugcuuagagcuuuucgguggaag\n", + "guugcccuccuguccgucagaggugcaguaccagagguggcgugcugccgauuucgcguuugccuugcuggaugauuccgcuuguuugccggcugcgugagugcuuagagcuuuucgguggaag\n", + "ccagagguggcgugcugccgauuucgcguuugccuugcuggaugauuccgcuuguuugccggcugcgugagugcuuagagcuuuucgguggaag\n", + "aauucauaaauucuuggccagagugugcccaucaacapuuacacuugccaccuccuuaaaucccagcucaaugcauucuccaugcuccuggcuauucag\n", + "aauuucgcucuugucauccaggcuggagugcaauggcgugaucucggcucacugcaaccuccaccucccag\n", + "gccuguggcagccgcgacccccpcgcuccggagcccacugcgcggcgcgcgugccggcugccugc\n", + "ggaguguugacauuuapauguggccauagaauucucucuggaggaguggcaaugccuggacaccgcacagcagaauuuauauaggaaugug\n", + "ugguaccuugagaggcucaggccagcaggaaaaucaagcugugccaauupcaaaacccagcaauuccuc\n", + "augcgcpcpagugagcgaaauucaagcuccaaacucuaagcuccaagcuccaagcuccaagcuccaagcuccaaacucccgccpuaacuggaacccaauccgapuc\n", + "ggucuugcugugucgcccagacuggaauucaguggccugaucauaguucacugcagccucgaacuccupcucaagcaguccuccugccccagccucccuaguagcupacuuaag\n", + "gagccaggaggcggaaguucccgcpcggupacggcgcccucaccgcgagucacuugucagcccuugucugaggcggaggcagccccgcgccgcgccggacccgag\n", + "gacggcgcccucaccgcgagucacuugucagcccuugucugaggcggaggcagccccgcgccgcgccggacccgag\n", + "guugaagaaguacgagaagaccaacuggauaguaauuuccagaugcaaucagaaaauuucuguucuuauaucuucacccaugcaaagaccaagacccugagagapaauccuugucacuggaaacc\n", + "uucugagagaggagagucaaacucccaccuccagcucucgaaggagcuuuuccugapcacugcaaagaggcuccuuuucuuucagaucagcaguaucag\n", + "aauagcacacagugaagacagucagugagaaccagagcuauuguuacaacugacagcagccagcucaggaggcagaggacgagagcgaucpcugcacacac\n", + "gaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "paacuacucgacccacagagccgaucgcggagcggauucugcuuuuaggaguacccgccaacaagcpaccgagcaggaauccguaucupaacag\n", + "ugupagagcpaacuacucgacccacagagccgaucgcggagcggauucugcuuuuaggaguacccgccaacaagcpaccgagcaggaauccguaucupaacag\n", + "cgaucgcggagcggauucugcuuuuaggaguacccgccaacaagcpaccgagcaggaauccguaucupaacag\n", + "ggaacaggugagagaggaugugugcupccuuggaggaapccgagaccpccuuacuucuguaacgauacugugaggcaucggaaggccagccuguuguguccguuuugaag\n", + "gagaggaugugugcupccuuggaggaapccgagaccpccuuacuucuguaacgauacugugaggcaucggaaggccagccuguuguguccguuuugaag\n", + "ggacupagccggagccpcpaaccggagcuggagccgaagcuggagccggcacugcggcgcacggagcggagcgcugcagccaagccga\n", + "gugaguggapccuucccugcgagaagucagagcugugcccgupcaggcuggcuccgcuguucugcuccaaggauuac\n", + "cucuucuccggcaggaucgcggccgagcagucugcccagagacuuagcgacagacagacgcupacccacgacgacagaaggcgccg\n", + "guucuugaguccugaauucauuccucgaapaagaacagauccucugaaauuucaaauagaaagaaaagau\n", + "gagaapcuucaggacgcpaggcgcacuugcuucaagucgcpcgupaacpuugcaaaacpccucuuuguccgg\n", + "ggcugaacgucaggccacccgccgcuaagcugagaapagagcgagcuuaggaccgccugcccpcaaccccgaaccaagcuuuagccgccgaggccgcgugucccaaaggccag\n", + "ccauguaccgcggcaacgcuugcugaccccagugaggagagaggccugaauccgapcccuggcaccugugagcucuuggcugucaccugccccaagccucgcaccuccgcuccacagcag\n", + "aggaugcccugcgcpcggcggagcpugcgugcggcggcgguugcgagagagaugagccgcggcg\n", + "ugcacuugagugcaccuugagucuccagccucucaaggaaccpagaucaggccaucagcgucucagccagcaaaggccugaaccaccagucccuuauaacccu\n", + "gcgugcuugagaggaagaaguugacpaaggccagugcgacggcaaaucucgugaaccuupacga\n", + "auuuggagucaggccuggcuguugcucaggugaccagcuugugucucupapcgcugcuuuccccggccacccggcgcg\n", + "cpccccuccuaaugucapacuuaagauupcucgcupaccuggugguccgguuaupaaaagaagccucgupagagcagag\n", + "uguuccaggcacgauucugccuucucucaaauggcauaacucaggacucugcaaauucccagaaacaggaggaaaa\n", + "agucacuupagccgucupuuaucagaucaacugucugcaaguauugcauuguuuguguucaaaucacccuuauuuuccaucaua\n", + "cgcaguuccgccggaaguggccccagccucgaggccpcgucuucggucaucuccggcgcuucuapcugguucccgucaucuucpagccguggag\n", + "ccagccucgaggccpcgucuucggucaucuccggcgcuucuapcugguucccgucaucuucpagccguggag\n", + "cgupcgcccacaauuugcgcgcucucuuucugcugcuccccagcucucggauacagccgacacc\n", + "gccggaaguggccccagccucgaggccpcgucuucggucaucuccggcgcuucuapcugguucccgucaucuucpagccguggag\n", + "ccuuuuuccucucuucagcgupcgcccacaauuugcgcgcucucuuucugcugcuccccagcucucggauacagccgacacc\n", + "gacacugucccagcugccaccuagacucggagcuccauccaaaccuccagcgaagacaucccaggucpugaaucuuccagcccupuggag\n", + "aaapcaapauuucugguuccuuaagagaucaacugucuacacucacucacaccuccuguccugcagcc\n", + "acuuauucaaguaauaagaaagcaaagaagaguuuggccaaauccucuagucgcucucauagcugaaggcacccaccpccacuucuguccccagcgucuucucpucgugcag\n", + "ccucgcaguaccgugauguugacgaacguuuucccpacggcggcccagacggapcgaguccuuguagcccacgauggccgcguccugacaggucccguccgccaugagguugucgau\n", + "ggcucapauaaaugcgcagccugagapugagcugacacugucccagcugccaccuagacucggagcuccauccaaaccuccagcgaagacaucccag\n", + "cuccagcaccugccuucuuggagupaagaaucuuaaapcaapauuucugguuccuuaagagaucaacugucuacacucacucacaccuccuguccugcagcc\n", + "auuguupccagucauuugugagcugguggccggaccacaggccacacacuucuuccgugcaaaucuucauguauugaaacugccuguguauuguuuuuacgauuggagacuuggccaagaaaag\n", + "guggcucagcgagcagcccagcugcaggaggccuugcugcacugupagguuccaggaugcccuggagucccugcucagcugg\n", + "agcugccacuuuucaccguuagaaguagagcuuuuuccagaccuccuaccuuuuagucuacuuugaaaggugaaagaaagaacaucguuucaggaauaaaa\n", + "gcuuuuuccagaccuccuaccuuuuagucuacuuugaaaggugaaagaaagaacaucguuucaggaauaaaa\n", + "gacucugacacaucagaguuuguacggagagaguuuapaacugcugcacagauuuccugcaga\n", + "ggaaagcauuaacuuuugagcuacguccagaauagcaucaucuucaupuauucccuacuccuaggauuucagaaaaccuuugauaacuaauugagaaa\n", + "gcugacaggagccucccggcggugcuacccuccaccucccaccucccugcgccccgccccgagguupcuuugaagaaugcagccgg\n", + "guggugcggccccuuggagcgccggaagcccgcagugccggaggcccgcagcgccggaaccucagaggcpucgcagcggcgcagaggag\n", + "guauuccgaagacaugcugaupaauuaccaggcggcguuggucucuaacuggagcccucuguccccacuagccacgcgucacug\n", + "acuuauuuaccaagcauuggaggaauaucguagguaaaaaugccuauuggauccaaagagaggccaacauuuuuugaaauuuuuaagacacgcugcaacaaa\n", + "agaagcgugapacagauuugugaccggcgcgguuuuugucagcuuacuccggccaaaaaagaacugcaccucuggagcgg\n", + "gagagaagacgaucugcacuucgcauuuuggcauugacauuuaauuuuapuccuuuauauagaapagaguag\n", + "gagagaagacgaucugcacuucgcauuuuggcauugacauuuaauuuuapuccuuuauauagaapaga\n", + "ggacuuccpcacuucguaagguuuaaaaaggaugcuucgcguuuucucucuccuuuuuggagacagauucgcaguggucgcuucuucuccuug\n", + "agacauuccaggacuuccpcacuucguaagguuuaaaaaggaugcuucgcguuuucucucuccuuuuuggagacagauucgcaguggucgcuucuucuccuug\n", + "cugugugcucugccgucaucucuaagaaacaaccauaccacugaaugcuacuguguacuuacaaaccacacucauauucgucacgucauuucaucuucacccccaccuccaaaugag\n", + "acucggccuuaagccguccupuguaugugaggcugaaapaaggaggaacapucupccg\n", + "gcuugaaaugagaugagauguuccucccuccccuuucaaccauggaccucacacuguggacuuccucuuagagccucugaguuagguacccaagccaaggcaca\n", + "gccgucaucucuaagaaacaaccauaccacugaaugcuacuguguacuuacaaaccacacucauauucgucacgucauuucaucuucacccccaccuccaaaugag\n", + "gugagugccupcagagugagagcaggaccagcpcagguggcggagcpucggugguggauggcccagcccuggaaagccgaggugaag\n", + "gcacauacguguccccgapupuguccpcccgagcccaaggaagaaaggccgacccgugupacgcacacgupaguucaccggacaucuguggacac\n", + "agugcupcuggaguguggaagagccauccagagugagugccupcagagugagagcaggaccagcpcagguggcggagcpucggugguggauggcccagcccuggaaagccgag\n", + "gugagagcaggaccagcpcagguggcggagcpucggugguggauggcccagcccuggaaagccgaggugaagguuacgagucccugaggaucu\n", + "gugcacgugagccccgagcgugagcggcgugugaggcuggcupaagacgcuggcggupappacugaaaggaagccagguggucccap\n", + "aaaggaagccagguggucccapugagcaupacupuggcaggugccucccgcugcugcacccucaggacgcagugacggcuucagucupug\n", + "cuccccgccuaggugcuggccgagcgcpcpcaggcgagcgcggcggcggcggcgagcgug\n", + "ugccagaauaacacagacucagcugccagagccugcucuuaacaccuguguuuccuuuucagaucuuacaggugaacaaggug\n", + "uuucacuuucccccuugcacaaaaccgaacaucccaccccaccaccaccuccaagcuaaaauaccupccgccccuccccacgaapacgcgcuccaggcga\n", + "caccaccaccuccaagcuaaaauaccupccgccccuccccacgaapacgcgcuccaggcga\n", + "gcgcgccugagaagapacgccagcccggucaggccucggcgcggccuacacgcuccgcucgcucgcucgcucccgccucccgccccgcgcccggcc\n", + "uuuuuuuuuuuuuuuuuuuuuuuugcuguuuugcugcaggugagugauucugaucuuguucuucuggccagccucccccucucucuccuugacucuggcuugugcuggugg\n", + "aacggcagaggugugcucuuuggauuagaaagcugugcgaaccuucaggaacaggugcaggaaua\n", + "gcpacgcgcapcccggcggupcpcpucggcgcugccccgupcucgcupagccacggcggagacccccgcccucaacugag\n", + "gupcpcpucggcgcugccccgupcucgcupagccacggcggagacccccgcccucaacugag\n", + "acgcgcguacacacupucuccaggcagcggccgucgccgcauccccggcagcagcuccaggcaaagugacag\n", + "cacacacgcacacgcacacacpcgcgcacacacacgcgcguacacacupucuccaggcagcggccgucgccgcauccccggcagcagcuccaggcaaagugacag\n", + "agacggaguuucaccauguuagucaggcuggucucaaacuccugacuucgugaucugcccaccucggccucccaaagugcuggaauuacag\n", + "acacacagacacacacacgcacacgcacacacpcgcgcacacacacgcgcguacacacupucuccaggcagcggccgucgccgcauccccggcagcagcuccaggcaaagugacag\n", + "pacgcgcapcccggcggupcpcpucggcgcugccccgupcucgcupagccacggcggagacccccgcccucaacugag\n", + "gagcpacgcgcapcccggcggupcpcpucggcgcugccccgupcucgcupagccacggcggagacccccgcccucaacugag\n", + "gaauccuuuguguuugaacccaacugccucuucaaaguggaugaguuuggcuucuuucugacauggagaagugaaggcaag\n", + "gaucccaaaaucuuggcugcucuugaagcuguuggaaaaucagaaaaugaucuggaapcggauaguuugugucugcaguggcacagaucuagugaacauuaguuuuaccuac\n", + "acacacpcgcgcacacacacgcgcguacacacupucuccaggcagcggccgucgccgcauccccggcagcagcuccaggcaaagugacag\n", + "pcpucggcgcugccccgupcucgcupagccacggcggagacccccgcccucaacugag\n", + "pagaaggaggaggcggagupaggapagcccuccggaguucpagcagcacguugugapuccacacaapugaugccagaccgaacaccauuapccupu\n", + "acacacgcgcguacacacupucuccaggcagcggccgucgccgcauccccggcagcagcuccaggcaaagugacag\n", + "acacacacgcgcguacacacupucuccaggcagcggccgucgccgcauccccggcagcagcuccaggcaaagugacag\n", + "ggaggcpagucggaggagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "gugaagguacaaguaagaagcuggcgaaacauagagcugcagaggcugccauaaacauuuugaaagccaaugcaaguauuug\n", + "pagucggaggagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "gagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "aagcaggaggcpagucggaggagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "gaggcpagucggaggagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "auaaaaupaauuacuaagcuguaaucaggccuaaaguggccugacuuaauacagagacuuucucacuucuccaucacaauuauuupuagcuucggcaugcagcauu\n", + "gugaagguacaaguaagaagcuggcgaaacauagagcugcagaggcugccauaaacauuuugaaagcca\n", + "ggagucggaggagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "aggaggcpagucggaggagguggcggcgcuggagcuccucccpaccagcgacccpagcgagcacgucgcuccgcaccgcucuuccuccagccgcugagccgucccuucucgcc\n", + "guuaaauagguaacugcaaggaggugauaugaaugccaugaccpaugcacagcucuauggccacauacaacapugccuaccuguccaaggagguagugaagaccgcagagaaaaguc\n", + "agucugcapaggaaagucagaauuagauauucaagauggccgccucugauggagucccuggcacucacucaagcuugcauuugg\n", + "uucucccucuccugagucgcugucgcggaggcuggagcgcugccccggaaguccuccccccuguuccccgcccgcggcaaac\n", + "guuaaccguauuuguuuucccaugcaaaugauagucugccugaggagcugguuacugacagugupcagcau\n", + "auccuugccagcacauuacagaauauuuuuguugaaccuucuugagaauucagagaaacugcugagugaccacugaacgaaaagaucuaaucuuaaggcuuac\n", + "gucuggccccuccccuccgcccgucaccgccuccuugaagcugccgcugucgcugcugcucguucgagucgcag\n", + "gccucacuuugaugcccaggcuggagugcuguggcucaaucacagcucaucgcaaccucgaccucccpcucaagugauccucucaccucagcgucccgaacag\n", + "ucuauuuacuguagauccuugccagcacauuacagaauauuuuuguugaaccuucuugagaauucagagaaacugcugagugaccacugaacgaaaagaucuaaucuuaaggcuuac\n", + "aucuucaguuuagaucuuggaggcauaucaacugugguucuaaauggcuaugauguaguaaagga\n", + "guggaggucagcagugccacagaacaaacuggaguuaagaaaugucguucuucagauuuaaaaagaaaaccuuuacugaaucagcugaguguuaauaauacgaauuuccuuuucuug\n", + "gcauuuccagagagagacacaccacguaggacugaaaaugguuacucuaapauucgugacag\n", + "acaggccgagcucgcpcgacugccggccaggcagacgcugcagcuaagcugcgcgguggcuguggcag\n", + "pcgaacgaacgagccgagapuggcggccgccucccuccucccccggccugaccgcagcccgacgcc\n", + "agauauuucuupuaguagaaaaagaaauacuucacagagcugucaaaucuccacaucuucagcauuaaauaucaugcaaccaaau\n", + "agacugccpauccaggucuccpuccgcuuuggccagaggcgcggaaggaagcagugcccggcgacacugcacccaucccggcugcuuuugcugcgcccucucagcuucccaagaaag\n", + "gcaucgucaugugaucaucaccuaagaacuagaacaucagcaggcccuagaagccucacucuugccccucccuuuaauaucucaaag\n", + "ugccpauccaggucuccpuccgcuuuggccagaggcgcggaaggaagcagugcccggcgacacugcacccaucccggcugcuuuugcugcgcccucucagcuucccaagaaag\n", + "agaacagucccuagucuauagucagcaggcaugaaugcuaguuauuauuauuuaagcccuugaaaguaguaagugauuucccuuaccuuuguauuuaugguuacagg\n", + "gaacacuacauauugcagcaaaguugcauuucccuuggaaguuguucaaaaagacagcuguuucaauuccccc\n", + "agccaggagupcaacgcggcgugagcagcggcccgaggcucccggagcaucgcgcupagaagacuucgccgcucpccgcagccug\n", + "gugaacgugcugccgccgaucagucacccagucggcuggagucggaggcgauauuucuapuguacuuguupucagg\n", + "guaagcaccagccacaaaaaccuacaaaagaapaaauuacugucuuuaaauauuaaaaaaaaacaagaucc\n", + "gaaagugucgugaacgugcugccgccgaucagucacccagucggcuggagucggaggcgauauuucuapuguacuuguupucagg\n", + "gucgugaacgugcugccgccgaucagucacccagucggcuggagucggaggcgauauuucuapuguacuuguupucagg\n", + "guugcgcgccguggcggccucugugcagucgccgguuccggaggapcccaacccggcupupupaaguguggcugguaaccuggcagccgcggagag\n", + "acauccuggaagaguggccuaggacagcuccucuccugccagagcuaggcaggcgccgaaguagccgc\n", + "acccgcugagcgucgacacagucgcuguuggccugguguccagcgugguugucuaucccgucuaccuggccauccucuuucucuuccggaugucccggagcaag\n", + "guugauggacggauggcuacauggaugugauggagaugguuuacuaucpaccuuccgcauccugcug\n", + "agccggcgcccpagcccggagccagugccgcgcggacaucpcucccccguucagapcgccgccgcccag\n", + "agcpuggaggauuuguuugaguacgaapugcaaagupacgcggcaccuacggucacgucuacaaggcgaggcggaaagaugg\n", + "apapcggcccugguacgcaggcgcgcaugcuuugupcgaggcugugguggcccgag\n", + "auuuccuuaaauucapuccugcucacaupaaauacuuucugagaguccuggaccuccugugcaagaac\n", + "cagcucupagaggagcccagcacuagaagucggcgguguuuccauucggugaucagcacugaacacagaggacucacc\n", + "cucupaguggagccccagccuupauucccagguguuucccuucagugaucaggacugaacacacacaacucauc\n", + "cuuugccuugcuuucuggacagcugaacacucugaacaaggucuugaagcaugaaaaaacaccgcuguuccguaaccaggucaucauuccucugguguugucuccagaccgagaugaagaucuc\n", + "accggcucuaggaucccaaggcccaacuccccgaaccacucapuccuguggacagcucaccuaguggca\n", + "aucccaaggcccaacuccccgaaccacucapuccuguggacagcucaccuaguggcaauggcuccag\n", + "gaagaaaccuauaucccaaaggaccagaaguauucauuccugcaugacucccagaccuccuucugcuucucagacucuauuccgacacccuccaac\n", + "agupagcapcggugagcapcggupcapccaggugcgcapagaaacaaggcgccuuggaguucag\n", + "cccuagcucagaggcucagauupcugugaagaccuugcugcauaupuucaccugagccaccaggcacpccaugcugaugauaccagcuuucag\n", + "pcggccgcgcggaucacugaggcuguggcggcacugcgcccggcgcucgcguccguccgcccguccgcccgcccagcc\n", + "acugcgcccggcgcucgcguccguccgcccguccgcccgcccagccaugacugcgccgguccccgcgccgcggauccuguugccguugcuguugcugcugcugcuaacgccgccuccpug\n", + "cgcggaucacugaggcuguggcggcacugcgcccggcgcucgcguccguccgcccguccgcccgcccagcc\n", + "gcgcuccaacuccggcgaugccgccucgcccuccccgccgcgguugaugcggcacgugcacgccgccgcccgcaccaggaccupccpucgcacggcuuggcccccggccaccgcuucggccuag\n", + "cugaguuuccccuggccaaggcugcagacaapacgcagacaaucggcacauugugagcapcugcagg\n", + "auuggagccucccucuuugcuaguaacauuggaaguggccacuuugupcuggccpacupcagcuucaggcaucgccauuggaggcuuugaauggaau\n", + "auauuccaauggagacaguuggaaaaccuguacuucagagaaaagaaguuuuccguggaaguucaugacccacgcag\n", + "ggcuucagugacaaggaggacguuupcacagcggcauugcagugcacacgugguaugcauguccggcauugaucaaguccaucupcu\n", + "gugcuuuuggaugcucuguagccacccpcccaggaggacugacucggcagcaggauucgugcaupaaucggagacc\n", + "aguaggccaapccuucgcccpcgaaupacgcccguuccpuaccagccgcuugcagccagaaguuccucggaucccuuggaagcgcaaaaaauaaaag\n", + "gguuucuacuucccauuaguggcaacccugccuugugaucaaauuugacgccgacgguguuuccugagcupaguuugcagaucugaucugucagcpacugagagcaaaucpacauucauc\n", + "ugccacguaagacgugacuuugcucccccuuugccugcugccaugauugupucuccccauccacgugaagcu\n", + "agguagucpucgapaaccuggcucugcccaggugccacugcccaaaccccupccccaucc\n", + "aacccaagaugcucgcucuagagaugaagguggaugcagaugcupuucpuggccucagcugapccugcugaccaaccaaagg\n", + "guggcuccucagagcaapagguagucpucgapaaccuggcucugcccaggugccacugcccaaaccccupccccaucc\n", + "agugapucccacacgccuggagccgapucugugucaagagcggcapcugcaggagauaagagaaacgg\n", + "gcugccgupuguguguaggcuucagagacaupaucacggaagacugaagcagaaacaguggauuaagacuuccugagcgauagcug\n", + "aaugcgcgugcgcaaupccacagaaccgccaugccggaaccgcgcpucgucgcagcugcpugaacgcggcguuugccgcgcgguacaaccgcuaccpagcgcgaggaacugcagcggc\n", + "gaauuugauccccagcaggagcpacuuuuacaaaacgcucuccuuguugaagaagaaggacccccgcauuuaucagaaagaugccaccuucuauaacagaacag\n", + "auucccugaggccggcccgcgucccgucaggcgccgcgcpuuagcgcpucagcggaggucagcpucagcagcagcggcuccgapcgcggcggacgcag\n", + "ccuuuucaacagcugagcggacugcuccaagugugugugcgaacpaacagagacgcaagccaaauucaccuccguggagcugcucapaauacauuucg\n", + "accuguguuccugaaugcacucauccccucaaagupaccugucccaaggacuggcccagccgupagaucaccuucagagacuaucag\n", + "gucacguguuguuguupccpaaagcugcuuccpucaaugcaggacacupcuccggcggccagagupacuag\n", + "aaagaacaugugcupuccuucucupuucgcaaacuuguccucaacaacagcaaagcuucuupagacgguccacaugauacuacaggaguuaccaga\n", + "auccaucucuccugucaccaaauugauaauacagucaacccuccauauucauggacuucauccaugcauucaaccaacugcagauugaaaauac\n", + "aaugucuaauuuaauapauauagacaguugguuuaaaccaacauuuuuggacgaggagaggcuauggaaaugaagaaagaaguguuuagaaauaucacacaaacag\n", + "gccgcaaucuuggcpaaggcgccggccgcuaagaagccgaaagauguccaggucpcgcggcggcugagaaggcggacuccagacagcgaccccagaugaag\n", + "gcuuuggaguacagcuucaagugaaguuaaucugaggugaagcaaacagaaaauuguggagguuuuguug\n", + "agcpuugcgagcgguuggcuggcpucggaapccccpcacacupcgcgucaguuccccgccuccuccgagucucag\n", + "gaagagagaaauuuaaaauuaaaaauuuuccauauuucuaucacaaauauugguaauuugacaacauguaauuugauugucgucuuaauaaaauuua\n", + "ggaguacagcuucaagugaaguuaaucugaggugaagcaaacagaaaauuguggagguuuuguug\n", + "ggagcaagcapuucggcggcauuaccuguacccauucaccggcggcuaccggcggcggcgcgcagcgugucaggcggagagacccgccgccag\n", + "ggapccggcgguggcggagccggagcaagcapuucggcggcauuaccuguacccauucaccggcggcuaccggcggcggcgcgcagcgugucaggcggagagacccgccgccag\n", + "guuucacauccupaauacuguauuuucaaucugagguugguggagucgccgguagccaccuaagauagga\n", + "cagauacuuugguguugaacauuupauagaagagagaaauuuaaaauuaaaaauuuuccauauuucuaucacaaauauug\n", + "guggagauaaguaauuaacauuucgaaacaggaaaugaaaggauuuauauuuuuaaaagcuauag\n", + "auacuuugguguugaacauuupauagaagagagaaauuuaaaauuaaaaauuuuccauauuucuaucacaaauauug\n", + "auucagguuugguugcuuuggaguacagcuucaagugaaguuaaucugaggugaagcaaacagaaaauuguggagguuuuguug\n", + "pcggccauguuggagcagcggaggcggcgcagaggcgcgucuupuccccgcggcggcgccg\n", + "gccaucugcuuuaucugaagauuuucagcugaugaagaacuaggaggcucaaacacuaucuuaccugaguccaggacaagugacuuggagagugugcucuucuguggcag\n", + "ggaggcucaaacacuaucuuaccugaguccaggacaagugacuuggagagugugcucuucuguggcag\n", + "ccucccccucccccucccccucuuucuucuccucccucgucgccgccgccgccgccgccgccucagccuucgccucagccgccgcccgcucccgcccgcgcgcggcp\n", + "uccucccucgucgccgccgccgccgccgccgccucagccuucgccucagccgccgcccgcucccgcccgcgcgcggcp\n", + "cuccucccucgucgccgccgccgccgccgccgccucagccuucgccucagccgccgcccgcucccgcccgcgcgcggcp\n", + "agugaggagcggaggcpcgcpcggccggccaugaucgcgucgugcuuguguuaccugcugcugccggccacgcgccucuuccgcgcccucucag\n", + "augcuuucuucacaugucgaaaaaauguccuucuggcgaacagcucauccccccagguagapcgacuuugcc\n", + "caucaucuugugcpaccuaaauucugucccugauucaccucucuacaacuucaucapauggagagcuccaguaccaupaugccagccuggaag\n", + "guaucuggacaggaagacuucucccaucagcuuuaccagaggaagcugcaggccccacuguggcccagcucccupcaucacugauugcugucaguaugucaccuccugucaccccaagagaucag\n", + "agagacgcaaguauggccgagacuuccugcuacguuuccgcuucugcagcaucgcuugucagcgaccaguaggacugguccuu\n", + "gcuagugcggapuuuugcccuucguaaagauggccgcggaggcuuuuggagccaacupagcgcaguacgcguuuucuggagc\n", + "guucugugguuuuccgcuauucccccagacccgcaccuucucggccucuuugcggagaaucgugaccaag\n", + "gugacgccgcgcggccgcgcuguaguggccgucgaggccgccgucuguucgaaggcuguccgacuucacgguuccccgcggcucggcccpc\n", + "uucacgguuccccgcggcucggcccpcgugagugucgccagcpcgacppcgcgcg\n", + "augaugcuuccugaagccaggapupaagagaggucuggcupaguuapauggagcaggacaacuccaaggcuccccucuggcagccagaccugcucaugaagaaggcuccucg\n", + "gucucuguuuccaugaagccuacaaugcacauucucuguggaguggagaaaccapcccagcccugccucuaucucaguauggcuguaccuccccugaaucugccugcugugcccapugccag\n", + "gcguuccuacagguaaupcuggcacgagagcagcgccpaccgccgugapcgcgcggaaauccagcccguuauauaauggagcagacacugccugcgaccccugcugcag\n", + "gugcagaccgguugcgauuguggucagacgcagcaccuacuucuaaucugaggacccgcgauuuacacuuuugcugaauaggacacuguggaaugaaacagaacagagaucaaaag\n", + "caggcggcaggcacgguccgugcggagcaggcgagcgagcpaagacgcagccaccuuccucaccagccagcccacagcgguuuguuccccuucucpagugcgcca\n", + "gagaaggcagugagcgagcaggcggcaggcacgguccgugcggagcaggcgagcgagcpaagacgcagccaccuuccucaccagccagcccacagcgguuuguuccccuucucpagugcgcca\n", + "cuuauauagaauuggugauaggaucacaacuucugaggucccagcaagaguccuaacaucuagcagcucuaccaccaggacaggcccccuaaaacuaauuccaacaagcaccucugaag\n", + "gucugucccugcggcauccagucugupuccugucccauccauccugaccuguuccaucucagccccaggacucaguacugcgguugccaacacugcugccag\n", + "auccagucugupuccugucccauccauccugaccuguuccaucucagccccaggacucaguacugcgguugccaacacugcugccag\n", + "ggcauccagucugupuccugucccauccauccugaccuguuccaucucagccccaggacucaguacugcgguugccaacacugcugccag\n", + "ucacuuaccaggucugucccugcggcauccagucugupuccugucccauccauccugaccuguuccaucucagccccaggacucaguacugcgguugccaacacugcugccag\n", + "gugaaagguguagcagucacucggccuacacccacagcaucgaccuugugaacccagcgaccugacugccuugg\n", + "gagaauugaagcgaaugagagupagugugagaggugcguuuggugcagcauuucuggcaupaacagaacuggccaggaggaagugacg\n", + "ucupuucugcccgcacacauuccucgccaccuucuuggugucugagaaccuccagcuucaccuccuuuucuggacccgapccuggcggagcuuccagcupaccagaccucc\n", + "aauugaagcgaaugagagupagugugagaggugcguuuggugcagcauuucuggcaupaacagaacuggccaggaggaagugacg\n", + "aauuacgagcpcggcgcugcguuuccapcagaggaaacgaggcgccgcguuggcgcuuggacggcpaaccggcuccggagcgagaacgcgc\n", + "acccuucaauuacgagcpcggcgcugcguuuccapcagaggaaacgaggcgccgcguuggcgcuuggacggcpaaccggcuccggagcgagaacgcgc\n", + "auuuacacauuucccuccucagcaaupuacacagacagccaagcuccuggacuaagucucugaaug\n", + "acguggccggcuucuucugcaguuccpaguuupaccagauuuaccuuggauugccccucccucuccuggcucpcaccccgaagcacgacgcaga\n", + "guucagucpucccggcagcggcugcagcgcucucgucuucugcggcucucggugcccucuccuuuucguuuccggaaac\n", + "cuccuggcucpcaccccgaagcacgacgcagaguaggaagaguuuaaagaccucgaggccucupcacuugaguuug\n", + "agaucuaaccaugagcuacccuggcuaucccccgcccccagguggcuacccaccagcugcaccag\n", + "gguccagaggccuuucagaaggagaaggcagcucuguuucucugcagaggaguapuccuuucagcc\n", + "agaugacugcagagugagagugaaaccagcuucccucggaggcugcagcacapcugacaugcaaacgucugaaaaagaggcaagcucucggugugagcaaguggacugcggcuauuugag\n", + "gcuggucucgaacuccuggccugaagugauccuccaaccucagccucccaaguagcupauuacag\n", + "gugcpcgcgcggugacagcgcpuuggcggcgupacccapcgacagaggcagcagcagcccgaggccugaggagaggagaccggcggcggcggca\n", + "acugcugcupaaugugacaguuggcuguuggagagaagcpcacuggcauugagagaccuccagacuggac\n", + "ugguuugaguccagccaaugacacuggagccaaaaagaagaaaaagaaacaaaaaaagaagaaagaaaaaggcagugagacagauucagcccaggaucagccugugaag\n", + "pcucaggcugccccggugccauccucagaucugcuuuggagaucccaacucugaaauaugguguaccag\n", + "caggccggcucagcpcgaggcpaccucpagcgcgcgccugcagaccggacguccggccagcaggcpccpagag\n", + "pcggagaagugccucaggaguccugacgcagugucuupcgcuaacggcggcggcggccuuguguuuagacuccagaacuccccacuugccgcguucucgccgccgcaggcucccpacg\n", + "ggagaagugccucaggaguccugacgcagugucuupcgcuaacggcggcggcggccuuguguuuagacuccagaacuccccacuugccgcguucucgccgccgcaggcucccpacg\n", + "cuuuuaguauuuaauaauugcaaaugauaguguauuauuuuguuuucugcucaccuuaggaacaauacag\n", + "aaagugauaacagaauucauugaaguggagaauuuuuaaagaagguaacaaaaagagaaagaaaaugccgaaacca\n", + "ggcacaauuagagaaugaaaagaagaaaagagaaauagcagaaaaggaaaaggaaagaauagaacgugaaaaggaagagcua\n", + "uguauuggaacaacacaaacuaacaaaagaacagupaagaaagaauacagaacuggcaugaagaacauagagga\n", + "uuucaggugaggcugcugucagaaaggaacuuuuacacaguuugccuucagagacagucuaucggcauguuguagaguuuuauuacuaagaaaauaaauguuacuuacaug\n", + "augguuuuacucagcauuuggugugguggaucuuacauaaaccuuuagaacuuacauuagaguguucaagucuucugagacuccagagucaccuaag\n", + "aggccugacgcgcgccccagcggcgcgagcggaagagauagagcuucgcggagacggcggaagcggagagcaacagcgcgccg\n", + "gugaggcugcugucagaaaggaacuuuuacacaguuugccuucagagacagucuaucggcauguuguagaguuuuauuacuaagaaaauaaauguuacuuacaug\n", + "agacggaguuuugccauguuguccaggcuggugucgaaauccugagcucaaguggucugccugccucggcuucccaaagugcupauuacag\n", + "gugaggcugcugucagaaaggaacuuuuacacaguuugccuucagagacagucuaucggcauguuguagaguuuuauuacuaagaaaauaaauguuacuuac\n", + "uuucaggugaggcugcugucagaaaggaacuuuuacacaguuugccuucagagacagucuaucggcauguuguagaguuuuauuacuaagaaaauaaauguuacuuac\n", + "cuggccuucaggaaaagcaucccggaggaggaagaagaaguguuauauguccuaaaguaagguuucag\n", + "gccagcauccuucagaaaaagcauccccgaggaggaagacgaaucguuaaacaucugaaapucag\n", + "cucuagccucucggaauuugucuucuucaguggaaaccccgagaagacugaucaguucuucaguucuaaaaca\n", + "uucccccgacggccccgcguccucuucuagccucacccucucccgaggccccagcguupacuaccgg\n", + "gugcacgcaagcgucauupugaupccgugcucggugcgcuucugcaccggugacgcaaccgcugugucuccgccaguccgcgcag\n", + "gacggaggcagcccpaagcgagccggagcggcgcccgcacugaggcggcugcagugcugacaccacucapcaapuguccgacggcuggagcg\n", + "uucuguuuugaacccaaaguggaugaugcugucagagcugaaccacugaaaggaggcugugaaaauuucccaucuucucauuggccaucaguugagauaag\n", + "aagaacaagcuacugaaucagugucccuuuauuacuauggcaucaaagauuuggcuacuguuuucuucuac\n", + "cgguggcaagaaucagguuccaauucucuggaaccucuggugacuucucuaccugccaccugccccag\n", + "gugaugacuuuccccugaggaagcccuguagcgugccuggaggaapcucuccaaccccagccccaccuagccacc\n", + "ggcacccugaaacccaccacccccguccaccucagcucccccaagauggacugaaucaggcugcuggccagauagagaagcuagaagccaag\n", + "gccagcaucuuguaguugagcucucuuuauccuauaguppcccuccupucuggagcucagcccccauccuuucauucucccuugcuuccuucacuc\n", + "guuacccuagcaacggagagacgccacgcucugcacagucuauuuucggagccuagccagagacpaaaacugaccaag\n", + "agaaaagccauuuccgacuccagacugguccccgcuccccgcaagcccccccccccgcucccacg\n", + "accccgcuccaguccggccagcccuucaaguucucgaucuuggagaucugcgaccgcaucaaagaagaauuccaguuucuucaggcucaauaccacag\n", + "gaaaauuguacugagaauuagaacuucugcaapcucaagagugucagcuaguaauaauaauaauaacaaua\n", + "cucuuucuucpcagccuccccaccaccccacuucagccucccccacucuugccgccuccauaucaucaagcucugguggcgccuppcuuuucggaucggcagg\n", + "cccccccagaccccgcuccaguccggccagcccuucaaguucucgaucuuggagaucugcgaccgcaucaaagaagaauuccaguuucuucaggcucaauaccacag\n", + "gapacgcccpagaccguacgucacugcucugcgccggaagacccuauuuucagguucucuucccuccauuccuaccccuuccccgguaccauaaaaucccpau\n", + "aggcugaaggucugacacaagcauuagugagaugcuccccucgaagaauagucuuguuucuucuaaggacugauucucaccccggcuuuggcucuccuaauuuuagagg\n", + "cugcuuacugcaacucgcuccggccgcupcguagcugcgacucggcggagucccggcggcgcguccuuguucuaacccggcgcgcc\n", + "acucauuuaacugguauugcggagccacgaggcuucugcuuacugcaacucgcuccggccgcupcguagcugcgacucggcggagucccggcggcgcguccuuguucuaacccggcgcgcc\n", + "ccgcupcguagcugcgacucggcggagucccggcggcgcguccuuguucuaacccggcgcgcc\n", + "cagacugcagcccgugcugaugacuguggcugugaugaauucgugccugugaccacagcugcucuccag\n", + "gupagaaggagaagcacgaagacpugaaguggagacagcuggagcacaapcccguacuucgcacccccauacgagccccuucccgacggagugcguuucuucuaugaag\n", + "cacuggcugcacugcuggacccccuuccacccagcuccucggaggcapcucucucauaagcagccag\n", + "uggugcggcugcugcggcuccpcggcucugacgcugcucpaggucccccgccgcccggccucccpugucccpcucgcgcaggacgcagaapcaguggagccag\n", + "acccuucagagacuuccuguugcucugaggacacucaucccagccgaccaggcccaccaggcccccaacagcacuaccuggcupucacgugcaggucuccuggcucuggcag\n", + "gucuccgcgcaggccucpaagcpuccpagccguggugcggupaccgcgupuccuggaagagcugcagaggag\n", + "acugcagcccgugcugaugacuguggcugugaugaauucgugccugugaccacagcugcucuccag\n", + "gcucpccuucccggcgucuccgcgcaggccucpaagcpuccpagccguggugcggupaccgcgupuccuggaagagcugcagaggag\n", + "gugacuuauagcagugcuugapaagaaaauaaauucuccguuucaaaagaaaauccapcpacaaucuuacuguugg\n", + "gccagacuuagcugaccagccagugaggacgcccgcugccucccaccugcccuccugccgucuuucgccagccaagcccagccugagccagcacuugccuuuacgacc\n", + "cpuugupcucucucuuuuccccucuugcuccuuucuuuucuuuuuuucuguuuuuuuaaaccuuccaaggcaaguuc\n", + "cacugaaggcuucccucuuuccuuaaaccugucpuugupcucucucuuuuccccucuugcuccuuucuuuucuuuuuuucuguuuuuuuaaaccuuccaaggcaaguuc\n", + "aaccccuuugcauuacaucugccugucapuuggcucuuuaaucugucgugcccucgguauugcucuuugucugcccgugaauaaagugcagcauugug\n", + "cucuuuccuuaaaccugucpuugupcucucucuuuuccccucuugcuccuuucuuuucuuuuuuucuguuuuuuuaaaccuuccaaggcaaguuc\n", + "aaauaugapccpcggacccaaaguuapcgagcgcpuupuupcugucuggcagcca\n", + "auuuuuccuuagucuaapcacagaauggaaagguucucauuuuccuccuccaaugagaauuggcaccccaacagcaggcccupcccucggcugug\n", + "gaggagacccuaagauggcggcgapacggugaagguugccucccgcccguccpcucugauccuccgucuccccgucccccggcggccggcccauggccuggcggaggcccgaacc\n", + "gaaucaguuuagacuugaaauucaguuuuuccugaaacugaucagaaguuagugacaccuugauuggauccguuuuucugucag\n", + "gagcucauuuugcagcucucaagcuuuuauagcaugcuguaaacaauugucaaaguuguuuaucaagaaacagauagaguugcaacuuguuucuaguaauagaaacuuuuacacugcauuca\n", + "gcaaugcaaagaaacaaguuuccaagagaaaaacuucagauaaaaapaagauaucagaaggaauguccucagcauucuccucuugaagauauuaaacagcggaaaguauuagaccucagacgaug\n", + "guacugcauaagccgaccacaguauaagacuucuuguggcaucucuucauuaauuucuuguuggaauuucuuauacagcaca\n", + "gugcuguugacgagagauguccacgagacagcuuccgcagaaaggcugaaaagaaapcagaaaaggugaaccaggcguuuaccaaaagcaaggaggugagguucuuucucccuguaucag\n", + "acccuucucugucuaccucupcpacugccpugaugagauacucggucggcgacgguagaacpcgacggcgacaaccgcaaucacauccacgacggugauc\n", + "ggugaugagauacucggucggcgacgguagaacpcgacggcgacaaccgcaaucacauccacgacggugauc\n", + "gagacccccapcgccggaapcgcgccpcggucggcggcggccguuggcgagcugaggccugccaggcgaagucuggagaccagccpccgcggccgca\n", + "gccccgccccggcugcccagaaccpaggcggcggcggcggcpccpcccpcggcggcggcpacgcgaggacc\n", + "apugucaagcuuccauuuugguaucuacuucuaaauacacucagaacaggagaaauuuggacuaauuuucaaacuacagacacuuucuaauc\n", + "agucaaggaaacuuuugagcuauuuacagcuuguagcaauuauguaaaguauacuccucugaacaaaauuuggagcauguuuguuucucucuaccugauuuccccagaaucuggaaacuaucu\n", + "auauuuauugagugucuacugugugccaggcacuauaucuaugugcauagaaaaacccuggaaggccauacaacaauauauauagagugaucgucucugcuugcugagcuaacag\n", + "pugucaagcuuccauuuugguaucuacuucuaaauacacucagaacaggagaaauuuggacuaauuuucaaacuacagacacuuucuaauc\n", + "agaugcaacauggacacagaauucupaaccuacaacgugupaguucagccagacuccagaugaguauaag\n", + "guggaggcuguggagcggcagcggcagcagcpucccpacugaggcagcagcpcggcggcpcggaagcugag\n", + "caccuuuggauuuugaagcaauugagucauacucaauaaucauucaagccacagaupaggacuuuuuggaaaaucuacagucagaauucaggug\n", + "cacccgacagcuacaaagugcaagauaagaaaaaugccuccagccgcccugccucugcaauuucaggacaaaauaacaaccacucaggaaauaaaccag\n", + "acccuccgccuguguuacguguugaugaccggcagcggcuggcccpagcgacgugaggaacpagaaacagcuag\n", + "auaucauauuuuccccucucugcugupcugaauauuuuacugugugguagcaggaagaagauuggaaaaaggugcugcagcaggaagaagcupaucugauugaacag\n", + "auccugcugcgcugccgcugagaggaagapagcugcccagcggccucacgcuguaacccucugcug\n", + "gauauuuggucuuugccuggcugapacacaaagcaagaagapagacaugcagauauguugcaggauauucaagaaagaaggauuuuagc\n", + "gugaucucauccauuaacagcuguguguugccaguucccaaaucuuuaucuaucucagacuucucuccugcauuccagauucuuauauucagcugccuuuuggauaucucucccaggauguucucaag\n", + "cccggccpuagcucuucacuccucagcgcgacgucgugucgaguucccaaaaagcuccgcapcuguapag\n", + "gcauacaagaauuaaauucugaauaagucugcagguaggauggacaguuauuuuaaagcagcugucagugacuuggacaaacuccuugaugauuuugaacagaacccag\n", + "aupucucacuguguugcucaggcuggucuugaacuccugaucucaaguuauccuccgaccguggcuucccaaagcgcupauuacaguu\n", + "acucccaggacucccggccpuagcucuucacuccucagcgcgacgucgugucgaguucccaaaaagcuccgcapcuguapag\n", + "ggaagccggcaaaagccggcccuccccgguapaccguugcaguggccguuggcggccggcgcggcgaugccccgccuccggcgcgagccucggagcccccpcug\n", + "gcguuuugucccgcgucucgccccguccgucuccugacuggccgcucuuguccuuccucccgcuuuuucuucucucuccuugcggucugaag\n", + "gaguggcuuuggagagauaucauccccuguaauccpaggcagaggugacacggacugcacggaaacagagugcucagaaaagaguuuuac\n", + "uucaggcaucucaagaugaaaauuuugguaauacuacaccaagaaaccagguuaucccucgaacuccuagcucauuucgacagccuu\n", + "uuaccccaacaagccgaagcuuacuaaggcagccagauauuuccugcauucuuggaacaggapaagucgccccgacuuacgcagucuucapuucuuuggaaaucucucc\n", + "guuuuapacagacugcuuccpucgaapcuugcuuccggagagcpaaggcuaaaacgcgguagcuaaacugcagccaacuuugguuguguguggaaaaggcuuuagccauggacag\n", + "uuaccccaacaagccgaagcuuacuaaggcagccagauauuuccugcauucuuggaacaggapaagucgccccgacuuacgcagucuucapuucuuuggaaaucucuccaug\n", + "gaapcuugcuuccggagagcpaaggcuaaaacgcgguagcuaaacugcagccaacuuugguuguguguggaaaaggcuuuagcc\n", + "uaggccucaccagaggcuccuuuccgugaggccgcccccaauuccugccccuauucucugccupag\n", + "ggcauucuucauuccuaaapugcugaagugagaugcaggaaauccaaauagcuggaggaaaagaggcaggauauuagaacuaccuguuucuuccauacauaccagcauucugaagauuucuag\n", + "cuuauuuggcagcugcugccucacccacagcuuuugauaucuaggaggacucuucucucccaaacu\n", + "acuuccugucagugacgcacuuccccucugcupcgcgcgguggacggucugaaapaguguucpuuucgcupccucgcggcuccagagcccagc\n", + "gcacuuccccucugcupcgcgcgguggacggucugaaapaguguucpuuucgcupccucgcggcuccagagcccagc\n", + "aggcccugacccgcgcuggacccgcgcgcuapcccugacggcccgcgcpcuccaggcgcpcagcpacggc\n", + "acgcuagccagcguagcuccggagcccgcgcgccgucgccgcgucgcucaggcccugacccgcgcuggacccgcgcgcuapcccugacggcccgcgcpcuccaggcgcpcagcpacggc\n", + "cuaggucucuggacccauuauggaaauuagauugacacaccaaagcuccugcucccuuuccaagaacaagccugagcaacaccacaggauauucaaggaguucuuguuug\n", + "gaauaagucucaggagaucugaupuuuaacapuuuccgcuuuugguucuuccucguuuucucuccaccaccauguaagaaguaccuuuugccucccacc\n", + "gcuccuugccagaggccuccacucacuccagaccccuauagcccgucgcugucagcugucaacaaaggaugcgaaugcuggccgcuuccugupcuucgugucacccagag\n", + "ggcggcgcaguugcgagugcaggugaguuccpccgccaccggcugcuucugupccpccucugagcauuggcgaccccagcccggcuccpcugacapccuggcuucgccag\n", + "uccugaagaaaccacccagccuuggcgcggcgcupugacuucgcguagcaggcapaacuggccgcggcgagcpacuggccauuggagugcuccgcugcggapapaccccgacucga\n", + "gagucuuuuccgaggagagacgupcugguauugagcgugcagcuaagcuggugacugcuucagagaaucucauggcuggaaauccp\n", + "agucpcagcagcaagaugcgaagcgagccguacagaucccpcucuccgaacgcaacuucgcccugcuugagcgag\n", + "aacagcuuccggcgugacgcaguagaaaagguggcguggcuggcgauucguguucgugapccuuuucug\n", + "ccugcccuugguuucuaccpccgccugcucccacucggcgaaaaaaauuacacaacagcagccgcggcg\n", + "aggcuucucaguggcuugaaagcucagcugacucccacgaaguuugccggaacucaaggcugucagugacauucguggcgccaagacuuaagcag\n", + "auuggaaacccggaguuaccugcuaguuggugaaacugguugguagacgcgaucuguuggcuacuacuggcuucuccuggcuguuaaaagcag\n", + "ggcguucugugaagaguucggugcuaaccucccucacgcggcgguggcugccpacccuagcagguuucagcuggagcggcggcggcggcaac\n", + "gcagcgcgccpaguguggcguucugugaagaguucggugcuaaccucccucacgcggcgguggcugccpacccuagcagguuucagcuggagcggcggcggcggcaac\n", + "agauugcacaggaggaggcgguagcggaaccuuucuccuccgccugguucucgcuuccacccpcccaguupacggacgcacuagaggcgaccuaaac\n", + "accucggcccggaucpaagugucaagcpcgcucccccaucuccgccgcuauuaccacugaacccggacccccuacccagguccapccagccgcc\n", + "cuuccagucaccucggcccggaucpaagugucaagcpcgcucccccaucuccgccgcuauuaccacugaacccggacccccuacccagguccapccagccgcc\n", + "gucugaggucaggaaugacucauuguaaggaagcaagcuguugcauauuuaggaccugucagccaagaaacuuaaguguccaaugacuuuugg\n", + "gcccpaccgcpaupugucggcgugaccaggccugagcucccugucucuccucagugacaucgucuuuaaacccugcguggcaaucccugacgcaccgccgug\n", + "ugacaucgucuuuaaacccugcguggcaaucccugacgcaccgccgugaugcccapaagacapcgaccuggaaguccaacuacuuccuuaagaucauc\n", + "ggcaaaggcagcuupacccagcgugcgcpcccgcpccpccpugaccupcugcagcc\n", + "gcugauagcccagcagcagcagcggcggcggcggcugcggagcpugugaggcggcuggaccgcgcugcaggcauccgcapcgcggcaag\n", + "cucgagagugcagagaugapccpuccagcgaaaaauccgacgguccagapcpcaagaggcgapcuggauugcggcccc\n", + "gaugaugucaccuggagcgaguagcgcgcggcguggaacgcgagucgcgaccccggcucccggcaguggcgcgcacuagcccucgcgccgcacpacacgapcupcpcagcp\n", + "gagcuggaggapaaugauauucagugguguuuuucucaggugaaaggagcaguagaugaugauguagcagaag\n", + "cagauauaauuucuacaguagaauuuaaucauucuggagaauuacuagcaacaggagauaaaggugguagaguugucaucuuucaacaggagcaggag\n", + "auaaaacaauaaaauuauggaaaaucagugaaapacaaaagaccagaapuauaacuugaaagaggaggauggaagguauagagauccuacuacaguuacuacacuacga\n", + "cgccuuugaccugaggaucucaaagugcuuuacaaacacuaaugaauuaauccucacaacaccccagugag\n", + "cgccugccccugccgcugccgccgccgccgucgcugucguagucgccgccgccgcugccggagaaagagcacgagcpaagccccagagugaaaucuagcauccugccggcug\n", + "cuuucuaaugcaguaccaaguauupacuaaccucuuuccaaacuggugcucuuggugguaguuguaugugupcagaacuaggcu\n", + "gcuggauuuagugacucacuuccaaagaacagaauauggcaapugaaagagucauuguauaguggagaagccuggcaaacauugucuuaaccaa\n", + "acuuuapapcuguccugaaaccuggagccuggagcagaaagugaaacccuggugcuccagacaaagaucuuagucpacuagccggccaagg\n", + "ggaggucacuuuapapcuguccugaaaccuggagccuggagcagaaagugaaacccuggugcuccagacaaagaucuuagucpacuagccggccaagg\n", + "gugcgcgauuacugcggagccgcpcugcaccgccgcuuacacuucccugagcgcugccugagcuggcugcgagcgcaucpagag\n", + "acggagucucaguggcgugauccugguucacugcaaccucupccccccccaacccacugcgaguucaagcaauucugccucagccucccaaguagcupacuacag\n", + "gugaugauccugcaggaagugcaggagagacccccpuggcuuucgagagaacagguuuuuguacugauaucggcagcuucggugaacuuagguucc\n", + "agacpuuucaccauguuggccagucuggucucaaacuuguaacuucaggugguccacacacgucagccucccaaagugcupauuacaggcaugagccacugcacccgacccauauauaag\n", + "gagaacguagaaugucapagcaucucucaccuguguuguugaugacaggauggaaaacugucuucuccaaacugucag\n", + "aaagagucuaugccugucguggaagcuggccuggcccccggagcucccuggagucgguacupcuucguuuuguacgcaccg\n", + "uuuucucucugugcuaupagaugucaaggaaucaaagaugcaaauaacaccagaaacuccaggaaggaucccuguuuuaaauccuuuugaaaguccuagugauuauucuaaucucc\n", + "gacagcccugcucccugcagccagguguaguuucpagccacupccaaagugagaguccagcggucuuccagcgcuupccacggcggcggcccupagcagag\n", + "caugcapcucugguggaugaacuagaaupaaauugcccagguggaccccaagaagaccauucag\n", + "augagaaaaaugagacuuagagagguuacgugauuugcacacugcugcugagugguggaucauggauacuugagagucugugaacacucuaaugccucccuacaucuga\n", + "uacugccuuccccaggcccugcccuuccccaagaggaaaacacaggagaggaaggaauggcugcuggucuccucacagcupccccgg\n", + "gcuggaagauuauaucuggaucaccaccagagcaagcccuuucugaagcuucauuccaagacccauguguagag\n", + "pupcapcgaagacugaagcgagaapcagcgcgaggupcgacuaccagagcgaagcgagcggcguguaagcpugaagacaacgccag\n", + "uccgupcccpcggcpccpagugapccggcugagcccaccucgcupcccucccuggcgccccgccuupcggcggcgagcgcgcpccgcc\n", + "aaacuguuuaaccggaucccauuguacccagagugcagagccgccuuuccagcaugcapcugcucag\n", + "gcgaguuaguaaccuacgagcggcugugaaggaaacuguuuaaccggaucccauuguacccagagugcagagccgccuuuccagcaugcapcugcucag\n", + "uucuuuguuuuccuaupugaggaaugguuguaugagcaguupuuucpacgcuuuuupagaacccgauggagucugaaggaucucuaaaucaggcggaacccacg\n", + "guacuucuaagucaggaguacaauacaaaggacauguggagauccccaauuugucugaugaaaacagcguggaugaaguggag\n", + "aguaguuuccaggcgcugccpcggcuggcacuaagcgguccugaggcuguggcuacggcugcuccggagcugguggcgccgcgauaggagagccg\n", + "ggcupaagagagagccaggcaggacgcpcgccccuaguaacuguaauucucccucugcaggacguugcug\n", + "puaauuapaccagaggcupaagagagagccaggcaggacgcpcgccccuaguaacuguaauucucccucugcaggacguugcug\n", + "gacuggaggagcacaggccuuggaaaggaaagcagcugagauccagaggaguggaaggcucccccuugacuaaagcu\n", + "ggaggagcacaggccuuggaaaggaaagcagcugagauccagaggaguggaaggcucccccuugacuaaagcu\n", + "ggcagccacauguuaugcaaacauucuccccucuguaaauacuacaugaauguuauuuuugcuuucagaaaucacuaaaccuuggcc\n", + "acaggccuuggaaaggaaagcagcugagauccagaggaguggaaggcucccccuugacuaaagcu\n", + "cucgucgcuccugcugaggcgguagccgcuuuucgucgacucuuaccgguuggcupccagcugcgccgcggcucacagcugacg\n", + "gcggccucgucgcuccugcugaggcgguagccgcuuuucgucgacucuuaccgguuggcupccagcugcgccgcggcucacagcugacg\n", + "gacugaguuuccagagcugaggcugcuuuaaguagaauccucaagcuuggccucagaguacuaugaggcuucugaauccaggaauaagacugcucuuggauuuacucucuuuguauugcau\n", + "agucaucaacupcucaugagaaccacaagaaaccuacgaaggcacupacagagccuggcugcug\n", + "uuucagagucaucaacupcucaugagaaccacaagaaaccuacgaaggcacupacagagccuggcugcug\n", + "uuuaaguagaauccucaagcuuggccucagaguacuaugaggcuucugaauccaggaauaagacugcucuuggauuuacucucuuuguauugcau\n", + "aaaaguugccuuucacucugucacauaaaucaggauaauacuuuaccuaccaaaucapuaauacauuaucuaccucuucauguaaucauugcagguuuucucacg\n", + "gccuccccccgcgccgccgccgcccgcuaccgccgccgccgccgcugcgccugcugcuccucgccguccgcgcugcagugcgaapcucgaag\n", + "gucuuccacggagaaugcauccgcgucucaagagucggagucccccgccgccgccgccgccaucuugaggapugugagcguguauugapagagcuagcgaagaguuagcgcggcgaag\n", + "accgccgccgccgccgcugcgccugcugcuccucgccguccgcgcugcagugcgaapcucgaag\n", + "gcgccgccgccgcccgcuaccgccgccgccgccgcugcgccugcugcuccucgccguccgcgcugcagugcgaapcucgaag\n", + "agagcauuacggugaggaccaguggcggccgguacccuggucccugcaccggagcpuggccggccgcpcaccgcagcgcpcuggaacacugapccgagcccgcag\n", + "gcuaccgccgccgccgccgcugcgccugcugcuccucgccguccgcgcugcagugcgaapcucgaag\n", + "aguggcggccgguacccuggucccugcaccggagcpuggccggccgcpcaccgcagcgcpcuggaacacugapccgagcccgcag\n", + "auauuaacacaauuauuuucuuuuuuucccccacugaaccuucccauuuacccucucccgcccacuccacccpcpaauuguuuccacgaugaa\n", + "uaugaagacucauagcagaaagupaaauggaaacaaaccagaggacaccaaacupaaaauaaggaagaagugaaagacuuggacaacuuuuucaaagu\n", + "auagcagagcaaucaccaccaagccuggaauaacugcaapcucugcugacaucuuccugaggugccaaggaaaugagg\n", + "agcagagcaaucaccaccaagccuggaauaacugcaapcucugcugacaucuuccugaggugccaaggaaaugagg\n", + "gcagagcaaucaccaccaagccuggaauaacugcaapcucugcugacaucuuccugaggugccaaggaaaugagg\n", + "guucuugauacauauuugccagacuucaagauuucagaaaapugaaagagaagauugcaacuuugagucagaccuguaggccugauagacugauuaaaccacag\n", + "aaggugaccugcugagaaaagugguacaaauacupaaaaaccugcucuucugcguuaagupagaca\n", + "ucaaccuaaaaggccuguguucuuccaaacguaguuccaccacucccccgcuguaugaccuupcagguggccucaccucccucaggcucaguguccuc\n", + "ggacagcccupucuapagagagucccugagugugagacccgccuuccccggucccagccccucccaguucccccapacggccacuuccugguccccgacgcaacc\n", + "agguggaagcauucgaauuacaucaaauucuggcagagagaaguaguucugaucagaacacucacaccccuacupacaugcccauaccccuucgcacuucuacacaccccugaagacagagag\n", + "acagugguccuccgccggcuacgcggagucaguggcuuucaggcgcuuuccuguuggaauuggcgacugcugcpcugagcgcugguuucacgcgucucpagccagguugguggcgcg\n", + "gacaucaccaapccuggcaccaggugcccagucuuccaguugcgapcaagcaaacccgucaugagcaacucccuuccccaucucugcucacc\n", + "uguuaccggcpagcuguuugaagacauuguggccagagaguacuacagugaagcagaugccag\n", + "ccacuguauacaucagauucuggagaguguuaaccacauccaccagcaugacaucguccacapaccugaag\n", + "ccugagaaccugcugcuggcgaguaaaugcaapugccgccgucaagcuggcugauuuuggccuagccaucgaaguacapagagcagcaggcuugguuug\n", + "guuuugcuggcaccccagguuacuuguccccugaggucuugaggaaagaucccuauggaaaaccuguggauaucupccugcg\n", + "pucauccuguauauccuccuggupcuauccucccuucupaugaggaucagcacaagcuguaucagcagaucaaggcuggagccuaugau\n", + "agucucgcggugcugccpcucagccccgucuccuccucuugcucccucggccpcggcggugacugugcaccgacgucggcgcpcugcaccgccgcguccgcccgcccgccagc\n", + "ccccgucuccuccucuugcucccucggccpcggcggugacugugcaccgacgucggcgcpcugcaccgccgcguccgcccgcccgccagc\n", + "pugcuuucucugugguccgcaggugugugaagaaaaccuccacgcaggaguacgcagcaaaaaucaucaauaccaagaaguugucugcccp\n", + "gcaagaagcgaaacccuggccuuaaaauuccaaaagaagcauuugaacaaccucagaccaguuccac\n", + "uagagacaggauuucaccgugucggccaggauggucuccaucuccugaccucgugauucgcccgucucggccucccaaagugcupacuacaggc\n", + "aggucuggugcccgcgccugcucgcuggaccgcccgccccgcgcucuggcggcuccucccpcg\n", + "ugacaugugcuauccaauugugacaaacacaucaucucugaauuuggacacupucccauuucagaag\n", + "cgagagcgcgcagaguccagacuggcggcapcccgapccgacccgcagcgucccuggucucuccagcccucacucggaaccgcac\n", + "gguucgagagcgcgcagaguccagacuggcggcapcccgapccgacccgcagcgucccuggucucuccagcccucacucggaaccgcac\n", + "cggugcgagcupccggcpugguucgagagcgcgcagaguccagacuggcggcapcccgapccgacccgcagcgucccuggucucuccagcccucacucggaaccgcac\n", + "gccuuacauaggaaguccuucuaaagagcugccugccagcugcccuuccccagaucccgaauauccuccuggccagguggagcagagaacaguuccucagcuggucaugcugagcucauacccu\n", + "gauggcugcuccaugaggucaagacupucuccucccuccucccccuucaccaaugccuggucucacpcuaguuuugacccccacgcu\n", + "agagcpccugcgcgcugcucuuccccgcggagcccgcgcaguccgcgcagcccucaucgcaacupcccgcgcgcag\n", + "aggaaguccuucuaaagagcugccugccagcugcccuuccccagaucccgaauauccuccuggccagguggagcagagaacaguuccucagcuggucaugcugagcucauacccu\n", + "pcagugcggcpcggcgcuuccggagagcpccugcgcgcugcucuuccccgcggagcccgcgcaguccgcgcagcccucaucgcaacupcccgcgcgcag\n", + "ggcggcagcccpacuccggcgagagcgacgcaaggucggcugcggcggcggcccgapcgcccgugugcccagugcgcggcpacggccgcgagcucgcuggag\n", + "accgguccapapacggcpacaggcpaccagupaccggcpapcugacapcpac\n", + "auacggaccggauuguuuucgcuggcccaguguccccggagcuugugugcgauacagagagcaccucggaagcugaggcagcugguacuugacagagagg\n", + "ucuccucupuaccagcuccuuacugcccugcagacaagcgugccgugcgugcuuguggccaapaaggaagag\n", + "guaccagcuccuuacugcccugcagacaagcgugccgugcgugcuuguggccaapaaggaagag\n", + "cugguugauccacagauagcuccuuccuccccgccccuuccuuuuuguuuggaggucccaggaucuguguucacagacaucupaagaaaaggagcaggaaacuaccccgcacag\n", + "aagacugcauccggcuccaggaaaagcgagupauaucccaaucuuuggacugcauccugguugccucuacuguggucaccuuugg\n", + "aacagaaacuguucauacuuggugcgcuguggacucuugugauaauuaaccaagaguagcucuauuuguccaaccucacaccuaaagaagaaagaaa\n", + "aaacuguucauacuuggugcgcuguggacucuugugauaauuaaccaagaguagcucuauuuguccaaccucacaccuaaagaagaaagaaa\n", + "auucugaggaggcpuuggccuaggcgaagauccggacucupuguuuugcuaccgugaccguuuag\n", + "ggagcucuagcucgcguauucugaggaggcpuuggccuaggcgaagauccggacucupuguuuugcuaccgugaccguuuag\n", + "guauucugaggaggcpuuggccuaggcgaagauccggacucupuguuuugcuaccgugaccguuuag\n", + "aaacccuuguguguuaaaauauuggagaaggcucauucuuugaccaugacucgaaguguguaaccuuugugcuggacgccaguguuauuccauagcacgcccag\n", + "ggaacauaccuggaaccugaaggcugcaggaccaggaccgaaaaaggacuaggaggcupaucagcaacaacupaaggccaaggaagacugaccugapaaaggagaaacupaggugag\n", + "gcuucucuuuuccuuggcggaggapagaccacagagcccupuuguggaagagguggcuguucccugucaucagu\n", + "pccaaagccauucaaccaauccccagauaauccagagcucuupagcagaaccuuaaagagagaucguggagagagccapcccagaagaacucucucaaag\n", + "ccaaagccauucaaccaauccccagauaauccagagcucuupagcagaaccuuaaagagagaucguggagagagccapcccagaagaacucucucaaag\n", + "agcugccccugaaccccagaacaaccagcuggaucaguucucacaggagccacagcucagagacugg\n", + "aauaguguuuuaagaauauuucagcguaguagaggauuuaagcagaucgcuuugccuacuuuaauuau\n", + "gcagaacupcucccuugcaucuuccaguuacaaauucagugccuucugcaguuuccccagagcuccucaagaauaacggaapag\n", + "auaaccaacuagcuccucgcugaaacuggcucacaccgcggaagcccpucggugucpcgagccuucccuccuuuuccuggagcccgucucag\n", + "uuagcuuggaaaguuaaccuaacuuggaaagacacaauagcuugacacuguugcuauuuguuaaauaag\n", + "guauggaaccuguggugacuuaagaguuguauaauugugagagcuaagcacaguccuuguuauuaaaugacag\n", + "agccacuggaggaucuugagcagaggcgugacguaaauuuuaagaaacuuguupaugguuguguucuaaaguuaaggaaucaaggaugaugucaag\n", + "guaauaguguuuuaagaauauuucagcguaguagaggauuuaagcagaucgcuuugccuacuuuaauuau\n", + "gaccacugugagcccgcggcgugaggcgupaggaagcgcggcugcugucgcccagcgccgccccgucgucgucugccuucgcuucacggcgccgagccgcgguccga\n", + "ucucugacugcaauggaaagaggaaagagaaauuagaaguauuuuuuuaaauugucauuugauuucuucagaguuauugupcuucugaacu\n", + "gcgcggcugcugucgcccagcgccgccccgucgucgucugccuucgcuucacggcgccgagccgcgguccga\n", + "agucuugcugugucacccaggcugccaggcuggaguggaguggcaugaucucggcugacugcaaccucugccucccag\n", + "ggcaucauucagaagauaguggacagucacaaaguaaagcauguggccugcuauggauuccgccucagucaccugcggucagaggagguucacuggcuucacguggau\n", + "acguaaauuuuaagaaacuuguupaugguuguguucuaaaguuaaggaaucaaggaugaugucaag\n", + "uauaguauagcaggacugugauggaaggcacagcucacuccagcacuacgugaccagcacguuccuggagccgagaga\n", + "gcagcupccgcguuuaggcugcaccacccgcguguuucagccgcucgacuccgcuggaccupacccccagacgupaggaupupugugccugccu\n", + "agagauuuauucgagcuucggcpapagcgcagcupccgcguuuaggcugcaccacccgcguguuucagccgcucgacuccgcuggaccupacccccagacgupagg\n", + "gcagcupccgcguuuaggcugcaccacccgcguguuucagccgcucgacuccgcuggaccupacccccagacgupaggaupupugugccugccugugaguuup\n", + "gagcugaagcpugcuccpagugaggapagcgccapcugcuccapaggcggagacggapcaucccpucuccgcgcggucgccugcgcuucaccccgcacp\n", + "ggugaccuagugucuuccaguapcaaucucuggacaucuuuaucuccccaguaccucuccagauccugaagccupccapaggagagguuagaugucagcaguggaaggacag\n", + "gcagcupccgcguuuaggcugcaccacccgcguguuucagccgcucgacuccgcuggaccupacccccagacgupagg\n", + "acugguugacggucaggupcugauugguucucccugcuacagugguagaauucagcgcuguaccuag\n", + "ggacggcggcucccggcuggcggcggcgcgcccccpcugugaaugcgacucgccccucggccgcgcuccccgcccgcccgcccgccpacgugguap\n", + "cucccgucacuagcuuuuucuccucaagccugcacugcacaccaacupacggapugcagaugaauaaaggcaaauccaucaccaaaa\n", + "cuuuuccaguuuccgaggugcccgcccccgcgcgccugaggcagcgcagcccggapcgaacgaauggcgguuggcaaacuuuga\n", + "uacagcucccgucacuagcuuuuucuccucaagccugcacugcacaccaacupacggapugcagaugaauaaaggcaaauccaucaccaaaa\n", + "ggcugcuuuuccaguuuccgaggugcccgcccccgcgcgccugaggcagcgcagcccggapcgaacgaauggcgguuggcaaacuuuga\n", + "gcaugucccucccagccgcccugcaguccagagcccauaucaaugccupucagagcucupaggaacugcucaguuaggacccagapaacc\n", + "cccugccccgccccgcccgccgucccccgcuuggcuuccagcgccgcuugcgcuccggagcgcuggcucugcuggcgcugag\n", + "ugccccgccccgcccgccgucccccgcuuggcuuccagcgccgcuugcgcuccggagcgcuggcucugcuggcgcugag\n", + "pacgupcgcpcgcggcgugcggcacgcugcapcugaagcggcggcggcggupacugcacguagcccggcgcucggc\n", + "ggccccggccccggcuccggcgcugcucccaccgccgcggcaacggccccggcccacggaggcggcuggacggacccccgacgguuggacguacggacucugcuucgagaguag\n", + "ccccccggccggccucgcgugccuucccgcagcacugccguccccpaugcugagcgcccaccgucuccccgcagcccccuc\n", + "accgccauuuuggccgguggccgugagaacacgcuguguggcugaaaagugaaggcaagagcugauuuggccucugugcuccccuccgcaapaucguuuucuccag\n", + "cpagcagcagcguggacgcggcuggcgcuggcgccaugaacccgcuguaaggcgcaggcugugcagcacpugcpaggaggaggaggacgccgcggugaaguucuccgcc\n", + "gacgcggcuggcgcuggcgccaugaacccgcuguaaggcgcaggcugugcagcacpugcpaggaggaggaggacgccgcggugaaguucuccgcc\n", + "cuuucuaccuccuuauucagagaaggaaggaucuucucaugcacagaggcaacaaauggcaacuuucuga\n", + "guccucaucuauaaaaugagcauaauaacaucaccuacuuaauuggauuuggugaggauucacupugaguucaugcaaagcgcugagaacaggaccccccgccccc\n", + "gcugcguuuggucaguugcaccuucupucacugguagccgcpagccpupccuaggcgaugauccggcauuaaggagcupaucauccuccgucucag\n", + "auccuuucuaccuccuuauucagagaaggaaggaucuucucaugcacagaggcaacaaauggcaacuuucuga\n", + "agugaggagaugacaccuagacugaaguagcagcaguaaugagcugacagccucacaucuacuuuuggugugccgugaauaagccauaugaucuuag\n", + "gguuuucugauuugcuguucccuccuccccacupugucuguucuggaggccapugagagguggaggagg\n", + "auauaguaugcagcaaccggaggagucacguupaacggcagaaagcagcuauccguuuacacuacuuugcucuaacagcuaucuua\n", + "paaaaggcaaaguauucugccuuccaaguuagauagcuaucuuuaugaaaggacauauuucaaag\n", + "caaacaccgucuacaagauucgagucaaacaacgugagaacuugaaauacgucuccauucuuuuuccuuaguacucucguucauucacuuacg\n", + "aaacaccgucuacaagauucgagucaaacaacgugagaacuugaaauacgucuccauucuuuuuccuuaguacucucguucauucacuuacg\n", + "aguauugacaaggaugcauuucauggcugaugagcacaguuuugacuuguguauccaguggagguguucccuuuggcaaaug\n", + "guagaagugacuugaagaaagagcgagaaguauagaapcgcaggcgcuaguucagugcucgugag\n", + "gacggucaguaaaaucuuccccugaggacauugugauugaacugagaucugaagaaugagacagaauuaacucgaagugaccagaucuugaauauuauuucuuuau\n", + "aaaucacuguguuuucagcucagcggcccugugacauuccuucguguugucauuuguugagugaccaaucagaupuggaguguguuacagaaauuggcagcaaguauccaaupugaagaag\n", + "agacuccaucugagcccugapagucggagcgccgcgccacpcpapcggccacgaauccap\n", + "gugcuuaugagauaaacgacapuaacuguccacauuggucccaguuuaugapagaagagaucauaaucuacaaaaauuugcaag\n", + "acggcgccucaucucccagagaucuuccuuggagacccuggaagauauugaggagaacgccccucuccggag\n", + "ggccauuuuucuuccugguguuugaaugacucauaaaaugaguuuggaguggucugaagccucugccuccuuccuuga\n", + "gugcuuaugagauaaacgacapuaacuguccacauuggucccaguuuaugapagaagagaucauaaucuacaaaaauuugcaaggugaccapaaaagagu\n", + "accuauaaauacggacacccggccccggagcccgcgagccagcggccaggcgaccggcpcggccagccagcgagccgaacuagccgagcuag\n", + "gccgacuucgcagaacuacugcucccuggagcagccaggccapcggcagcaccagcgccuucgagcagcugcagaggucccg\n", + "aacuuugguguacuuucgcccaccagaacupcaaacugaggacauuaaaaaaacgguuuaagagaaacuggccagagcg\n", + "gcaaugauucgugugaauaccuucucucaaguggcagauuucuuggagagaaaguuuggcaaccucacaguugu\n", + "auuuauccucuagcgcucaggcccugccgccaucgccgcagauccagcgcccagagagacaccagag\n", + "ucaucapccaaguucgupacaccagaagucaaccagaccaccuuauaccagcguuaugagaucaag\n", + "gccuuggagccagagagacgcagcuaggccugcacggcuguggagagauccugccacpccuuguucacc\n", + "uguaacaggaaguggaaauugagcgaaguuugugcucgccagcuuuuaagagucacccupagccagcuggaggauucugugaaagauucagacaagaaaggcaaggaaacaucuuuugacaag\n", + "ggagaaaucuggcaggucucuaggcagacaaaapaacaucugguapacupacauguagaaaaaag\n", + "cgacugcuggcccuaauaagccugagaguggauuugcagaagacagugcugcucpcgapugugucagaccuccacgaaguggucucccugaaggagcgg\n", + "auuauuuggagaaaucuggcaggucucuaggcagacaaaapaacaucugguapacupacauguagaaaaaag\n", + "gccagaagccaaggaguccucagugacggupauccacaacaucuccacaucgcuguccccacccagccapcagcgccagcacuagcucagacgcaag\n", + "gacggaaccgcuggacuccagguuccuugccupaguaggagaaauccaccugcupcugaguguggccugapacaggcccupucccp\n", + "gaccccggcuugagguaacagcgcgagcugaggcupcccuuggcgcggaggcugapacccgccgcggcgcugucgccggagapapcaccgcugucgucg\n", + "cagcccuccugcacccaggugauuaaaagcuuuauugcucacacaaagccuguuugguggugucuucacacggacgcgagugaaagaupaucacaggcccccaccaccacgcccag\n", + "agucuugcucagucaaggcuggagugcauuggcaugaucucagcuuacugcaaccuccgccucccagguucaagugauucuccugccucagucucuggaguagcupauuacag\n", + "pacauugaauaaaccugaguauugugugccuguauuuugacugcgaccuaucagaugagaucag\n", + "gucaagagacaacugccuuugaaagagagugagugacuguuuccaaaacagcaagcauapagagccgccggaaguauugacggaaagcuugaauuaccuacaug\n", + "auugaugauggucuccagcugucaaagaagauugugguugccaagagaaagguaaccauuucucauccccuugaguggaauuggaugccucuaggagcccacauuggcuggcaguagac\n", + "ggagccagaggaggcgccggucgcuggcagcugagcggcggaacccuucgcuggcpagcgcgguucpccgcagag\n", + "accaucauugaaugucuaaaauauauuuguacuggagauuucccuccuggaaccaaaggaaauacauuuguacacgaucccaag\n", + "guugcucaagaaacagaugugagagcccagauucgucugcaauuucgugaugucaauggagaacuuauagcugugcaaagaucu\n", + "guggcagcacacccupccccccacuccccgccgcaaguccugaggauggccagcagagaaacaagaaaauggacucccuggcugcuggagaguugaaugccagccaccagccaugg\n", + "aggcucccpcugagucuaaaucacucaucauugguuaaagccgagcucacagcagaauaagccacc\n", + "agcugcugcaacugcagcaagagguapcucaggcguupaauugcaccgacaggcagucgcacagaaaggcacacagauguaguggugugcauagcccuugacagcgaauag\n", + "guccugaggcugccuccuapuccggccggcgcuggagcugcggauuuagauugucacugccaccucggucggugcuuacuucgcugccagcuggucgucgcc\n", + "gccuccuapuccggccggcgcuggagcugcggauuuagauugucacugccaccucggucggugcuuacuucgcugccagcuggucgucgcc\n", + "cgacugacaacaggcugguugcuuggcguggaauccuaaaguggccuggcuuugagacuggagugagaccccagcccuaggcupuucuuuccauuauagaggagacggauucagaapcuacag\n", + "accaagguuguugaaaaccagacauaugaugagcgucuagagauuaacgacuccgaagagguugcaaguauuuauacuccaaccccaagacaccaag\n", + "acaggaggccacacugcuccccgagcccggagcaaaagcacucugcccuagacccucapcpcuccuccggccccugccccaggcccgccgacaaggagagacg\n", + "cuucccucucapaagcuccagcugucccucccgcaguuggcccugugguguuccgaagccgguuacguacggccugapccaggcgaaccucaggcucuuuguccuacuaaaaagcgcag\n", + "acuaucaacugcacagcpcagaggcagaggaacacagaaccuucucacacagcpauaaaagg\n", + "caaacauuagcuguaccugaggcccuupagcuucuuaaaccucaggcugcupcccacucccggaguuccugauuca\n", + "agugguucucaaacauuagcuguaccugaggcccuupagcuucuuaaaccucaggcugcupcccacucccggaguuccugauuca\n", + "cacpcugagccccgcgccgccaccauguccguggccuucgcgucugcccggccaagaggcaaapagguuacgcagcaaaccauccagaag\n", + "augcuggacgagaaccaccaccugauccagugcauccuggaguaccagagcaapcaagacggccgagugcacgcagugagugcccgccauacaccggaacacuuggapuguc\n", + "aaagacagcggcaacagugcugguggcapagcuccgcggacagacuugcaagagaccccugcuccuuguuggaaaguugucccaugaugaaggccuagaccuggucacggagacuuuugg\n", + "apcgucguuapagcgagucgugaccgguupccacacucaacgupacgaagcuucgccuacuguuugacuacgugcgugcagccuccccucg\n", + "cuuuccgcuccaacgcacggapugaggucgguacgcggugguggcgucacggcgccagcuccucccgacgccgaggupuuccpagacccgcpucuggcugcgagag\n", + "gucccuucuuuccgcuccaacgcacggapugaggucgguacgcggugguggcgucacggcgccagcuccucccgacgccgag\n", + "puucggagcgcgaagccgccgcupuccucggcgcgccccgcgucugcgcuugcugccgcgccccggucggcgcgcupaguuccagcc\n", + "guugccuuggagccagagagacgcagcuaggccugcacggcuguggagagauccugccacpccuuguucacc\n", + "guacaggaagaaggaauggaaucggaaggaagaaaauucauuccagagacaaaauagcuccccuccucuguuguagcuguuccucuggcaauacaaacuuucugcuuuca\n", + "papcpcggcgccgugccccpccgcgaggcucggcucccgcuccugguccuugucugcacucccuccaggaagcaggcucgcucgcu\n", + "uccaugaagcaagaggaggaggcagagcgcgagaggucccguccgccccagccgcgucupccaggagaaaag\n", + "guuggugaagagaucaggaagagauuucuucgagacuaaggauggaugacccuuagcaacagugaccgucuccucccggcauagcaagauggccugcccucag\n", + "ccgccgccucpcpupcugacuggcggcaggcucgccgcggcgcggagucccggcugcpauagaccgapcc\n", + "gagcaagccaagauagcaaagcuuggacuuaagcupuuugcucaccucugacgcugacugcgaaauugagaagupaagaucaggagaaugagauuguucaauauggacggaac\n", + "pcpupcugacuggcggcaggcucgccgcggcgcggagucccggcugcpauagaccgapcc\n", + "gcagcuupcccgcggcggcggcaapcpapagcggucgccgcpauuuggagcugccuagccucgcggucg\n", + "cuuucccuggcuggugcugucaggaaggaccaucugaaggcugcaauuuguucuuapaggcaggugcuggccuggccuggaucuuccacc\n", + "cuuuguuaccuaacagcuuggcucuuuupaaauauagacaagcuggaacccaggagcaguupaguuuuaaagaaugccagccuuuuuaaag\n", + "cuuugauguccagugcuauagaaucaaguuacuguggaggucaaaacaauuugagauacauaagcuggccuuagaaaauaaauugccucuaacuu\n", + "ggugacaggcccupacucupaauacccagcuuccuccccgcaacccggugaaagccaacgca\n", + "ggcggugacaggcccupacucupaauacccagcuuccuccccgcaacccggugaaagccaacgca\n", + "paauacccagcuuccuccccgcaacccggugaaagccaacgcaauguucggugcpacgaggacgacaccgauuuccucucgccgagcggcgg\n", + "gacgucggcggugacaggcccupacucupaauacccagcuuccuccccgcaacccggugaaagccaacgca\n", + "agcuuccuccccgcaacccggugaaagccaacgcaauguucggugcpacgaggacgacaccgauuuccucucgccgagcggcgg\n", + "aucaagacggaaguaacagcggaaaggaaguuccaaggcccgcgcupaaaaagguppaccapaagacucggagugcg\n", + "agcggaaaggaaguuccaaggcccgcgcupaaaaagguppaccapaagacucggagugcg\n", + "gaaagacgcugccccgcggagugaaugacuacucuuucccuucguuuggacacaupcuuacaacgccuuguguuguaaggagagaagaagaa\n", + "uaagauuuacacagaguacaaugcacaaauuuucaagaauacuggcugaaccacagaucuucaagaauccugucucacgccuguaucccagcacuuugagaggccaag\n", + "cccgcuccagccgccgcgcauccucggcccgcgccccgagacccgcgcccagcuagccccggccccgcucggcgccccaggcagcucggcugcgcucgccgcpacggcgcggcc\n", + "ggcccgcuccagccgccgcgcauccucggcccgcgccccgagacccgcgcccagcuagccccggccccgcucggcgccccaggcagcucggcugcgcucgccgcpacggcgcggcc\n", + "gugcgccggaagagcacgcccaguccpcugcgcggaggaagcgcupucccggapcpuggcggcgccggaggucgcc\n", + "auuuuggaaacaauaccgcaccgugcggaguggccuccucccgccccggccugugcccgccgccgccgccgccccugccugcgccucccgccuccugccgcagcccg\n", + "cupcuuuuucccuccuucccaaucgagucupcguccagcccccgagugcucgucacgcuggacccuggcgcggagcccuggcaucacgacucggaggccgagacucucuccuggagucacccag\n", + "uagcugcugauucuacuccugcuauugcucacaacccucagagucaaacuuugugaccggccuaggucagaaaacgugaucaagaaaaapugguuccaggcpcccapaagag\n", + "cccgagcaggcguauuuuggaaacaauaccgcaccgugcggaguggccuccucccgccccggccugugcccgccgccgccgccgccccugccugcgccucccgccuccugccgcagcccg\n", + "ucupcguccagcccccgagugcucgucacgcuggacccuggcgcggagcccuggcaucacgacucggaggccgagacucucuccuggagucacccag\n", + "guacccugcaugcauauagcugcugauucuacuccugcuauugcucacaacccucagagucaaacuuugugaccggccuag\n", + "auuuucccagguacccugcaugcauauagcugcugauucuacuccugcuauugcucacaacccucagagucaaacuuugugaccggccuag\n", + "ccupaagagccaucucugcugapauccccgaacgcpacuccggauccggcuggcuggaacpagucccpccpcagagagag\n", + "gccaggagccaccguccgagccuugcggagcgcggcagupcgccggcugcccgcagccccugacccggccccggacggagcgccggccgcaccaccgcccucuggccguugccucaccgg\n", + "aggagccaccguccgagccuugcggagcgcggcagupcgccggcugcccgcagccccugacccggccccggacggagcgccggccgcaccaccgcccucuggccguugccucaccgg\n", + "aagagaucgcagcapugaapagcggacpaagcgauuuuugccgacuuuggauucguccccggcgugcgcaaga\n", + "aguuuguuuuucuccugucugaacaauggugucuggagaaaucugugagcuaccaggcuguagaaauccuagaaag\n", + "gaaaugucucuauuucuagauugucuucaauguucuuauccugcuuaucuguggauaauauucuugauagucaugugaaggaucuaucuupaaagccaaggacaucupaauguuugacag\n", + "auaaacaagaacaaaagaggcaagacuguucauaaaaaauugagaauguuuuaguuugcgauggacuucaaaacaaaauauuuaccauguacuaacauauaauuucau\n", + "aaacaggaaauguucacguuucagagaggcugcagcccggcgcagcauccugagcgcgccucugccgaggcgagcggac\n", + "auaaggaugacauucggcugcugccgucagcauupugugaagaagagaaaacgaggacccaagaagcagaaggagaacaagccaggaaaaccccgaaaacgcaagaagcgu\n", + "caaguggaacagaagucaucagcaacucugcuucugaccupccuggaggauguggagcauguguucucugaggaggauuaccacacgcucaccaacuacaaagccuucagccaguuc\n", + "aaggapcuuccgcccpugagcgcpcugcupugacccggcuccugcuugccccgcagccccggcccccugcccacc\n", + "gaggaggapagugugcgcaggcgcccuapucuuccccagcacacguupaagaapucugcaagcaugcgcacaauugccagcucaggcuaaggacugcaggagguuccag\n", + "guccggcggcagcggcguupacuccggcpaugcgcgcccggccccucagcgcccccagcacgccgccgagucccgcucgcc\n", + "ugcgagguuaaaaccuucagccccacgugcuguuugcaaaccugccuguaccugaggcccuaaaaagccagagaccucacucccpagccagc\n", + "uuuuagguaccugcugcuuauuguggacacacauagaauuuuauguauuauuuuucgacuuaggcuaaugauuuagcaaacucugga\n", + "acucucuucuccucccuagugcgagguuaaaaccuucagccccacgugcuguuugcaaaccugccuguaccugaggcccuaaaaagccagagaccucacucccpagccagc\n", + "guuccggcgcacguaaucgccgapcacgugcaugcccccugguuaagaguugcagguagcgguagcg\n", + "aaagcccaaaacgaaaagagccaagagauuccuugagaagagagaaccgaaacucaaugaaaauauuaaaaaugcc\n", + "acgcgcagcuuccgguuccgccuguuccggcgcacguaaucgccgapcacgugcaugcccccugguuaagaguugcagguagcgguagcg\n", + "agccagaccccgcgccgcccgcgccccgcucgacuccggaggcucccgcagccccggcguccgccccgcugcccccucccccpcc\n", + "gccagaccccgcgccgcccgcgccccgcucgacuccggaggcucccgcagccccggcguccgccccgcugcccccucccccpcc\n", + "cugccucccccccgcucccgcuccccugagcccagccagaccccgcgccgcccgcgccccgcucgacuccggaggcucccgcagccccggcguccgccccgcugcccccucccccpcc\n", + "augccaaagaccuggaucagcupccgaaauaagaucacacacaucaucucuauccaugagucaccccagccucugcugcag\n", + "caaaaagcacuucaaagaauguaucaacuucauccacugcugccgccuuaauppaacugccuugugcacug\n", + "guugucccgcpccgupcccggcacacupcuuuguccggccccccgccgcgacccgaggcpccccac\n", + "aggaagugaaguccccgagcacguuagaaagccugacauggccugacucpacagcucagagcapcagaacupacacucupccggccuucugccugc\n", + "gagcacguuagaaagccugacauggccugacucpacagcucagagcapcagaacupacacucupccggccuucugccugc\n", + "uaaaaccaggaagugaaguccccgagcacguuagaaagccugacauggccugacucpacagcucagagcapcagaacupacacucupccggccuucugccugc\n", + "aaugaagacaaacacagagauggugugucuaagaaacuucaaaagguguagaccuccugacugaagcauauuggauuuauuuaauuuuuuucacugua\n", + "guuacaacuuccuuaacacaacacaguucaacccauuapagcugccaccugaaaucgugaaaaauuaucaaaaca\n", + "cuuccuuaacacaacacaguucaacccauuapagcugccaccugaaaucgugaaaaauuaucaaaacaguaaguauuuuaag\n", + "auggaaaaupuaaggaacaaucaaauucaauucpaagaauauagaggugguaauaauugguaaaag\n", + "gaaugaguccupaaaggcgcaugcgcucucauugcagccucggcguuuguagaagaggagcaucugcuccag\n", + "caugucaaguucagacuguaaggaguagaugcaguagugaagcuguccaucucaggugaauugaaaaaguaaagaacuacaaaaugccaucauucccucucuguguugauuucuggugaagcucagag\n", + "cugcauuucagagucagaaugcacupugacupaagcugugauguaugaagcagaaagaagauugauuuuucacaag\n", + "cucucuuguugcucaagccccuuagugugaucuccucaucuccaucaucccagauggcaaaaaugcapaaggagaag\n", + "ucacucucugaaagagaacaaaguaauuuucugaapaagcugcagaauauggaaaacauauauuggagcuacaugg\n", + "gcgapaggaggaaggapaggcagcgcuccggcggcuccgcgccccgcacucccggacccgaagccpaag\n", + "gaggaggaaggapaggcagcgcuccggcggcuccgcgccccgcacucccggacccgaagccpaag\n", + "cgccgcpcpcgapaggaggaaggapaggcagcgcuccggcggcuccgcgccccgcacucccggacccgaagccpaag\n", + "ggcguccggucccagccuccucupagcpcaguuggcgacccugcacugacccgcgucccuccgucccgagcccgcgcgcccucagapugcccggacag\n", + "aguuggcgacccugcacugacccgcgucccuccgucccgagcccgcgcgcccucagapugcccggacag\n", + "ccuccucupagcpcaguuggcgacccugcacugacccgcgucccuccgucccgagcccgcgcgcccucagapugcccggacag\n", + "ggcaguuggcgacccugcacugacccgcgucccuccgucccgagcccgcgcgcccucagapugcccggacag\n", + "guacuaaaucaaacuucucgacuugagauacagcugcuggagaauucauuauccaccuacaagcuagagaagcaacuucuucaacagacaaaugaaaucuugaagauccaugaaaaaaacag\n", + "ggaggupagucpuguggcuguggaggaagcuacuuaaauccggauuugaucuuugcuaguucuuaucccuggaccugaacccaggcgcacaucuggauuagaag\n", + "cuuucaauggugucuuuucuugccuuguuucagaaggaucuacuaguuggcccuaucuugugccaagacugacagcaaggaagcugcuggcuga\n", + "gccuucucuuguuucccauagaagaagcucucacugagucuguuuacuuccacccaggccuuggaagaauccuguaccucucuccuuuggccaggccuuacugugaugagcacauaaag\n", + "gcggcugccpcagcaaaggaggauggcgapcugauacugaacccpaapupcugugcugaagccagagccggagccggagcug\n", + "cuaacucucapucgcuapuggcgcgcaggcgcagagcgaugcgcaaaugugcgcaggcgcuuapcugaggcgcg\n", + "cugaacaauaugugccuuuuugacucuucagaggcugugaauuucuggucuuggaagaucacaguggagcaauuggacagauaggauuuuauccuucauaucccuugcaaaagaucucuaagaaccc\n", + "ggauugagcugaccacaggccacaccagacuccucucugcuccugaggaagacapcagcccggcgccacccgcucggcccucacg\n", + "gaccacaggccacaccagacuccucucugcuccugaggaagacapcagcccggcgccacccgcucggcccucacg\n", + "agcuugaguccggacaccaacgacpacgcupaagccgacuuccggcgcccuauuuucucaccugguucccgcggcgagccagcggcagcggcggcggcg\n", + "pccaagcccgcuaccuccuguaagaggacuggapaagcpaggcgagcpuagguguuccuuugcuccucacaagucucuuucucuuuuacagcupccuacacuucgucgcacg\n", + "gcaguuucacuuuuagcucupcaccuccagcuccugcucgccggacggcucccapagagcagacgcgccagacgcgccacccucpcgccgacggucacg\n", + "acuuuuagcucupcaccuccagcuccugcucgccggacggcucccapagagcagacgcgccagacgcgccacccucpcgccgacggucacg\n", + "ccaggugcggugacucacgccuguaaucccagcacuuuggaaggccaaggcpuggauagcaaggucaagagaucgagaccagccuggccaacaug\n", + "cuccugcucgccggacggcucccapagagcagacgcgccagacgcgccacccucpcgccgacggucacg\n", + "cagaaggccccgcgccgcacacpcggaagcuccaggcuucpaaaggcugccccuggccagcccapcccggccuuuggaccupcuupcuugacucccag\n", + "ccuccagcuccugcucgccggacggcucccapagagcagacgcgccagacgcgccacccucpcgccgacggucacg\n", + "cucupcaccuccagcuccugcucgccggacggcucccapagagcagacgcgccagacgcgccacccucpcgccgacggucacg\n", + "aguggccgaggagcgcgcggcggacggcggcccgagaguagcgcgcuggccgcpaccggccgcgaccgccgcggccggcccggaggacgccugccgccgccgccgccgcgcgccuagcgag\n", + "gguaugaacgugauuucugaugaaacuggauuggaauaauuuucaugaucuuuguauauuuauauauauauauuuuuaaauuuugcauuugacuuaaagugcc\n", + "auuucugaugaaacuggauuggaauaauuuucaugaucuuuguauauuuauauauauauauuuuuaaauuuugcauuugacuuaaagugcc\n", + "ggaaggcugcguuuccggccugagaaaccgucauguuucupagucaccucagcuggcaguuaccaccguguuagaaagcagccucaggaccggccaccuccaucacuggcgucacc\n", + "gaaagaacuuugugcuuuggcugcagcgcugcgaguauaaapaugagupuugcacggagag\n", + "agucpugccgagauuupagagacgcucugaacugacugccccgcaucaccggagcgucccagcugcgaggag\n", + "cuagagccaccguccapagcagguagcugcupcuccpacacuuugcguucpcupagcgugcuuuccacgacggugacacgcuucccuggauugg\n", + "cagccagacugccuuccpucacugccauggaggagccgcagucagauccuagcgucgagcccccucugagucaggaaacauuuucagaccuauggaaacu\n", + "ggcugaggaguguccgaagagaaupcaggugagcggugagacaguuguucuuccagaagcuuugcagugaaaggaaucaaagaaauggagccguguaucag\n", + "aaaagucuagagccaccguccapagcagguagcugcupcuccpacacuuugcguucpcupagcgugcuuuccacgacggugacacgcuucccuggauugg\n", + "cucaaaagucuagagccaccguccapagcagguagcugcupcuccpacacuuugcguucpcupagcgugcuuuccacgacggugacacgcuucccuggauugg\n", + "ucucaaaagucuagagccaccguccapagcagguagcugcupcuccpacacuuugcguucpcupagcgugcuuuccacgacggugacacgcuucccuggauugg\n", + "ccagacugccuuccpucacugccauggaggagccgcagucagauccuagcgucgagcccccucugagucaggaaacauuuucagaccuauggaaacu\n", + "aaugcapcugaggaguguccgaagagaaupcaggugagcggugagacaguuguucuuccagaagcuuugcagugaaaggaaucaaagaaauggagccguguaucag\n", + "agccgcccgcgcgcggcucgcgcccuccccuuugugucgccauggcggcggcagcggcgacgagaacggcgagcgapucgagcgcggccpccugaggaggcuacgcgacc\n", + "gcucucagcuccucgaggccccuucccgcggcuggcugacugcgcccauuuccacuacgagaacguugacuuuggccacauucag\n", + "cuccugcugucuccagaccgugaapcccagccucucuggagagaaugagcugguguucpugcaggugaccugucag\n", + "gcccuccccuuugugucgccauggcggcggcagcggcgacgagaacggcgagcgapucgagcgcggccpccugaggaggcuacgcgacc\n", + "ugugucgccauggcggcggcagcggcgacgagaacggcgagcgapucgagcgcggccpccugaggaggcuacgcgacc\n", + "cgcucucagauguccucccaggupagucacuagacaccccugugcuccuaaccacupucuucuuuccucucuccaccaacuapuggccgcc\n", + "cuuauaaagcggccgcagucggagccuggcacgcucgcccagaggccugcgcccacacccucuccuguccagcccucgcccgccupcapcccggcgccguccgugg\n", + "acgcucgcccagaggccugcgcccacacccucuccuguccagcccucgcccgccupcapcccggcgccguccgugg\n", + "acuccacauaccaccagcaccgcuaauaccccuguagaaggagcucuccaggaugaagcuccagacupuuguapcucagacaaaagagaaacugcccgucuucaagaaccuucaaucua\n", + "gcucgcccagaggccugcgcccacacccucuccuguccagcccucgcccgccupcapcccggcgccguccgugg\n", + "ucucauguaagucaacaacauccupauupacccacuuucupcacugcuggccagucccaaa\n", + "aguuuucuuuuaguaccuugugccaaagagacauauccaagguugagauuaguuuccauuuucuuuguacuauuuucuggauaauaagacauuagacauuugaagag\n", + "cacgccccpccpccgcagccuccupcuucgupcagacccagccuuucccggcagcgagcgcucggccaggugcacuaggcgcugugcpccccccuuccccgcg\n", + "ccccagguccccacgccccpccpccgcagccuccupcuucgupcagacccagccuuucccggcagcgagcgcucggccaggugcacuaggcgcugugcpccccccuuccccgcg\n", + "cuagccpcggugcuagcugucagaucgcugcggcugcaagccugcaggucpcccaaaaguaggcgccguuaccaagagcgupccagccpucuuuguggcucccuugccug\n", + "auggcugacaugauggucugugaccugaaaguuguugaauaguuggaguguucugcauucauguggaagaggcuaaaggauguuug\n", + "gaagaaagcgcuccgaagagcuagagcugacacucggcgaugagcuaagacgcuguuucagagcguuupuccucugaggccccuugaccag\n", + "gagugucucugaagauacaguccaaagaaaguucuccaaaacaaggagaacagucugaagcup\n", + "ucccuccgcuccaguucgucpcpcgcggcggcggcggcgaaggaggagcgcggccpcg\n", + "upcapcuuagccugugcgcuucugcuggccuccuuuucgcccucccacccgcacugcagucuccagccugagcc\n", + "uccguaaaauugguuuuggagcuucgcugagccuccupcguapuucccpaaagugugga\n", + "uuacucagagccaaucagaagaaggcgccgcagapuggagcuuagcgaggaaauccuacaagcaucuggaaacgaccauuuucgucaaacugcgg\n", + "agauggagucucacucugucacccaagcuagagugcaguggugugaucauagcacuggagccuggaacuccugacugaagcaauccucccaccucagcuuccugaguagcugagacuauag\n", + "ggagcuucgcugagccuccupcguapuucccpaaaguguggagugagccgcagcgcccupucuggcp\n", + "agaagaaggcgccgcagapuggagcuuagcgaggaaauccuacaagcaucuggaaacgaccauuuucgucaaacugcgg\n", + "aaucacauuucagcugauaacuucucaaauauuucagcauaggcugcugugcauguagauagauauagugaaauaaugacauaagauggaaaaaucucuuccguuugucuugguguuugguaau\n", + "gagaugaugcgugugccucccugccucgugauacacuggccuguagugaaccuucaauaaauugucaugguagcuguuauugccguuacguaggauuugcggaaggcaggaggugucgca\n", + "gcuccucaagcgcggccagaauggacggcgaggccgaggaggcaccgagagcgagcgacgcugcgcpcugccagcaugcugucaccucucaauaugaucuu\n", + "agapuggagcuuagcgaggaaauccuacaagcaucuggaaacgaccauuuucgucaaacugcpuagagucuuucuccccgacag\n", + "auacacaugcagaagcugugacacgugcggaagcugugguaagugcauccuccuucagucucaguucugaaaauagaucauc\n", + "acauacacauacacaugcacacacacacucauauacacaugcagaagcugugacacgugcggaagcugugguaagugcauccuccuucagucucaguucugaaaauagaucauc\n", + "augcagaagcugugacacgugcggaagcugugguaagugcauccuccuucagucucaguucugaaaauagaucauc\n", + "gcugacupacugcugagcccgugcacggcagagagucuggupuggapcuggccuggccccucuguccuguggaa\n", + "auacauauaacaucccugcgcacaggaacaagcaacaugcauucaggacuupcacauguuaauacaccgugcauguguguggcacuugc\n", + "papagauccagcuucagacaugcaaaggaagaccccgcagaggauccugccugacacuuagcugucau\n", + "agugcccpcgacggcggcpaccggccpccaupcgccpcagaggcggaggcggcagag\n", + "ggcuuggcucccaccugugccuacgucuuccagccugaacugcuggucacgcpuggucgagauuuccauc\n", + "aaacuugaugacagcauaguggccaagcuuguuucuccupugcucuuccaaggauauucaggccgccuccggcgucgcagugucuupccgcuggaag\n", + "aaacuggcucgaagaagacpauuggccaucgcuuccggaaguugugagcuuuguuucggagcpagcucuuccgagacgcacupccggaug\n", + "gucggccugcpuagccagaggcupcggcuguggagccuguggupagcggcauugupcapaaaaggugagccgagccgacggapacgcgcugcpcgcccccagucu\n", + "gcggcuguggagccuguggupagcggcauugupcapaaaaggugagccgagccgacggapacgcgcugcpcgcccccagucu\n", + "agccagaggcupcggcuguggagccuguggupagcggcauugupcapaaaaggugagccgagccgacggapacgcgcugcpcgcccccagucu\n", + "acccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "guagupcuggagcagagccugccgcgaacccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "ccugccgcgaacccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "acaguuguguupcucacaccagugaaccgaagcucuggauucugagagucugaggauuccgugaagaucucagacuupcucagagcaagg\n", + "agaaugcugauauucaggccaggcacgguggcucaugccuguaaucccagcaguuupaggccaaaacaggaggaucucuugacccu\n", + "guugcgaccuuuccuuccccagcaauaaacuggucucuggagaucacuguagaauuguaguggaugaaaaaucaggucaggugacacuggaagauaccag\n", + "caccaguggaacagugauuaacaagcugaagguuguuaagaagcagacaugcccuuuacagacupaugucaucuacuugguguacaggaagaaugaaccggaacaca\n", + "capugapagcuuggcuuccugagaagccacccaggagccccggcuupaugacuugaggccgcgucuucg\n", + "auuccgcccgcggcgucgccacapugapagcuuggcuuccugagaagccacccaggagccccggcuupaugacuugaggccgcgucuucg\n", + "uggaagcagcauugcccaagccucccaggagugacaggaauuguuucugccugaggagacacucugcagccupcucugugagacugagguggcggucagccgga\n", + "acucugcagccupcucugugagacugagguggcggucagccggagugaguguupuccupcaccugccuuacauggcuuguuuaugaacauuaaapaagaaguugaag\n", + "agugcgguguuugucugccggacugacpcggccpcggugcgcggcggcgguggcggcpaag\n", + "cggcggcucgacpucauccpcgcaggcgcagugcgguguuugucugccggacugacpcggccpcggugcgcggcggcgguggcggcpaag\n", + "gcuggugaupcaagccpuguaccaaguccaggaugcacaugaggagcguuuguagccgucacugaaucaccucaugacuagcpcaggccucuaauucaccgcaggauuuccg\n", + "aucucacucuguugcccaggcuggagugcaguggcacaaucacagcugaccacaaccuugaccucccaaggcucaggugauccuccugccucagcccccaaguagcupaccuacag\n", + "gcuggagugcaguggcacaaucacagcugaccacaaccuugaccucccaaggcucaggugauccuccugccucagcccccaaguagcupaccuacag\n", + "aaaugugauugauaauaguaaagccacacuccucaagugccugaaauaccccucauugucuucuucagguggcaapcucuggaacagccacauaaag\n", + "acpcgcgcgcacgccgccuucgccgcuggcuccgucuguuppcgaacacgccgcgguccucgucgug\n", + "acgccgccuucgccgcuggcuccgucuguuppcgaacacgccgcgguccucgucguggugagcgcagccacucaggcugguccupupcuguapaaagugcuaaagccgcugag\n", + "gcagcuccgccccgcguccgacccgcggaucccgcggcguccggcccpuggucuggaucgcggapa\n", + "gacaugcggcgcggccccggaggcagcagcagcggcggcggcagccggagcaguaggcacccgagcagcgccagcggccgagcpcggcuuccuggccupcgcuccgguggcggcggag\n", + "guaaacuuugccuguaggaggacugaucucuugaugaaauacagaaaaaccaucucagaaaaaggaaa\n", + "gcuaaagcgagcaguccucapuuuugauguggaucgagaugccaaaaagcugaacaaagccugcaaagga\n", + "aaaguaaaggaacccgagaucugcgcapuucccuuugccgauuucucucaccucaccuuucaaaccuaaacucgagccuacuguucaccggccuagcauugcucucgcc\n", + "auaaaguaaaggaacccgagaucugcgcapuucccuuugccgauuucucucaccucaccuuucaaaccuaaacucgagccuacuguucaccggccuagcauugcucucgcc\n", + "ccggcugccucugcugcaguucagagcaacuucaggagcuucccagccgagagcuucaggacgccuuuccugucccacuggcccaguugccacaacaaacaacagagaagacggug\n", + "acccagcuggaaccapacaacgccugaguccaacccucgugucuauuuuccagaaaacpcaaugcugugagagccauuggaagacuguccucu\n", + "acauuaacgcacacaucaguuccaggccccauuccauucucugaacaucuucugacacacugacagugcugagcagagcaag\n", + "aacaaacaaguguccgagcuggcaggacgacccagcapucagccgugaggaggapagcagagcgagguccgugupagacuuccuagaggag\n", + "aaacaaguguccgagcuggcaggacgacccagcapucagccgugaggaggapagcagagcgagguccgugupagacuuccuagaggag\n", + "cagaguauuuuacaaaagccacaacaaacaaguguccgagcuggcaggacgacccagcapucagccgugaggaggapagcagagcgagguccgugupagacuuccuagaggag\n", + "ggucggcagcapcgcugagcgagcucggagcccgcgcugugcgccugcggccpcgccccgccgagcgccggugccccggcucccpccgccuucgccgcgcgg\n", + "guggcucccggcugccucugcugcaguucagagcaacuucaggagcuucccagccgagagcuucaggacgccuuuccugucccacuggcccaguugccacaacaaacaacagagaagacggug\n", + "pcuccccgcgccgcccggucggcagcapcgcugagcgagcucggagcccgcgcugugcgccugcggccpcgccccgccgagcgccggugccccggcucccpccgccuucgccgcgcgg\n", + "ggcuccccgcgccgcccggucggcagcapcgcugagcgagcucggagcccgcgcugugcgccugcggccpcgccccgccgagcgccggugccccggcucccpccgccuucgccgcgcgg\n", + "cauuucuuccuucugaupcaagacucucucuggaaupcucuuaugaccuacagucaaacaag\n", + "cagcapcgcugagcgagcucggagcccgcgcugugcgccugcggccpcgccccgccgagcgccggugccccggcucccpccgccuucgccgcgcgg\n", + "agagcaacuucaggagcuucccagccgagagcuucaggacgccuuuccugucccacuggcccaguugccacaacaaacaacagagaagacggug\n", + "aaucuuugagcggucaapaaagacaagccgacucuucagaucccuguggacacacugccugcucuuccau\n", + "guccagccggccggugagcgccupaccgcagaggugagagucgcgcccpaguccgccgccugcgccagg\n", + "gacucgcucagcagcagccugaaaacuugcuacaaguaucucaaucagaccagucgcaguuucgcagcuguuauccaggcgcuggaupaa\n", + "gaagcaccuacuccacagguccagccggccggugagcgccupaccgcagaggugagagucgcgcccpaguccgccgccugcgccagg\n", + "accuacuccacagguccagccggccggugagcgccupaccgcagaggugagagucgcgcccpaguccgccgccugcgccagg\n", + "gcguauucgaguagapcgagcccgucccgccccucgucpcgcuucccagaucugcuugagucuauggaggaaaaacuccgcpuccgcgauuccc\n", + "caggacucgcucagcagcagccugaaaacuugcuacaaguaucucaaucagaccagucgcaguuucgcagcuguuauccaggcgcuggaupaa\n", + "ucgaagcaccuacuccacagguccagccggccggugagcgccupaccgcagaggugagagucgcgcccpaguccgccgccugcgccagg\n", + "cggccggugagcgccupaccgcagaggugagagucgcgcccpaguccgccgccugcgccagg\n", + "ugugcugagagcugguggccagupacugagugagcugugugccguguauugacccgcuuccuaguccugaauuccuuucagaagcuccggcapagg\n", + "cucaagauagcagaaauagauaagcuucaacugacaaauuugguacagaagucauggaaaggaag\n", + "gagauuuuaucpagcagugaggugacuuuggcagcuaacaggccacuaguauccuacuaaagcuuuugucuggauaggagcaacaugcauguuuacagucuugcag\n", + "cagugugcugagagcugguggccagupacugagugagcugugugccguguauugacccgcuuccuaguccugaauuccuuucagaagcuccggcapagg\n", + "aguccggaauugcauguggupugcuuacuuauuugcagucucaaucaagaauucucacucucaagauagcagaaauagauaagcuucaacugacaaauuugguacagaagucauggaaaggaag\n", + "cacagacucagagagaacccaccauggugcugucuccugccgacaagaccaacgucaaggccgccup\n", + "aacaaaugugucaguuaucagcaggauccaugccgccagaguaaagcuuucuacccuuuacucccugcaaagaaacaagagugcuuaucccagcuaagcuccagg\n", + "uuuupacagaucccgaaguucgagcaucccucggauaggccpugucaggccuggucucucaggcccguccag\n", + "aucccgaaguucgagcaucccucggauaggccpugucaggccuggucucucaggcccguccag\n", + "accaucagcauauccgcuacaacccgcugcaggaugagupugcuggugucagcucaccgcaugaagcggcccuggcapucaaguggagccccagcuucugaagacagugccccgcc\n", + "guggacggagaaagugaaaggugaggcacggcccugcagauuuuccagcggaucccccgguggccuc\n", + "guguggacggagaaagugaaaggugaggcacggcccugcagauuuuccagcggaucccccgguggccuc\n", + "cucuuuuugccugcugccauuccaguaggaugugacuugcuucuccuggccaugguugugaggccuccccagcuauguggaacu\n", + "auguuggagcapauccaggaucacucaauaapcagccugagccucaagcuggaugccugagagugguaauccag\n", + "gcacauaccccaugucucaccacgaugauggagcuacagupacuuggaauccagaugugugaaggauggapuugaag\n", + "agagaucgcgagcgaggcaccagccugcagccggcccccagcacauccucagccgcacagacacucggcgagguggag\n", + "gaugcggcgcaggagcugucgcuguguuugcuuuaaccugagucuuguuccuuauugugguuccugcugugguuuugauc\n", + "agugccgccacuggaaccaggagaugcggcgcaggagcugucgcuguguuugcuuuaaccugagucuuguuccuuauugugguuccugcugugguuuugauc\n", + "guucccauggacuugucauaagacaaaagaggacagcugugcugapcapucugcagccuccuggcugugccaggaccacaccuaccaag\n", + "auccuuucugcgcagguucccgccgcacucgcgcagaccuagcgcguccaggupagguuaguguggcccpcguccgcuccucagcggauguggcagccccgagcc\n", + "gcacucgcgcagaccuagcgcguccaggupagguuaguguggcccpcguccgcuccucagcggauguggcagccccgagcc\n", + "acucgcgcagaccuagcgcguccaggupagguuaguguggcccpcguccgcuccucagcggauguggcagccccgagcc\n", + "ucugcgcagguucccgccgcacucgcgcagaccuagcgcguccaggupagguuaguguggcccpcguccgcuccucagcgg\n", + "acauuccugcuuugcaaggcuuucugcuaaggauguauuguggcuuuuguuuggauugcagcaugcagaauuacag\n", + "gcccucucaagcugcuuccagugaaugcuacacaccugcaccaugguuuguccgacauccuuagccaagaucaggauuggcuauguug\n", + "gaaaacggaaacuuggaaaacuuacaucacguggcuuaguaaauggcagaacugaaauauaauuacaagucugucuaaaugcaagacacguuguucuuuccacuucaucacgacgcgucuuuguaau\n", + "aaggacacuacaugcaacagccagugagagcaggagacaucgguguuuccagaguccagacccaccaca\n", + "uucucuuggagauguugaaauagcugaagugaaugucaapuuuguucgugaagcucauuaacucuucccuugacaaagaa\n", + "cauaacagaagaagcuuaaggacacuacaugcaacagccagugagagcaggagacaucgguguuuccagaguccagacccaccaca\n", + "paaagcupcucgucccgucccggccccgcccccaccccpagcccgauaccgguuucagaguccupcagcgugcgcgcucuuccuggcggcugcgcag\n", + "cccaggugugcugcgacggacggcugcccgcgcucggcgcucagccugccauagcccgcpaggccggagccapauccpaggcccgcgucccgccagguuucgcucugcggacgcag\n", + "upcagaugcugcggcucgccgcgcggcuccagcupcgcgguggucccgacggucacccgaaucgcapagucgccgcuggagapcucggcgcccggcpacugcag\n", + "gcgaugacccaggaugcagccapccacgacaugcacggaggaccgcauccagcaugcccuggaacgcugccugcauggacucagccucagccgccgcuccaccuccuggucag\n", + "cupcugugucugaacugcuggagccugcaggagcuggucagcapacccpccacuuccuuauccuccuugagcagauccugcagaagacccgagag\n", + "guccaggagaapcaccuacgaccugcucaccccgcuggcccugcucuucuauuccacuguucuuugu\n", + "ggaucuccuaccagagacuggugapcugagcapccugcccaucaggagucaccgcagcuccaccgu\n", + "acacugcaaaaccapaagcuccacaccauccccaucccugucgccaggugcuacaccuacagcuggagccaggacagcuuug\n", + "gcugcggcucgccgcgcggcuccagcupcgcgguggucccgacggucacccgaaucgcapagucgccgcuggagapcucggcgcccggcpacugcag\n", + "agaugcugcggcucgccgcgcggcuccagcupcgcgguggucccgacggucacccgaaucgcapagucgccgcuggagapcucggcgcccggcpacugcag\n", + "uuuguugagaupaguuggaaaguguuagcacuuugccagacuuugccagcaagauuaacugaggagaucaaauugagucagg\n", + "agaguuucugccuccacaguuaaaagcucagacapcuuupagcapccugcaaaucaaag\n", + "gcuuuccgaggcggcuggagaagugcccagacggccgucccuccgcgccccugcgcguccccgugcgcccaguguuccccgugcaggagucccggagcg\n", + "aucuaacgaggaucuagaauagcuaggauuuaugaaauaccggcuuucaaguucucuggucuccacccaaag\n", + "ggaguguuguagagccucgagccugcgaggagcgcgccgcccgccagcucccugcgucccgucccgcguccccgcguucccgcguccugcgauccgccgcc\n", + "aggaauuacauguuucggagacuaacgaguguccuuucaucccggucaugcauuccuuugacccugcagguaugacgcupcpauggcuucaucgaccug\n", + "gcuaagugcaggcggauaccccggccuuggcggcugcuugccuuucuccguacugucccugugaaggccaagaucuguaacgcugacaguccccagacauacg\n", + "ccgcaguuccugagagaagaacccugaggaacagacguucccucgcggcccuggcaccuccaaccccagau\n", + "gcaguuccugagagaagaacccugaggaacagacguucccucgcggcccuggcaccuccaaccccagau\n", + "aaaaggcccaagaggaupauacaaagagccuuuggaccgcugaacuuguggaaguucuaagaaag\n", + "aacacaggcauacacaggaagauacauucacagaaagagcuuccugcacaaaguaagccaccagcgcaac\n", + "gaacacaggcauacacaggaagauacauucacagaaagagcuuccugcacaaaguaagccaccagcgcaac\n", + "gagaguuupaucuacagcagccaaaggcuugucccugacuuuauauggcugcuccuggcgagcgacugagucguccgugaggaaaaagaggcgaggcuuuuccgagaucgucucagcg\n", + "agccgccgccgcagcucaccpcgccacauggacccagccggcccgagcgcgccccgccgcugaccgcccgcgccccpaag\n", + "gaagaacacucgcucccggccauacuugcgugugaguucugaccccuggaggagccacuguggaagcagagcaaucgcc\n", + "agcagagcgccguugcupaaugcagaagcggccgcpcuagcaagcucccggagccggcggcgcaccacc\n", + "aguuacugaacccuuaucaagcagcugccupacucaauuugccccauccauuggagauuaacc\n", + "auguuccagccuggcugaaaagccuccgccugcacaaauaugccgcgcuuuucucccagaugaccuaugaggagaugauggcccucaccgagugccagcuggaggcgcag\n", + "aauguuaccaaaggugcaagacacaaaauugucaucaguauucagaagcucaaagaaagacaaaaucuccugaagucuuuggaaagg\n", + "gcgccpuggagucauccupaaccuccacgcgacuuugguggagguaguucuuuggcagcpc\n", + "gaagaagaagaagcuuuugauuggacagucgcuaguccgaccucagagaacucagccaaucauaaugcuuau\n", + "acuguupcaaaggaagaaggagacpccacccuacaguccaggcacuagcugagccuccaaagccguggacacagcauucgaguguupapacuggucagugcugaag\n", + "acuucapaagcugugaaggcagcugcaccuccuuugucaagcuguugguuucaaccacagacacgaggacacacuugag\n", + "cagcaacgugucpuuuucggaguagagauaaacaaaaccaggugacauuuccaagccucucaaggaaappaaaaaaccuuucup\n", + "guaucuggauggaaaccaauuuacacugguucccaaggaacucuccaacuacaaacauuuaacacuuau\n", + "uuugcgagucucuaaugaagaaguaaaugcagacccgguguugacggcccacgcgcuccugaugaggcgcuuccagaguucagcgaaguggagc\n", + "ggauuuaaauggaaauaacaucacaagaauuacgaagacagauuuugcuggucuuagacaucuaagaguucu\n", + "uggugcpccagacggccgccgccggcuuagcpaacuucgccuaguccucpcugcggucgcagcgucauuuugccugaguuggaucacgcucguccacccaccccguguaaaaauaacag\n", + "agauguuuucaagcccggcuccggcggcuuuacaggcggcugcagcggcgacgaagacaacgacagcgacggcuacgccgaagcacucguuccpugaagccuccugcgccggccuugccucgg\n", + "augauucugcugcagagagcuuuaauggcaaugagacucupcacaguucaauugcuucapaacacacagcapag\n", + "auucucagcucuuggucugcaaccccaacgucuauagcugcuccaucccagccaccuuucaccaggagcucauucac\n", + "agagccagcacagccugagagcgccuugaaacucagacuccacaaucuaupaaaguguccugcuguggcaugaaauaa\n", + "aucugcauccauauugaaaaccugacacaauguaugcagcaggcucagugugagugaacuggaggcuucucuacaac\n", + "gaaugcgcuccaucacagaaccgcgacacacagccucuacauagcgucugaguugcaggcapucucacaaucacccuauucuguacgcaagaggcccuuggaauaaagaggag\n", + "gauccaucaguuacacaagugacaagaaauguuccaccaggacuugaugaauauaauccauucucggauucuagaaca\n", + "cucucugcgccupucpupugacgccgagagccagagagaugucggauuucgacaguaacccguuugccgacccggaucucaacaaucccuucaag\n", + "auaaugugucuauaaacauuccuguacaaguguucuguuugaucaccuguuuuaaauucuuuupauauauaccuacaaguggaauugccuagucau\n", + "gcgcaggagaccccpugacpcccggcgccgcuaacuggagcgaaccccagcguccgccgac\n", + "aguggcuuagaccuagaaaagaaucgugacpcaggaaaccauuacaccaccaccupcugugcucuccggcucccgccgccacccccgcccucgccuucgccuccgccuccg\n", + "agaccuagaaaagaaucgugacpcaggaaaccauuacaccaccaccupcugugcucuccggcucccgccgccacccccgcccucgccuucgccuccgccuccg\n", + "aaccgucpugugaccauugagapaaaagguuggagaaapucucuaccaugaugccuguggugcggugapaauccucpuguggcagcag\n", + "acuuuucccacaaacucucucgugagcaugaacuuuuucpaggaagaguaucagaupugcucagucuuaaag\n", + "ccucapuacacuuacaaaguaguaauagaaagcagcagaugaaggaggugcagcucuauaagaaaacguguuaagacauuccagugaugacuaagcgugcugguaag\n", + "guaaacacagcaacaaaaaaguuaugagaaccaagagcucugagaaggcugccaacgaugaucacaguguccguguggcccgugaagaugucagagaga\n", + "guugcccaccucuuggucuggaaaccuuaaaaaucacagacuuccagcuccaugccuccacggugaagcgcuauggccupcacaucgapagacucaacauccag\n", + "gagugacupugacauccuauaaggucauggugagcaaugacagccacacgupucacuguuaagaauggaucuggagacaug\n", + "auccuaauaauuauuaucaccgccggaacgagaugaccaccacugaugaccuggauuuuaagcaccacaauuauaaggaaaugcgccag\n", + "uugaugaaaguugugaaugaaaugugucccaauaucaccagaauuuacaacauuggaaaaagccaccapccugaagcuguaugcuguggagaucucagaucacccupagcaugaagucg\n", + "gcagagcagcgucagagccgcgcapacpagugagagcaggagcgacgcagagcggccgucgccgugcccpucucapcgccuggcugaagugagc\n", + "ggacuguugacauucapauguggccauagaauucucucpaggagupaacaccuggacucagaucagaagcuuuuauaupaugug\n", + "aaccauugugauggucuagauaaguguacaugcuuaggccuucugaagcagcauuugaagcugcaguccugaaaaccaugcaggccggaagaguagauaaagaaauauuuauuugag\n", + "agcauuugaagcugcaguccugaaaaccaugcaggccggaagaguagauaaagaaauauuuauuugag\n", + "uaaguguacaugcuuaggccuucugaagcagcauuugaagcugcaguccugaaaaccaugcaggccggaagaguagauaaagaaauauuuauuugag\n", + "cuauuugaguuuguggcgcgcgaggcccugcaguccpuuggcgcuupuacuggcupuccg\n", + "cuuucucpcgcaggagguuccgcaggcccaggccaggccapaggcagccgauccgucgucpuugacaguuacc\n", + "gcucgcgacuccccaccccccapcucccuaaagapccacgagcugcgaaapcpaaaggcaguuggagaagag\n", + "aaacccaccuugucccauccacaucaggacaucccagcuggaguucaaccuucaucccuucuguggcaguuaggagacugaaucaagguccagagaagguggaggaauccugauacugagcg\n", + "gaagaaaauacacagaugugcuuccuucccaguccugacaaauggccuuuccuuaaguuccucauuaauucauaugaagacaacacauuuggugacuaaauuuggaaucagaggcuuuuaaag\n", + "ccucccagcugcucugaccccaauaucaggaacuuggcaucucugaucuaacaapcaccacuaacaaggacaaagccaccaucauucaccuugauuccgcac\n", + "guaagcgguuacucacuccauggcugcagcaaggagaggcggcggcggccucggcugaagaaagaaggupagcggagagcgcaggcgug\n", + "acuuccugugcpapuppugcupcggccguuggacagugcagcccagcccpccpuccagaag\n", + "pcgccagagccpcaccugcgcaggcuuggcugcgcccucucgcgccgcacgcucugcpuuccucccuucuuccgagccucuccucuggccgccgcgcpagagaggccgag\n", + "gauuaggupcgccagagccpcaccugcgcaggcuuggcugcgcccucucgcgccgcacgcucugcpuuccucccuucuuccgagccucuccucuggccgccgcgcpagagaggccgag\n", + "cgcaggcuuggcugcgcccucucgcgccgcacgcucugcpuuccucccuucuuccgagccucuccucuggccgccgcgcpagagaggccgag\n", + "cccacguccaacucugccuuucuguuaaaccuacccuuuucuucugcgucugaacuucuggcaucucauaucugcauauggcauuuaggagaaacucccuuguaguuacucag\n", + "ccuccccupcupcugacaguaccugguggcauapcagacacgccugcagacauucucupaaapcagcagcagccag\n", + "caccpcggugaugaauupacgcaggcgcggagcccapaccacucccccugcacagacaugagaccauapaccugucupuggccucapauaggcgcuccccaag\n", + "pcggugaugaauupacgcaggcgcggagcccapaccacucccccugcacagacaugagaccauapaccugucupuggccucapauaggcgcuccccaag\n", + "auuucuggcucuggcccupuucguugucccuccccupcupcugacaguaccugguggcauapcagacacgccugcagacauucucupaaapcagcagcagccag\n", + "cugguggcauapcagacacgccugcagacauucucupaaapcagcagcagccagguguggcagugacapag\n", + "ggcuauucggagucaccagaccuggaguuugaguaugcugacacagacaagupcugcagagcucucgg\n", + "ccccgcccugcgcuggaccgcggaggucgcugcaccugaagagaacpauucccgcgcccucaccccaucuccccgcuccggucggcgcccccag\n", + "gacagaugucccugaaggcccgapacaccagccgcuaugccaggcuccaaagaacccgaggcaaaccaacgcuggucccggucuuugaggacuccccggcccagugapagaccgacag\n", + "aaaagccacccccgccucggcccggacgguuuccaagcugguuuugaagucgcggcagcuguuccupacguccgguugaccgcg\n", + "gccuggcagupaccupcccuuggaauuuuggaaguccagucuuagcaugcucugaaguugcugg\n", + "acagaaggaggaaggucagcagccccgacagccgacagucacagcagcucugacaagagcguuccuggagcccagcuccucuccacagaggacaagcaggcagcagagacc\n", + "agcauuugcucaggcagccucucupaagaugcugcuucuuccucucccccugcugcucuuucucuugugcuccagagcugaagcug\n", + "gucuauaacagucacccuuggagcccauaacauaacagaggaagaagacacauggcagaagcuugagguuauaaagcaauuccgucauccaaaauauaacacuucuacucuucaccacgauauc\n", + "gacauguauuccucugagaaaccuuggacagcagauuuugguuuaauaucugauupacaacauucagacccauuuccaguc\n", + "gauugacuucuaaagacuguugguacgugagaaagaaacccagaagaggaagaggaaagcaaaggagucap\n", + "gguuucuguccugcgcgcgcagauucgcgcagaccaggaaguggaucccguggaaugacggucacgccgcggcpcg\n", + "gauugacuucuaaagacuguugguacgugagaaagaaacccagaagaggaagaggaaagcaaaggagucapauggcucuuccucag\n", + "ucccucucaucucgcuuagguuccgucucucgugacccagugucaugaacuupaagaggcugcacupcagguccupaapcucacaccccgac\n", + "cggccgccuuugccgccuacugaagccggcgcugcucugupcucuggccgcgccuggccuggccpacc\n", + "ccacgcucccugcucagcuuccuuugccuugcagugcgcgucccpacgacuggcgcugugcgcgcucc\n", + "aagcacgaagcccuuucccacccgucpcuccupuucccgccagccgauuuccagccgucapucacgccacucgcuggaaacccugaacucugugccccccaagcccupcccccugcpa\n", + "ggaggugcauuuguugaaauuuucagugcucaaggaaaaaauccuggagcaaaauggaagauccuugguaguccaucugugauuuggaaa\n", + "gaguuugauaaagaaguuaaaaguuuuguguuuguccuggaaggcagcagccaaacaaacaaaauucaguuaccaaaggagaauaagcaaagcc\n", + "uuggauugauccagagguuucuuguacuucagauuuacguaccccupacaagacuucuccacugaauugcu\n", + "aauuacugauuuapaacaucaaaagaagauuauauuuaucaacgguccauaaggaacuauccuccaccccucuucaugcaaaaauuccacucuuc\n", + "gcaaaaugugauacuccagcauucuuuucccaagagauaugaagaucuucugacaauucaaaugagauuaguguagacuaggacuucucaaaccauuugaagaacgag\n", + "aauuacugauuuapaacaucaaaagaagauuauauuuaucaacgguccauaaggaacuauccuccaccccucuucaugcaaaaauuccacucuucaugaucaaacguaaaauu\n", + "cugucuaugguguucccuuuucaacagaugagccuacagauauuauaccacgaagcugucaacua\n", + "aguuucucpcccagcuguggcugcugccpagccccaagccuuggcpuccuugcggcgaauaggagucuggucaggcgucaggcuaguccgacgaagagugg\n", + "gcccgcguggucgucgccaccgcagccgcccgagaggagcupaggacgguggcccgcgaggcucgucgcagacaacgcggcggcgauguccgcgagccag\n", + "gccgcccgagaggagcupaggacgguggcccgcgaggcucgucgcagacaacgcggcggcgauguccgcgagccag\n", + "aaucucauuuucagcuucugccagagccaguagcaguupaaagaaggcugugcucuuugaaga\n", + "pcupcgccggagcupagcggcgcpuaggagcccggcggcaggucccagcccpcuagagaccgapccpuccpcccggcggcpacccaggcgguugaggcuggucag\n", + "gcccpcuagagaccgapccpuccpcccggcggcpacccaggcgguugaggcuggucag\n", + "gaaguggcgacugcugcpcugagcggugcucgcacgcgucucpagccagguuggcggcgcgaugaggcgcagcaaggccg\n", + "uuupupauapcauaggcuugugaapcaguccggauccggaggaacuccucuuugucccugguaggagagacacccccagucuauccucg\n", + "cuggacuacggcgcpagapuaggapcccuugaapugcgcguucccguggcggugcaccpuagguuucagucagagucacuauggcggccggcgcuggcaag\n", + "ggupauapcauaggcuugugaapcaguccggauccggaggaacuccucuuugucccugguaggagagacacccccagucuauccucg\n", + "aaaaucagacaagagcaaaagaaucugauuuuucagauacucugaguccaagcaaggaaaaaagcagugacgacacuacag\n", + "ucgacauuacucugaapacgcacaguuaucgugaapccccagaggaacccugcggapacuucaaucacaucaauguagaacucagccuucuuggaaagaaaaaaaagagg\n", + "cuccpuugacaaauggupuaacagaaaggaacuggcuaccguucggacuauuuguagucauguacagaac\n", + "cucccagcuggugcugaagcucgucaguucaccauccgcccucggcuuccgcpcgcupccgccagccucggcaccguccuuuccuuucucccucgcguuag\n", + "aaacaaaccucgccuggcucccagcuggugcugaagcucgucaguucaccauccgcccucggcuuccgcpcgcupccgccagccucggcaccguccuuuccuuucucccucgcguuag\n", + "gcaggugacagcapacaugucucpagaugcaggauguagaccucgcugaggugaagccuuugguggagaaapag\n", + "auugapaaaugcuuagaggucuccacugccucuucuacucacaagagacugaaauuuaauccagguccagaugacagcagccauggaaaaaau\n", + "gagcaggacaucgagacuuuacauggcucuguucacgucacgcugugupacucccaapaaaccggccugucauccucaccuaccaugacaucggc\n", + "aaapccgcccgugcggugccgcuggagcgccaggaccgcccuuuguagccccgcguacuccagga\n", + "aaapccgcccgugcggugccgcuggagcgccaggaccgcccuuuguagccccgcguacuccaggaguaagcgccccggagcugcaa\n", + "aaggagaucacagacaccagaagacagcagcuucugccagaacupuccuuccaugauucucag\n", + "gugucuggcuugcagacupucpaacpuguggauccgagaggcugguggcgcuucagucccguagcacacacapcggugugcaugugugagu\n", + "cccagcuggugcugaagcucgucaguucaccauccgcccucggcuuccgcpcgcupccgccagccucggcaccguccuuuccuuucucccucgcguuag\n", + "aaaccucgccuggcucccagcuggugcugaagcucgucaguucaccauccgcccucggcuuccgcpcgcupccgccagccucggcaccguccuuuccuuucucccucgcguuag\n", + "agcuugcccupucugguccupcucaguggcaaauucaacgcupcagguggccugaggaca\n", + "gacuuccuguugugcccgcgccccgccgccgccgccgcccggcgccccucgcccgcggcccggcgcggccgccgcccauggauuucaccuagugccggcggcc\n", + "gugauccacccgcgcgcacpccguccucuccgcgcpagacgcgcgcauccaccagccccggcugcucgccagccccggccccagcc\n", + "guaaauaacagcgcuggugauccacccgcgcgcacpccguccucuccgcgcpagacgcgcgcauccaccagccccggcugcucgccagccccggccccagcc\n", + "apcggcggcggcggcggcagcggcggcggcugaggapcccggccugcgagagccucagupagccggcucagcccucggccacc\n", + "gcggcggcggcugaggapcccggccugcgagagccucagupagccggcucagcccucggccacc\n", + "aacaaupacuuccacagcaaupauuuccuuccgcauucaguuuaugccuuucccaugagcgagagacuccuaggagagccgcagcccguuaggaagccaugupaacucauccacag\n", + "auuggcgcccaucgugguacaccaggaaaagupaacgaggaaaacagccgugagcgcagagugcgaggccaggcugccgcuaccgcccgcugcgccgccuccugcccucucccgcugg\n", + "accuccuuauuggugcuaguuugcagcgcccagcuccugcgccuucgcuucgcguuugaaucuggcucgccccuucguauu\n", + "guaguuucccpagagacgaaagcaggaacgagagcggagcggagcacaguccgccgagcacaagcuccagcaucccgucapuugcaggugugupag\n", + "uuucccpagagacgaaagcaggaacgagagcggagcggagcacaguccgccgagcacaagcuccagcaucccgucapuugcag\n", + "gapccuguggupauccupcugucpcugaguaugccgugupuggagaggaagccucpaaaucgcccag\n", + "gaugagcugcugcugcucgacucugaggugcauucuuuuuuugaugagaggcaucucuagguaccaucccugaccugguccuc\n", + "gacccgauuggcugaupcaaccgccaacggcuguggcguuuaaacccaagccgcagccgcugcugcucgccgagcucccggagcupupugccccacgcugaaagagag\n", + "ggcuguggcguuuaaacccaagccgcagccgcugcugcucgccgagcucccggagcupupugccccacgcugaaagagag\n", + "cuuggagaucuuacaaugauggcaaucaggagacacugaacggagaugcuacauauuccucucuugcagcaaaagguuuuagaagcguucgaccaaaccuacaagauaaaagaucaccaacucag\n", + "agcaguagcagaggcagcuucugagagccupcaggcagcagcuggcugaccaaguccacuggaagagaaggcuugugccagccpagaaggaagccpacagg\n", + "gcagcaguagcagaggcagcuucugagagccupcaggcagcagcuggcugaccaaguccacuggaagagaaggcuugugccagccpagaaggaagccpacagg\n", + "auugugcucccccggcucagaauccaaggaaagaaaggaagcgaagccucugcauugaguucuaggacagcugag\n", + "aggcggacgcucucpuuuaccugcuuccuguuaacagauugupcucccapcauaugucugcacgcugaggccgaggcggagaapcuuccugagcgucccaguacacugacagag\n", + "agauugupcucccapcauaugucugcacgcugaggccgaggcggagaapcuuccugagcgucccaguacacugacagag\n", + "aacagauugupcucccapcauaugucugcacgcugaggccgaggcggagaapcuuccugagcgucccaguacacugacagag\n", + "cuguuaacagauugupcucccapcauaugucugcacgcugaggccgaggcggagaapcuuccugagcgucccaguacacugacagag\n", + "agcacaacaaucauuuguugagagccuacucaagacucuguacuuguccgugacagucacupagcauagccuuucuccaaugacaucgcccugaacauccacucuaaaaaugcag\n", + "ccaaccaauuuguuggaaaaucagucaaaaucuaauuuugauguucugcaaguucccupccaugaagcaccug\n", + "auugupcucccapcauaugucugcacgcugaggccgaggcggagaapcuuccugagcgucccaguacacugacagag\n", + "gaggcgcugcapacgcpaaguggcggcgccggcagcggacagcucggacagcgcccapccggagcccgagcccuuggag\n", + "guugauugacuuaugugcaauuupacgcuggaguuuaccuucccuccgcagccuggaacagagccuccucugguguugcaaggaagaggcugaaugaggcagagaag\n", + "cugagugcuguccaggaggcccaguuaaagcggcucgaggugacaagaccccgagugcupagcapagcapccaggugccgagg\n", + "uucuagaagacaaugacugguugaccccacaccggccaggaagcupuuucucucccugagugupaggccgagguccugaagcaggcug\n", + "cgcpaaguggcggcgccggcagcggacagcucggacagcgcccapccggagcccgagcccuuggag\n", + "uaaagcggcucgaggugacaagaccccgagugcupagcapagcapccaggugccgagg\n", + "acagugcuccpugucugcaggcugcaggccgagcccaguggcgcaggcacugagcuguacuuauuugcugugcuauuugaccucuugguuucagagagcucccuggaccaucua\n", + "ggcuuccccacacccacggagugaagucagccgcggcccugccupaggaacuuaccgucuaccpaaagguggccagcagaugugucpccug\n", + "ggcuuccccacacccacggagugaagucagccgcggcccugccupaggaacuuaccgucuaccpaaagguggccagcagaugugucpccuggugagagg\n", + "agucgacggcagacuccggcccgcugagccacccgapucccguggccuccgcggacccggaaucupcccucgcggacccgcgccccgcccagucgccccag\n", + "pcccucgcggacccgcgccccgcccagucgccccaggugagcccagaccccgccgugapccucggcguggccaccucgccgcuccccuccgccucgccag\n", + "agucucagugccuucgcugacguuccuuugaugagcuucuaacucucucugagaacaucgcccuggacccccg\n", + "gguccaucauucugaggagcugcagugcccugcuccuuccugauggcuuagagauucuccuuaacucccagccauggaucuuggagaauuucccccgagaucagcaggag\n", + "gagugccccgccccgagcggcupcguguggcucccgcgacccgcgcggcccpucccccccgccgcagcc\n", + "gcaagcauuuugacuuccugcacuuuuauacaggauggagcuggccggaaccaaacuugucucuagaaucauacaagacucucuuuggcuguugcuuagagcugaccauuupaauaaaagauuga\n", + "gcugaccauuupaauaaaagauugaguaagauguaacaaaacaggaauucupcugugugucucaauuuauuggaagaaauuguuua\n", + "gaacucguggaucagcucuacucauuucgagacugcuauuucgagacacauaguguugaggaugcupaggaagcaacaggaugugcagaaggag\n", + "agcguggaaggagcugcpcgcpaggaggaaguagagcccpaccgccaggccaccaccggccgccucagcc\n", + "gaaggagcugcpcgcpaggaggaaguagagcccpaccgccaggccaccaccggccgccucagcc\n", + "gccggccgcpcgcpacgucagcgcugccagcguggaaggagcugcpcgcpaggaggaaguagagcccpaccgccaggccaccaccggccgccucagcc\n", + "cuccgccccgccggccgcpcgcpacgucagcgcugccagcguggaaggagcugcpcgcpaggaggaaguagagcccpaccgccaggccaccaccggccgccucagcc\n", + "uuucauuuguucacucacugupuuggaagcaaugccguuauuccucuuagcaaaaauaggcuuuuuucuauuuccuuuucuucggaguuuccuguuugugacggaaaaagugcaa\n", + "aguguccaagcuacgccacucpccpcguupagcpagugcagagcguggucguggcggcggcggugagaagagcgaggcggaggapugcc\n", + "aguuuacuuccugcguccccggacgccguagguggaaaggcgaacccugaguggaggauguucccgcugccuaaagaaugauugacu\n", + "cucaugacacuaagaaguaaaauuacgaacucacugagcuggaagucauucaacpaauugaauag\n", + "guaugaggaggacugccugcaggaggcuuuaucgcccuuuuaggagaacucguuuagcugccucguguccgcaccua\n", + "ggaaggcaauuaaggcgcccauuucagaagaguuacagccgugaaaauuacucagcagugcaguuggcugagaagaggaaaaaag\n", + "aaggcaauuaaggcgcccauuucagaagaguuacagccgugaaaauuacucagcagugcaguuggcugagaagaggaaaaaag\n", + "ggaaggcaauuaaggcgcccauuucagaagaguuacagccgugaaaauuacucagcagugcaguuggcugagaagaggaaaaaaggucag\n", + "cauuucagaagaguuacagccgugaaaauuacucagcagugcaguuggcugagaagaggaaaaaaggucag\n", + "agacacacuaugcpuugcpccupccggacggcuguuuccuguccuggugcaugguggucggacgaaggaauuguuggaaaauuuucucggag\n", + "aaacguggcauggcugcauugaacugugccucuacuacaugguuuuauuuuuaaaauaaaaaaccacuccacccucauagcauaguuccauuucuggaag\n", + "gcpuugcpccupccggacggcuguuuccuguccuggugcaugguggucggacgaaggaauuguuggaaaauuuucucggag\n", + "acggcuguuuccuguccuggugcaugguggucggacgaaggaauuguuggaaaauuuucucggag\n", + "augcpuugcpccupccggacggcuguuuccuguccuggugcaugguggucggacgaaggaauuguuggaaaauuuucucggag\n", + "ggccggacggcuguuuccuguccuggugcaugguggucggacgaaggaauuguuggaaaauuuucucggag\n", + "acuaugcpuugcpccupccggacggcuguuuccuguccuggugcaugguggucggacgaaggaauuguuggaaaauuuucucggag\n", + "pcpcaggcggcggaccccagugucuuuaucccucuuuugcacagucagcuucugcagcucucccpcuagc\n", + "aguuagcgcggugcuucucuuccgcuccpucggcuccguuucccuuuccpcpcaggcggcggaccccagugucuuuaucccucuuuugcacagucagcuucugcagcucucccpcuagc\n", + "cccuuuccpcpcaggcggcggaccccagugucuuuaucccucuuuugcacagucagcuucugcagcucucccpcuagc\n", + "cpcpcaggcggcggaccccagugucuuuaucccucuuuugcacagucagcuucugcagcucucccpcuagc\n", + "guuucccuuuccpcpcaggcggcggaccccagugucuuuaucccucuuuugcacagucagcuucugcagcucucccpcuagc\n", + "ucggcuccguuucccuuuccpcpcaggcggcggaccccagugucuuuaucccucuuuugcacagucagcuucugcagcucucccpcuagc\n", + "ucpugaggaggucgcgccggaaguggcucuagccguggcgcuucggcguaguaaggagccugcaacagaguuuuguuguuuapcgcggcaccgcaccgcucccuucaccuugcagcagcc\n", + "ggagccgcccucagcacapucugugaguuucauuucuucgcggcgcpcpcupcgcpugaaagaggcgaagcgagagcggaggccgcacuccagcacugcgcapaccg\n", + "ccuuggaccgcaguugccggccaggaaucccagugucacgguggacacgccucccucgcgcccuugccgcccaccugcucacccagcucapcuuug\n", + "gaauucuguggccacacugcgaggagaucgguucupucggaggcuacaggaagacucccacucccugaaaucuggagugaagaacgccgccauccagccaccauuccaag\n", + "gaggugcaggagaacagcucugugauaccauuuaacuuguugacauuacuuuuauuugaaggaacguauauuagag\n", + "aacccuguugucagagguacacccagagcaacuccacaccpugcaugccacagcaacuccaucuuaaauaggagcugguaaaacgaggcugauaccuacupcugcauucccagacgg\n", + "aaccgcgcuaggagcgcggagaapcauupagagcggcguucguggcggagacuagcgcuccggagcacpcacgacpcaccuucucggcugcua\n", + "apaccggugagugucgcuucupcagcgcccaguaaccgcgcuaggagcgcggagaapcauupagagcggcguucguggcggagacuagcgcuccggagcacgg\n", + "guuccaggaaccacccuuugagaagcacpucuauaccacacgcacagaagaggaaacgaaacgaggcaaaggaaaccagucccuuuacucgcgcccag\n", + "ucuucgcggcgcpcpcupcgcpugaaagaggcgaagcgagagcggaggccgcacuccagcacugcgcapaccg\n", + "aapcgccpaaaguuucagauccacggcugcgcpccacgagcccacccgaacgccgaccacugcuuuccgucgacuucuauuuccupaacgcgcgaaagcaaacccaa\n", + "ccaguaaccgcgcuaggagcgcggagaapcauupagagcggcguucguggcggagacuagcgcuccggagcacpcacgacpcaccuucucggcugcua\n", + "paggaupcagguugupaugcuccgccguuccgcgaccacccgccuccccggcccagcagaaccpuccaggcupaggugcuagcgguguau\n", + "ggacuugcaggaaaugcagccpaggaupcagguugupaugcuccgccguuccgcgaccacccgccuccccggcccagcagaaccpuccaggcupaggugcuagcgguguau\n", + "aaaggccaacugaggcaaccauagcccagaagacugguacuccugagaggcagaugaagugguggucuuugauaucgagccupaugcccupcacaugag\n", + "gucgcuucupcagcgcccaguaaccgcgcuaggagcgcggagaapcauupagagcggcguucguggcggagacuagcgcuccggagcacpcacgacpcaccuucucggcugcua\n", + "uuucauuucuucgcggcgcpcpcupcgcpugaaagaggcgaagcgagagcggaggccgcacuccagcacugcgcapaccg\n", + "gaaguugcuagcupcagagacggccacgcgguugcaggaguaagagaucccucuguggcga\n", + "guaguggccacagccuuacaggcaggcapugguuggugucaacappccaacapuaccagagccaagacccucggccuccucccccgccgccuuccugcag\n", + "ccuuccucuccuagccuaaggcgugcaaacagagcgccacupaggcugaaaccuuuaggccgaugcuugcuugcaaggucaggcaagcuggauucugguccccaccuuugcagagagaacagcg\n", + "agacaccguguccucuugccupagapaagcagaucugaggacaucucugugccaggccagaaaccgcccaccugcag\n", + "agacaccguguccucuugccupagapaagcagaucugaggacaucucugugccaggccagaaaccgcccaccugcaggugaggcccggaccccugcccag\n", + "gaaucccagccauucccpauccgaggacccaaapcagaapagaacccggcuuacccggccauccupaaaaauggcccc\n", + "accacucagacaccguguccucuugccupagapaagcagaucugaggacaucucugugccaggccagaaaccgcccaccugcaggugaggcccggaccccugcccag\n", + "accacucagacaccguguccucuugccupagapaagcagaucugaggacaucucugugccaggccagaaaccgcccaccugcag\n", + "cugccugccgccaaagcpuccauccupuccaccuccaaguguggccacupaupcacauggaaguuucuagaacaaggcuugcaacuugacaagugcau\n", + "acaccguguccucuugccupagapaagcagaucugaggacaucucugugccaggccagaaaccgcccaccugcag\n", + "auaauucauucacucgccucccacupaguccacaauggccuaaugcacguuucaagcucuugguuucuaucaaacggcucgcucaag\n", + "aguccccapagacacuuaapaaauuaaacugcagagugcaagagaugccucagucaagucagccaaaaacacgcpucauccccaagccccagagag\n", + "acucapugcuaggcgccuauuggaggagaaggccgagaggagcaggacggcpaagaggagugcggaacccgcpag\n", + "agauuuguucucpuucacagugcucagapaggagapaggaggugaagacaccuggcapaagcapccuccauggaupugcauucacggcapag\n", + "uucucagcaggaugugcacagapcccaggaggagccucaggagccggacugccguuggccaaccg\n", + "gcuuugaauugaaggcgagugccucagaauuugcauccauuguucugucuuuccupaaguuauucauccugguggccagcccaccgacaaa\n", + "acuuugagccaggccuguuaaaccaaguucucagcaggaugugcacagapcccaggaggagccucaggagccggacugccguuggccaaccg\n", + "aauucpcpacuuccpucagccggcguuggcugagacgucuucgugccacggugcugccuccuuuccaagcgcgacccguugag\n", + "auccccuugaccacacccucauucucagcuggugcucaugaaggacagaagagucaaugucaguacaaugugagugaapcugag\n", + "gcpacuuccpucagccggcguuggcugagacgucuucgugccacggugcugccuccuuuccaagcgcgacccguugag\n", + "apcuggcuagagacccagaggcgcagagcggagaggccugcggcgaggauggapccuggcagugcgguugcugcgcggcagcag\n", + "ggcguuugcuguggcggcuaggcccgcgugcgcuggagaccuccgcgcuggcccccgcgagccuccugcccuggcccggcgcugcggcucugccgcggcggcagc\n", + "cggcugcccucgcucccaggccccgcagucucauuugccgcuuccgacgcgugaccccggcgcgcuagcguccpaccggugacaggcgcpugcgccaagcaguccc\n", + "cguccguugapcccgcgccgcauggaggccggcugaggagcgccgcugccucgccucgguacgccgcgcggcgcggacggcgc\n", + "gugauuucugccuuugcaggccggagcccucaugacuucagugaccugcuucugccccucuaggucuaucagccacagucucugcaaguuuccaagagcagcagaaaaugaacacauugcag\n", + "pccagugucauucaaagauguggcuguggauuucacccaggaggaguggcagcaacuggacccugaugagaagauagcauacpaugugauguuggagaacuacagccaucuaguuucugugg\n", + "gguaugauuaucaccaagccaaacaucaucauggaguggaggugaaggaaguggagcapagaggagccguggauaauggaaggugaauuuccaugucaacauaguccag\n", + "ggagugacgcpcccpcgcgacggucucggcggcggcggcggcggcgacagagcgagcgcggcgcpccacc\n", + "auuggagcuuggucugccauccugaacugugguuccccugccucccagcccggcugugagugcucagcgacccugacaggcugacag\n", + "gcpcccpcgcgacggucucggcggcggcggcggcggcgacagagcgagcgcggcgcpccacc\n", + "ggaauaguacuugccccapaguuuccagaapaccapcugugaaaagucuaccaapccugguuagcuapaapcucaucapaagauuugauguuugagcuaggcucugagga\n", + "gugucaccuccuucagcaggacagaggcuaagaggagucccugugupcagcuggagccuucag\n", + "ggauccagccuccacccpuccgcggcccgcgcccugacucaccuccuggcccccgccccgccugccgcgccacug\n", + "acucuuguuucgcuccuugacaacccuggcpuucgcuggcugcggccccggcuccggcccccgcaggagcag\n", + "cugccccuapagacagacucgccugcugugccupucggaaggauucccgcugcucauccucauccuggauacagguggcaggcgccaagccagg\n", + "guagauuucagcucccagaggcucacuucuuguuuuggagaaupccucgaccuuuuucaucuugugaaacccagacucaaug\n", + "gucuuccaaggcuuuuuugccgcuggugucaggaguauuuucauauuccaauaccgauaaaucuuugag\n", + "uguuaaccuugaugccugaaagaacuggaaauuaugaagauagauucagaagucaaauauguuaacuaacugcauugaagaguagaagaaaacaauagccua\n", + "ggaucaguguccuucapauguggcuaucgauuucagcagagaggaauggcggcaccuggacccuucucagagaaaccuguaccpaugug\n", + "ggugcuagaagucggaccggaaguggaaguggucuuccaaggcuuuuuugccgcuggugucaggaguauuuucauauuccaauaccgauaaaucuuugag\n", + "agccuacaaapaggugcuagaagucggaccggaaguggaaguggucuuccaaggcuuuuuugccgcuggugucaggaguauuuucauauuccaauaccgauaaaucuuugag\n", + "ucuuccaaggcuuuuuugccgcuggugucaggaguauuuucauauuccaauaccgauaaaucuuugag\n", + "ccapccpccpccaugagcgcgccguccucgaguccccgagccgcggagcccgcccgcgccccucpccgccccgcgucccucgcc\n", + "apuaguuuagauagaaauggagagapaauguguccccagaaggagaaaggaggaaauug\n", + "ggaaguacgguuuucggapaucagacucagacucacgucgcacuccucgcaguuggacuggupaacupaacacuggagaccugauuucuaacugacgcuaccgucgcggccgccg\n", + "uaaaaggccccuccccaucuucagaacaguccupuucugagccugccauccaaggaacucaggaggaggaguugacagucucuucguuccuaaccagugupacgacuucagc\n", + "agcgccggaaguacgguuuucggapaucagacucagacucacgucgcacuccucgcaguuggacuggupaacupaacacuggagaccugauuucuaacugacgcuaccgucgcggccgccg\n", + "guacgguuuucggapaucagacucagacucacgucgcacuccucgcaguuggacuggupaacupaacacuggagaccugauuucuaacugacgcuaccgucgcggccgccg\n", + "aacaguccupuucugagccugccauccaaggaacucaggaggaggaguugacagucucuucguuccuaaccagugupacgacuucagc\n", + "cggaaguacgguuuucggapaucagacucagacucacgucgcacuccucgcaguuggacuggupaacupaacacuggagaccugauuucuaacugacgcuaccgucgcggccgccg\n", + "guacucaggaccccapaacaaucugcaugagguggagacagcccaapcagcgcuuccuggugagc\n", + "uccupuucugagccugccauccaaggaacucaggaggaggaguugacagucucuucguuccuaaccagugupacgacuucagc\n", + "gaacaguccupuucugagccugccauccaaggaacucaggaggaggaguugacagucucuucguuccuaaccagugupacgacuucagc\n", + "ggcggugccagugccpcugcpucpcucaccaugugcuggugcuacagcugacagagcggcuucpacgcggagaacgaaucc\n", + "agacagcaggagagcagagaccaccccacaggaagauaccgcugcuuccgaaucugcapuaaaauccuccacccaagaagccgccaggcuccuccuacccccaagaaaggca\n", + "aacggaaguggcuguggcucaggcuguuguggccapuagccuuaggcggcggcagagaaacuaacgucuucuuuagccuccaaggagaaauucuaguauucuuacccpaugag\n", + "cuuccugugcuaagugccccccaaaugcuuccugugucaauaacacucacugcaccugcaaccauggauauacuucuggaucupcagaaacuauucacauuccccuuggagacauguaacg\n", + "acaccaccuccucaaagacaaccgapcaggaaagaggugaguggaggcugauccccagacccuucccag\n", + "cuauugaaacucaagcgauuacagacaauugcucugaagaaagaaagacauucaacuugaacguccaa\n", + "aggaaaggugguuggcuuacggcacaguagagagcuuccapcuggcuggcgupauacccguaccacagaa\n", + "gcucccpcugagguggagccgcpacgccggcapuuguggcgcagcagucuccuuccugcgcgcgcgccugaagucggcgupcguuugaggaagcugg\n", + "pcugagguggagccgcpacgccggcapuuguggcgcagcagucuccuuccugcgcgcgcgccugaagucggcgupcguuugaggaagcugg\n", + "caaugaucuacaggagaggaagaaagcuaucuapacgagaucuagaaucaacugagagagaugcuuaaaaaucaccaguuacuuuaauga\n", + "ggaguuucaagcagccgcggcggcagcagcagcccuggacgcagcagccaagcucuucgcuggcucccpcucucccpuuccucucauugcaggcugaag\n", + "guaaugagaggcccuaagaucccagaggaugccauaagaggaaaagucapaguguugaagacucugccuccuacaaauau\n", + "uuuaaugcuaaaaagaaggauccaggccaaggapuaaagaaaaugcagaaugcaaauuauccccucacupauauccpagcgaagucccugagcugcugaggaagcuuuacgccuaaggag\n", + "aagaggaaacugguucagaacugupcagccagcccaagagcacgcagcuguccapcagaguccacgucuggcuucuuugucuggaguugaaagccagaucaccaccuucug\n", + "gccggcucucaacuuugaggaguuucaagcagccgcggcggcagcagcagcccuggacgcagcagccaagcucuucgcuggcucccpcucucccpuuccucucauugcaggcugaag\n", + "ccgucuggucacaaugaucuacaggagaggaagaaagcuaucuapacgagaucuagaaucaacugagagagaugcuuaaaaaucaccaguuacuuuaauga\n", + "upcagcgucgcuucuuaggaggaggaggaagaggaggaaggapcgagcgaggaggauggcggagucpcuccugacg\n", + "agucuuuuaucaagucuugugaaacugaauaguuugaccuuagcuagaaauugcuuccaguuguauccagupugguccaucucaguuuucuaccaucuauucccucaac\n", + "pcagcgucgcuucuuaggaggaggaggaagaggaggaaggapcgagcgaggaggauggcggagucpcuccugacg\n", + "gcuggaguguaguggcgcgaucuuggcucacugcaaccuccgccucccagacucaagugauucuggugccucagccucccpuagcupauuacag\n", + "aggaggaggaggaagaggaggaaggapcgagcgaggaggauggcggagucpcuccugacg\n", + "auaccgagugcgucuaguuucuacucaagapacuacuauaucaaaagcuuuuuguuacgguuuucagaauccuaag\n", + "uuaggaggaggaggaagaggaggaaggapcgagcgaggaggauggcggagucpcuccugacg\n", + "uucuuaggaggaggaggaagaggaggaaggapcgagcgaggaggauggcggagucpcuccugacg\n", + "ucuuaggaggaggaggaagaggaggaaggapcgagcgaggaggauggcggagucpcuccugacg\n", + "gaggaaaggacaapcggagagagagaagcuggcggcacugcccgucucugauupcagcuucucuugccccg\n", + "gcagucccgacgagcaacgcguuuguagapupugcgcacgcucugucccugcgugaccuuccgaccccgcuguccucaccgca\n", + "gacgagcaacgcguuuguagapupugcgcacgcucugucccugcgugaccuuccgaccccgcuguccucaccgca\n", + "aguacucccaggcucucaucpagcagcupcuggcaggaguccucaggcagcagcauccgccgaggcccacccpccacccccpuuccaggccuggcaugguucapccc\n", + "aggcagcagcauccgccgaggcccacccpccacccccpuuccaggccuggcaugguucapccc\n", + "agugacaagguaauuaagaugaagaaagcaaauguagcaggcacagcgupuggacagucagcuguccgugucuucugcugag\n", + "ggagugugagcpcucgguuuupccgcggcpagcpagucgccgccacucgagugcgcaggcgccuggcgauuaccggucucaccauggagcggaaag\n", + "uuuupccgcggcpagcpagucgccgccacucgagugcgcaggcgccuggcgauuaccggucucaccauggagcggaaag\n", + "agucucpcggcgguguccggcgcgcpcggccugcupcpcugaapuuagcggagcacpcaaggcggagagugacggagucggcgagcccccgcggcgacag\n", + "agaacaaacuccuaccucuguuugcaacuaagaguuacaucccccaugccaagaccuuccgaggcgucccagap\n", + "ucgucgupcuucupcagcuapcugcccgccgcgcugccugcgccggaccpcpuccagucccpcpccgucgcpagag\n", + "aaauaacaucugcuuugcugccgagcucagaggagaccccagaccccucccgcagccagapcuggagccugcucagaggugcuuugaag\n", + "ccgccauugccgccaucgucgupcuucupcagcuapcugcccgccgcgcugccugcgccggaccpcpuccagucccpcpccgucgcpagag\n", + "gccuggugcugcugguggugcugcugcugcuucugaggcacupcupccugugccuuaucggcuggaacgaguucauccugcagcccauccacaaccugcuc\n", + "cagcuccaccaggagucaggagugaauccccucupaacgaggcacuaggaagaagaacuuccagcccaggag\n", + "acpaggagcaagaacacagaacagapcaagacagcuccaccaggagucaggagugaauccccucupaacgaggcacuaggaagaagaacuuccagcccaggag\n", + "aauccccgcagcgccaccgccauugccgccaucgucgupcuucupcagcuapcugcccgccgcgcugccugcgccggaccpcpuccagucccpcpccgucgcpagag\n", + "auccccgcagcgccaccgccauugccgccaucgucgupcuucupcagcuapcugcccgccgcgcugccugcgccggaccpcpuccagucccpcpccgucgcpagag\n", + "aacuggacauuagcuucuccugugaaagagacuuccagcuuccuccuccuccucuuccuccuccuccuccugccccagcgagccuucugcugagcuguag\n", + "gcaaacuggacauuagcuucuccugugaaagagacuuccagcuuccuccuccuccucuuccuccuccuccuccugccccagcgagccuucugcugagcuguag\n", + "cuggaaagugccugagccagcugccccagcggccucagcacuaccaaguuggcacaaagcuccccaaauucggapcucapaaacgaguggapaugaggag\n", + "ggcacugaccagccugcaaacuggacauuagcuucuccugugaaagagacuuccagcuuccuccuccuccucuuccuccuccuccuccugccccagcgagccuucugcugagcu\n", + "acggccggacacuggccccggaagaggapaggcgguggcupaucggcagcagccguccaupaacacccagccggccccacucgcacpuagagacapcgcccugcuggagcugag\n", + "aaucagagcgcggcugagcggccccgcagccaacccccgaggagcggccggcuggcguccgccgcgcccaggaguup\n", + "agagcgcggcugagcggccccgcagccaacccccgaggagcggccggcuggcguccgccgcgcccaggaguup\n", + "agagccgcagccgccuagcupagaggcccguccpcuggcucugagcgccgcacggccgucggaucccpacgccpcccpcugagcgccgcggcccgcgaggaggagcaccg\n", + "acaacuuggaauguccugcaauaucuaacauguaagcacgucgaaucauuuucuagacagaaucugaaccucugugucucucagucuuucucucuuucucauucucuuucaau\n", + "uguccugcaauaucuaacauguaagcacgucgaaucauuuucuagacagaaucugaaccucugugucucucagucuuucucucuuucucauucucuuucaau\n", + "auaugaacucucccgccacccpaacaguggcugccaccguuuguguuuucccgaguuugaauucuugcag\n", + "gauuuacugaacauggcugcugaaauguauaacauuauugugcauuauugcuaccgugauaugcggauuuauauugcaauugccucuggauucagaaaaacacccuucacagugag\n", + "gguuucauaugaacucucccgccacccpaacaguggcugccaccguuuguguuuucccgaguuugaauucuugcag\n", + "aagcuuuccccggugucggcggcagguggaauuuccacgcuuuaucugcgccugcgccgcgcpauucgcgguccgagcugaagagguucgcgguccgg\n", + "agcuuuccccggugucggcggcagguggaauuuccacgcuuuaucugcgccugcgccgcgcpauucgcgguccgagcugaagagguucgcgguccgg\n", + "uuucacuucuccgaacccugaggcagugugugaagcupacgccagccauguuccagaccgcuuggcgccag\n", + "paugaggccagaacugagaaggaaggauuaacuccaaaggaucauguguccaaagaaacagaguccuucagacug\n", + "cccugcggcagagacgacggaggcggaagcaacccgaucccggaggcggcggcggcppagccggagccgccupauguuca\n", + "cuuccagccaggcguccaucuuaagagacgcuggucuccucaggcgugaagauuggauuupuupacupaagucucg\n", + "auaaauauaacuauaccuuguggaaaggacagcuuuuaaauaaaggaaaacuuuuguguuauauuucucugaggucagccacucgugcuuuuuugccuaucaaacu\n", + "ggaacuacagcgucgccgccupuugugucgccgcgguaggcgcugcgcucugagcgcagcgcaggccccguaccgaccgcccgcccgcccucuguccgcg\n", + "ucaguagcugugcucugaccccagaapauauguuuccguagcaccgaaguguccagccauguuugaaucuacccuuguguucupaupcpcaaguggacacgcgugugcgccuggcucug\n", + "aaaaccccaggauggaagaucccuacugagguuucauucuguuccucugauuguacagaaapcugcuuuggccuagacag\n", + "acccaauccuggagacuccugcggaugccauuaugaggagcaagaacgcgaapccucpuccgcu\n", + "cugcuucccagaggccpauccggagccgcccgaagccggugccgcagcccccugcgcccccggugcccccg\n", + "cuccpucccucugucacuuccugaauccugcuuccugcuucccagaggccpauccggagccgcccgaagccggugccgcagcccccugcgcccccggugcccccg\n", + "ccugcuuccugcuucccagaggccpauccggagccgcccgaagccggugccgcagcccccugcgcccccggugcccccg\n", + "agaggucagcaggaagucgauacguggcugccgucuguccccgcugaggaggugcagcagccggag\n", + "aguccaauucccgcaccuuugaggcccaapagcgagccggugcugcugcaggcugaggcugcggcagaggcggcgaggcgcpcggugaggacggacag\n", + "ucaccgacuuaguccaguucccugugaucucaaaacaauuguugcagcaggcuccuggcagucucaagcaguucaucuucuugguguacug\n", + "cacagucaccgacuuaguccaguucccugugaucucaaaacaauuguugcagcaggcuccuggcagucucaagcaguucaucuucuugguguacug\n", + "uuugaggcccaapagcgagccggugcugcugcaggcugaggcugcggcagaggcggcgaggcgcpcggugaggacggacag\n", + "pagcgagccggugcugcugcaggcugaggcugcggcagaggcggcgaggcgcpcggugaggacggacag\n", + "ggaacaugaagucacugagccugcuccaccucuuuccucucccaagagcuaaaagagagcaaggaggaaacaacagcagcuccaaccapcagccuuccugagaag\n", + "gcaaggaggaaacaacagcagcuccaaccapcagccuuccugagaagaugcaaccaauccugcuucugcuggccuuccuccugcugcccapcag\n", + "gugcugcuguggucggccaacaagguguuugaggagcugacggacaucgagaggcaguuccacaaggccuucuacacggugcpccuaccucaacugcgagcgguacuccgupccuccuggac\n", + "gugacugcggccapcggcuccacgacggugacupucapcaggagaguguggaggccagugaggapuccacacccaucggugaggcaggagucagg\n", + "auggcgcugacgugagcgcgaacucgcacugcccagapuggccgccgccuaagcugcagccgccggagccgcagaaacaagaggccgagccgugucgaag\n", + "ggaaaauggcgcugacgugagcgcgaacucgcacugcccagapuggccgccgccuaagcugcagccgccggagccgcagaaacaagaggccgagccgugucgaag\n", + "gagagcugagagguggaaaauggcgcugacgugagcgcgaacucgcacugcccagapuggccgccgccuaagcugcagccgccggagccgcagaaacaagaggccgagccgugucgaag\n", + "cgcaccucugcccgccucggagaccccgcagccccgcgccgccgccuggccccggccccggccccuccgcpauccuggccccuccucgagcgccgccaccggccgcc\n", + "gaacagccagcgcuggaggagcgccpagacucugccgucggugcgugcgcggacacgcacccgucccccuuggucucgccgccagcc\n", + "agagguccaccpagagcpccccccpucccccpaccgccpagugccuggauccgacggcaucgac\n", + "agcgccpagacucugccgucggugcgugcgcggacacgcacccgucccccuuggucucgccgccagcc\n", + "guccaccpagagcpccccccpucccccpaccgccpagugccuggauccgacggcaucgac\n", + "pagguucccugcucaagcucucuucucuugucugcugccaugugagacgugccuuugaccuucugccaugauugugaggccuccccagccacgugaaacu\n", + "acuucugaaugaacagugaaucuauuacugaggaaaaccagaggaagccuguguagauagguaucaauuagauaccagcuacuggaagagcuuucucagagacugauuaaaaaauucuccacuagau\n", + "gaccuugcpcuguuugugcugapacagcuuuauuuaaauaauaauaugcgugcaggcgcccugcaugauuccuggccgcgugcuuucua\n", + "aaaauucaagccagugauuuccuacpuggaagacgagucucugauugucccccaacacaucuugagaaagagagaauacuuucg\n", + "uuaccuuauuggauuccagaucuguucapagaacuupuggauagcaagcccucuggaaggap\n", + "accggccpcccgcccccuuggcaaugucuucagcccgcugcucuccuaacuuaagcauuuauuccacupauagaagcggcaggagcagcguuggcaccggcgaacc\n", + "auugupagccgcuccccucggcuccgccacgcuccccucgacugcgcuccagccupcgcgcccggccgccgccgccuucgcugccgccacpcccgucuucuuccuccuucggcucccagg\n", + "agaagcpaguagagaucauucgguuugcaugcuuucacuucucagcugucacugugccauggugccuacuuucagccagugaaccaacucaacupccpc\n", + "uuuugucugcucacauucaccccuuucuccuucagaucacuucucccupcucccaggcccuccugcagcagcccccgccupcc\n", + "acagcccuuuuugaggagcugcgaapugcacaggccaguagcuggagguucuuugguacccccuccuuuuaggupucagcagacacapcgcc\n", + "gcuguaguggcuucgucuucgguuuuucucuuccuucgcuaacgccucccggcucucgucagccucccgccggccgucuccuuaacaccgaacacc\n", + "gcugcgacgcuguaguggcuucgucuucgguuuuucucuuccuucgcuaacgccucccggcucucgucagccucccgccggccgucuccuuaacaccgaacacc\n", + "cgccgcgcugcgacgcuguaguggcuucgucuucgguuuuucucuuccuucgcuaacgccucccggcucucgucagccucccgccggccgucuccuuaacaccgaacacc\n", + "guugucgacccuguucuucpagacccuaccagguuccguucaccugccccgcccccgacucagcgaggccuccucuggccpcguccucacggcgcuccauaa\n", + "uuccuucgcuaacgccucccggcucucgucagccucccgccggccgucuccuuaacaccgaacacc\n", + "guguaagupuagcapcuggcpaccuuccucgcpccggagcgcggagcgcugccccagcccuacggcacucp\n", + "ucugugaaguagguacuauugucccaauuuuuacauaggaggaaacggcucagagagaacuuagguccuuugaccgagguccugcaggug\n", + "acaguuuccugcugaaapcuacuauucuuacucccauccccacucuacagaugagguaauggaggcccaggaaaguuaagugacuugucccagaugacaccgcug\n", + "pucugagguuuggugacugcpcaggccpcagcugucugucuggcucuuuuugacagcccccagugcgaaaggcugccagc\n", + "ggapaagucccgagacaaapaagcgccgccgccgccgccccgcucgguccuccaccuguccgcuacgcucgccpcugcggccgcccgag\n", + "ggcugcgcgcggagcpcuccggapaagucccgagacaaapaagcgccgccgccgccgccccgcucgguccuccaccuguccgcuacgcucgccpcugcggccgcccgag\n", + "aacucgcpagcgucaccguccugcgacgcuucagaggauccuuaggccucaguggucuuugacccccggccccaggaccugaccccaaggaaaccuccpaccuguggcuggagag\n", + "gagaaucagauugugcccacaaggcggaaauguacgacagcpuuccggugaccacgaaggcggcaaaggcgacgga\n", + "agccucggagcgupacacapccuucugucugucuguauuucccuccugcucucucucucucucucugccuuuggcauauaccucuccuccuccccacuccccuuucccugcccac\n", + "ccugcgccucccaugcupccccacccagcucpcccagcacccaccugcccaguccaccagcaacaucgcupagucgugcugcuuuggcucucccagaacaagcc\n", + "guuuauggccgcguuaagucugagugccgcuuugaguuguugaaugaagugaacuucauuugucagcguucg\n", + "uggccaguguucpcuguggaaaaaccauagagucuauucagcugaguccagaagaauaugaaugucuuaapaaaaauc\n", + "aguuuccgccgcguuuauggccgcguuaagucugagugccgcuuugaguuguugaaugaagugaacuucauuugucagcguucg\n", + "acuguaguuuccgccgcguuuauggccgcguuaagucugagugccgcuuugaguuguugaaugaagugaacuucauuugucagcguucg\n", + "gcgagaugcgugacgagcgaagcgcgugacggaggagcgguuggccaacgcaguggcggcagucgguguaaacaaggccucgcgccgcugcpuccugcgaccgcuccuggcug\n", + "agcacgcuuugcuuucaccaaacccaaggaggugacaggaggagcccccgcacaggaccuaagaaugcugugaccagaag\n", + "gaagcgcuuucuuccgagapauuucgauuggucggucagagagguuaccuggaaauccaacaccgcccaacaccccucccgcuccccaguccpacuucgauag\n", + "aguggcggcagucgguguaaacaaggccucgcgccgcugcpuccugcgaccgcuccuggcuggupuggucucgcgupcgguuaccgccggcuucagupag\n", + "gagaugcgugacgagcgaagcgcgugacggaggagcgguuggccaacgcaguggcggcagucgguguaaacaaggccucgcgccgcugcpuccugcgaccgcuccuggcug\n", + "agcgcuuucuuccgagapauuucgauuggucggucagagagguuaccuggaaauccaacaccgcccaacaccccucccgcuccccaguccpacuucgauag\n", + "auaagcuagugaagcgcuuucuuccgagapauuucgauuggucggucagagagguuaccuggaaauccaacaccgcccaacaccccucccgcuccccaguccpacuucgauag\n", + "aggccaagugagguuggugcapaggaggugcagcaaauuuacaauucauucaggcccucuuggacucagaggaagaga\n", + "agagagguuaccuggaaauccaacaccgcccaacaccccucccgcuccccaguccpacuucgauag\n", + "aaucuuucuucaguuggugagcuapuagcgcacuacgguucacucuugcuuucuuugcuucacaggauuggagaag\n", + "uuucgauuggucggucagagagguuaccuggaaauccaacaccgcccaacaccccucccgcuccccaguccpacuucgauag\n", + "aguuggugagcuapuagcgcacuacgguucacucuugcuuucuuugcuucacaggauuggagaag\n", + "ggauuucgauuggucggucagagagguuaccuggaaauccaacaccgcccaacaccccucccgcuccccaguccpacuucgauag\n", + "aggaagccgcgagaugcgugacgagcgaagcgcgugacggaggagcgguuggccaacgcaguggcggcagucgguguaaacaaggccucgcgccgcugcpuccugcgaccgcuccuggcug\n", + "ucccaggacaucaaagcucugcagaaagaacucgagcaauuugccaagcuccugaagcagaagaggaucacccupauauacacaggccgaugupcucacccupuucuauuug\n", + "gguugccpaaucuggaccugagcgagaagcacgauccccggccgcccccgcucuugcaucccccugguccuacugcugugcuugcuggcgacgguucguuccggaagucag\n", + "ucccaggacaucaaagcucugcagaaagaacucgagcaauuugccaagcuccugaagcagaagaggaucacccupauauacacaggccgaugupcucacc\n", + "aacgcuucgcuuucguuucccgcuggcgccuggcucccuccpuuucguuucccgccggcgccuggcucccgccagguuucguuuccgaggcpccgapcggcgucgcugaggcgccc\n", + "uaacuccaaucacuggcaacuccugagaucagaggaaaaccagcaacagcgupaguuupagaggcauuccauaccagauucuguggccugcaggugac\n", + "paguuupagaggcauuccauaccagauucuguggccugcaggugacaugcugccuaagagaagcag\n", + "uaacuccaaucacuggcaacuccugagaucagaggaaaaccagcaacagcgupaguuupagaggcauuccauaccagauucuguggccugcaggugacaugcugccuaagagaagcag\n", + "gagucugugacagccaccccaacacgugacgucauggccaguapaagaugagcugaggaacugugug\n", + "gagaacagucagcaaaagcauuggucccaccugccccuuugcuggaagcugugaagucagcaagacucagaggcgccacugcccagccugcagguugcagaagugcuuagaugcuggc\n", + "uguuggaggucggcgccggcccccgccuuccgcgccccccacpaaggaagcacccccgguauuaaaacgaacpcggaaagaagcccucagucgccggccpaggcgagccg\n", + "ggcgccagcpaaacgaaagcgaagcguugcpaaacgaaagccggaggcccaggcpcaggagcccupcupcgcccuuccggccucuccuccucgccgcgag\n", + "acuucugaaugaacagugaaucuauuacugagaaaaaccapuggccuguguauauaggucgcaauuagacaccggcuucuggaagagcuuucccagagacagauugaaauauuccccaguagac\n", + "auccucgucgucgcccggcacagcgcgagcpcgagcggcgcpcggccggagcgccgaggcccggcc\n", + "pcpcgcgccgcugcauccccauccucgucgucgcccggcacagcgcgagcpcgagcggcgcpcggccggagcgccgaggcccggcc\n", + "gucgcaguucagcccagcugaggccugucugcagaaucgacaccaaccagcaucauguccaugacacupuacupacauccgcp\n", + "gcuggcaaacauucagcagcacacccucucaagauuguuuacuugccuuugcuccuguugaguuacaacgcuuggaagcaggagaupcucagcagcagccaauaggacaugauccaggaagagca\n", + "gcuggcaaacauucagcagcacacccucucaagauuguuuacuugccuuugcuccuguugaguuacaacgcuuggaagcaggagaupcucagcagcagccaauaggac\n", + "agaaggaagcaagauggcugcccuuuaggauuuguuagaaaggagacccgacugcaacugcuggauugcugcaaggcugapacgagaacgag\n", + "guagagaagcagaaggaagcaagauggcugcccuuuaggauuuguuagaaaggagacccgacugcaacugcuggauugcugcaaggcugapacgagaacgag\n", + "aaaguuccggcuucggccuccgccgcugccgccgccgcugcuacagccgccgccgccgcuguugccgcggcuuguuauucuuaaa\n", + "gcggagccggaggagccgccgcaaagauggaggagccgucgaggaggugcugccgccgcugccgccgccgcugcugccgccgccgcccgcgaagccggagcucgagccgcagcgg\n", + "pcucggcapcpuccpcggagcgcpugcggapcggaggcggcuccggcgcccgcucugcccgccgcupuccgaccgcgcucgccuuccuugcagccgcgccucggcccc\n", + "gcggaggcggcuccggcgcccgcucugcccgccgcupuccgaccgcgcucgccuuccuugcagccgcgccucggcccc\n", + "gucacgcuagaagagccgucugcugacugcacgugugugugcacacucgugugcauggcugugaacuggaaugugugacugugaccuu\n", + "gcuaagcccccacugccpaggcpugaupccggcccapccugagapaapcapugcacaggagacacggcaggacpacc\n", + "agaacgugcuguguggaugcggcgaaacgcugaggcgcggccuucgcuguguggupacucacaagaccgacgucaag\n", + "cguaccagcguccaggcpuuaccguggagacagaacgugcuguguggaugcggcgaaacgcugaggcgcggccuucgcuguguggupacucacaagaccgacgucaag\n", + "guuaccguggagacagaacgugcuguguggaugcggcgaaacgcugaggcgcggccuucgcuguguggupacucacaagaccgacgucaag\n", + "guguggaugcggcgaaacgcugaggcgcggccuucgcuguguggupacucacaagaccgacgucaag\n", + "gugcuguguggaugcggcgaaacgcugaggcgcggccuucgcuguguggupacucacaagaccgacgucaag\n", + "cuuuuugguguaaaucuggacucuaauucuguaauauaucaaggaaucucguaaaaccgacacuaaaacgucccugccuacaaaucauccggccaaauu\n", + "ggugcuuugugugcugccggcpcgcgcggcgguccpcpugacuggcggcpcgccgcggucpcuggcugccpcagc\n", + "gugcugaacgaggaupuacuccuccaccaucaaggacaagauccugaccauugaugugaagcccgguuggaggcapcacacgcaucaccuuugagaaggaapaccag\n", + "acuaauuaaaugccaucupugguuccucupuuuuugaguccaucacccaguucagaucgagucagaggccaaggaggagaac\n", + "caguuacacacaggcagugguaucugugagcagcucuguggacucaaagguuuucucccugagaggcaugacccaggccagcugauucaucagaaucag\n", + "ucugacagaggaggcuccgugucugcagcuagugugucaacucagcguuucuccucucgucccug\n", + "agugcpucugacagaggaggcuccgugucugcagcuagugugucaacucagcguuucuccucucgucccug\n", + "ccucuaaagupaccaagacuuucaccucuuaggauuguagucpauuaaaagauuuucccg\n", + "uuuagcagauacuuucagaaauggauacauaagaaauggcuggaaaucaaaugaauguccaaagaagagcuuapucuuaguaacauucuuuuuuaaaauaacugucugccaaa\n", + "gaacugaccaacacuggaugaauuugaccauuucuuaggagacuggaauguuaaguuucuauaaaugaaugaaccaguucucucuuguuuggagca\n", + "gaaccuuaaucucaucuuuaaaauaaggagaauuacugagugaccugaaggacccuuuucagcuggaaagucu\n", + "gguuccaaacagccguggcccgcggugucuggcgcucggupugugguugccccuaguuugaggccugcccgauuacccgcaagacuupcagccccpcgccgcuccgaccacgacapaaag\n", + "ccaaacagccguggcccgcggugucuggcgcucggupugugguugccccuaguuugaggccugcccgauuacccgcaagacuupcagccccpcgccgcuccgaccacgacapaaag\n", + "aguuugaggccugcccgauuacccgcaagacuupcagccccpcgccgcuccgaccacgacapaaag\n", + "cuuuucaucuuuaaggaacugaccaacacuggaugaauuugaccauuucuuaggagacuggaauguuaaguuucuauaaaugaaugaaccaguucucucuuguuuggagca\n", + "gugguugccccuaguuugaggccugcccgauuacccgcaagacuupcagccccpcgccgcuccgaccacgacapaaag\n", + "gagucaccuggcuugcuuagugaccaucagacgagaccagaccucucacuuggauauucugauucaguaggugugaguuggagccaggaaucucuacaaacucauuccag\n", + "gccgapucaccuauaccuuuccagucagguccuucuugagucccapagcagagcgagacugcagcccugucagucaa\n", + "gcucacuccaugugaggccccagucpcagccaccugccgugccuguuggaaguugccucugcc\n", + "gccauaaagaaugcugaupagaaccauuuuccuaauuuucaaauuguugagcuguuugccaua\n", + "uuuuauuaauaugcugaucuguuuuaucuucucaggccauaaagaaugcugaupagaaccauuuuccuaauuuucaaauuguugagcuguuugccaua\n", + "aupcpagapuuaggcuugcaggccgcggagguggcguaggcpagcgacccgagcccacucupcugugcuguucggacccucagccuggcga\n", + "augcagucgugauuggcacuguaaapucuccaauuugauguacuguuuaaggaacuucugcagaccccaauuugaacaguguagugucag\n", + "aaugcagacpauapugugugugugapapccuguauggcaacugcucuugccccagcguccccaaaagugcagaggcagcggcugcagcauccagccagcuuggaugucuggccu\n", + "uuucagugccuguguaauagaapucuguauuguaaaagaagucaaaagcagccuugaauaaucggaacccuuuugccagaucaucuaaugucaau\n", + "cpcugcgcgcggcccgcugcaaaaauagugcccacgugcgugcgcgucucucgcccgccggcuggccggucagcccgucagccccgcapccacaccggcccc\n", + "augcacaaagcapucaucagaagccucucgauucaaaagaugauaauaccgaaaaacacugcccagugacagugaauccuuggcauaugaagaaagcuuucaaagucaugaacgaauuaagaag\n", + "uuuuauuuggagauaucugcuaagccacuucugcugaauauucuguguugaucuuugacggaacuuggacaccapag\n", + "augcacaaagcapucaucagaagccucucgauucaaaagaugauaauaccgaaaaacacugcccagugacagugaauccuuggcau\n", + "gcacuuguuaagacaugcuaucgauuguuccaugugaaauacuggcaguaguaaggccuccuggugaucuuucccagauggccucauuagcuuuugcuuagaaguuccaguugugag\n", + "guacuucucccagcagcuggucucuuacaguuacaggaugugaagaagacuuguugugaauuuuuggaaucccagcuucacccugucaacugcuuaggaauccpcuuuugcugau\n", + "agaacagaggccaguggaaacuauuaggaagacucagcuuuucaugaaguuagauuuuuagccugagcuuuaagucaaagaaagaugaccuggacuuaaagugccuu\n", + "ucuuuggcuuccpcgcacgcuacucugucgccgccgucagaccggaauugccggugccgccgccaccgcugucugugcgcccaccucugcugcuacc\n", + "guucucuuuggcuuccpcgcacgcuacucugucgccgccgucagaccggaauugccggugccgccgccaccgcugucugugcgcccaccucugcugcuacc\n", + "gcacgcuacucugucgccgccgucagaccggaauugccggugccgccgccaccgcugucugugcgcccaccucugcugcuacc\n", + "acucugucgccgccgucagaccggaauugccggugccgccgccaccgcugucugugcgcccaccucugcugcuacc\n", + "cucugucgccgccgucagaccggaauugccggugccgccgccaccgcugucugugcgcccaccucugcugcuacc\n", + "gugguuuccggaacuucgcccgcgucucupcuuuugcucugucaggcugguggcguuuuggugucuucguuuguu\n", + "cuuccaggccuuacucuuggcapuuaauauuuggacagagaggagagaaggcucuuguagcgucuagaaagacuaag\n", + "augaugcuggaaaucgacuucgguuucaguuggaguuggaauuugugcaauguuuagccaacccaaauuaccuuaauu\n", + "uucuugcccaaagagguuacuucaaagacaaagcuuuuguuaauuaucuuaaauacuugcuuuacuggaaagacccagaauaugccaaguaucuaaa\n", + "acagugccccpaccggaagapagccgugguuuccggaacuucgcccgcgucucupcuuuugcucugucaggcugguggcguuuuggugucuucguuuguu\n", + "aagaauguccagauuauauuaaauaccauagagguuuuauauccaccagcauccuuuucaaggauaacugaacag\n", + "aaccuucuaagucucagacacguaaacccaaguguggcaaaggaacucauugcucucgaaaugcauau\n", + "acgaaacugcaaaggaaauccgaauugcuugguugguauuggugagcauauuugguuaggagaaauagaugaaaauaguuuucauaacaucgaugaucccaacugugagaggagaaaaaag\n", + "aacucauuugupccugacuaaccuuggagccacuuguuaugucaacacauuucuucaagugugguuucucaacuuggagcuucggcaggcacucuacuuauguccaagcacuuguagugacuac\n", + "agauuauauuaaauaccauagagguuuuauauccaccagcauccuuuucaaggauaacugaacaggucuuguuuuauaguaggcauuuuuaacaauucuauuuucuucuguacuacuauuuccauu\n", + "gugucgcaggagcacaucgagaccgcuuaccgcaucuggcuggagcccugcauucgcggcgugugcag\n", + "cccucpuaacggucgcgagaggccgcuugcaugacccugacaucggcagcpagcggcggccag\n", + "acuggagagacgccpcgcgcgcgcgcucccucpuaacggucgcgagaggccgcuugcaugacccugacaucggcagcpagcggcggccag\n", + "gaagaugacacggauucauuuuucucaaacagcccaagaaccuuuauuuuccaauaagagaauauaacaauuucuguacacu\n", + "aaguuuauacgagaccuaguuuccapaagaacucacugaugccgcgapagaupuacuggaugauggucuucagccuuaagg\n", + "gaguugguguccuuugaggagguagcugugcacuucaccupaggaguggcaggaccuggaugaugcucagaggacccuguacapacgug\n", + "aguuucacccagcaagcgugagaacagguacugcuuccugagcaccgccagccaccggcaccaagaccggccacaucccagcacugcccaccucug\n", + "cggccgcggugaagcgcggapcggcgcpcaccpccpccpcugcagccgcagcggcc\n", + "acagucacugagaaaauucuuugugcaggcucaccuuccccucaucucccccacucuuccugauccugcagcgucagaucccagccugcaguaucagaccucaaaaggagccucuggugucuu\n", + "augcgccccgacgcucpcccgcpcuccuuucuccgucgccgcuccaggacgcggccucpagcccuaccpacggagccgcpccugcgacuucccccggagcuggccugag\n", + "pcccgcpcuccuuucuccgucgccgcuccaggacgcggccucpagcccuaccpacggagccgcpccugcgacuucccccggagcuggccugag\n", + "ggcgcuucugcggcggauccucpcpcagccpccggcgcgucacguggcccacggcguccapcgaccagccgcpccgcapc\n", + "aggccgcpccgcpcugcpcpaaagccgapcgupupcgcucupucagcagagacggcuguccgcccgcupcgccgcugcggauuug\n", + "aaaaauugaguuugcauagccpcgcaguggcuuacgccuguaaucccagcacuuupaggccgagccagguggaucacgacgucuggaguuggagaccagccugacaaac\n", + "uuugccaacagaaagaucuggccuuuaguaagcacucuauaaaugaauaaagaagcauugaaaacaagccucagaagacaucuggaaucuucgugcgccagauuggagguauaga\n", + "gaccaaaagaggaagauagucuupacccuugcaugguguuucaaapuggugaagaacuaag\n", + "pcuccagagcuugauauauuucupaauuuggaauaugcuaaacuagauuucugcccuagacuaaacaucuggcuguggacucaau\n", + "aaaucaaaccaggaauaaccuaugcugaacccacgccucaaucguccccaaguguuuccugacacgcaucuuugcuuacagugcaucacaacugaaga\n", + "cucuccgccuccggaagcgcpcgcgcggcgccpagcccguucapccgcpagugcgccagcgccgcgcgupcugugguggccgcggcucucag\n", + "agaguauuauggucugucgugcgcuggcugcugcuuuucugcuccuggaagcggccaappaagcggcgagucaac\n", + "aucugacaggauggcaucugaugacuuugacauagugauugaggccaugcuggaagcucccuauaaaaaagaagag\n", + "gcuggagcacaguggcgcguucucggcucauugcaaccuccaccuccupuucaagcaguucuuaugccacagccuuccaagcagcupacuacag\n", + "gaugagcaacaaaggaaagaaguuaaaaaggauuauccuagcaauaccaccagcagcaccagcaacaguggcaaugagaccaguggaagcagcaccaucpagacaagcaa\n", + "auggaaucuugcucugucacccaggcuggagcacaguggcgcguucucggcucauugcaaccuccaccuccupuucaagcaguucuuaugccacagccuuccaagcagcupacuacag\n", + "gaaaaaacuaccagccugaaaaugcauaguguuugcuaccuuauugcuuuuagcacaucuagaaagacacuaaaccca\n", + "agucuuggucugucacccaaccuggagugcaauggugccaucucggcuggcugcaacuuccgccucccpuucaagcaauucuccugucucagccucccag\n", + "ggucacacauugcugcccaggcuggaguacaguggcgugaucuuggcucacugcaaccuccaccuuuupuucaagugauucuccugccucagccuccugaguagcupauuacag\n", + "ggagccaguugauaaucugaguccugaggagcgugaugcccgcacaguuuucuguaugcaguuagcugcccgaauucggccucgagaucuggaggacuuuuucucugcuguaggcaag\n", + "aucggaacucacgucguucuaapcauugccuacguggaauucugugaaauccagucugugccacuggccauupcugacupcagcgguugcupagugccuaucauuguacaggcuucacag\n", + "aggcagcuuuaaccupugupugaggaugacacugugaugcuccuagaggugguucaugaggaauggacgaauaagugguuggaacugauaugagaacacauagcugaagaagag\n", + "ucgugaaggaaggaggaacacacuccaaguucuuaucacagcacacaagucauucauguagcaaacuau\n", + "acacaggaguguugccauguuguccaaacuggucucgaaauucuggagucaagcagucugccugccucguucuccaaacgugcupauuacaggcaugagccacuacgccuggccaaguauucg\n", + "ggcacucguggcugugguggcuucggcagcggcuucagcagaucggcggcaucagcgguagcaccagcacuagcagc\n", + "caccagcaggcagcuggcuccgguuuupuaucupcuccaggcagaagcacagccuccccgaccugcccuacgacuacggcgcccuggaaccucacaucaacgcgcagauc\n", + "uagagacagcguuucacuauguuggccaggcuggucuccaacuccugacauuggcuuauguucuuuuuaaaaaguuugaug\n", + "acucguggcugugguggcuucggcagcggcuucagcagaucggcggcaucagcgguagcaccagcacuagcagc\n", + "gcgcuuucuuaaggcccgcpcggcgcaggagcggcacucguggcugugguggcuucggcagcggcuucagcagaucggcggcaucagcgguagcaccagcacuagcagc\n", + "gcugugguggcuucggcagcggcuucagcagaucggcggcaucagcgguagcaccagcacuagcagc\n", + "cuuccaggacaucuguuuccucuguuacacauugcugcaagaagcaaaacuuguuucugcuuuggagccuuuga\n", + "cuugcuuccugcuucgccuccgcgccucgcgcuaupacagagcccccgauccgccagcaccaccugaggauccagaaaccgccccagcgauggaagaggaucaggagcuggagag\n", + "ccuugcuuccugcuucgccuccgcgccucgcgcuaupacagagcccccgauccgccagcaccaccugaggauccagaaaccgccccagcg\n", + "gccuuccgucggucgguccuugcuuccugcuucgccuccgcgccucgcgcuaupacagagcccccgauccgccagcaccaccugaggauccagaaaccgccccagcg\n", + "gcgccuuccgucggucgguccuugcuuccugcuucgccuccgcgccucgcgcuaupacagagcccccgauccgccagcaccaccugaggauccagaaaccgccccagcg\n", + "uucgccuccgcgccucgcgcuaupacagagcccccgauccgccagcaccaccugaggauccagaaaccgccccagcg\n", + "uugaaaaugcaacugcaagcuccccggugaaacaaauaccgccuucaaccuucguauucuguggugacucaucucgcacgugaccccccucccucuucaag\n", + "uccgcgccuuccgucggucgguccuugcuuccugcuucgccuccgcgccucgcgcuaupacagagcccccgauccgccagcaccaccugaggauccagaaaccgccccagcg\n", + "guucacaaauuuuaagaaapagaauaaagugaaaaaaaucucagaaggaauccacucaacagacgag\n", + "gauucacuuccaaagagacauauuaugcaaggaagcaacuuggaagaggaaagaaaagaagucaggaauggcccuuacucag\n", + "agucucacacguugcccaggcuggagugcaguggcaugaucccugcucauugcaaccuccgccucccugauucaaaggauuuuuccaccucagcuucucauguagcugagauuacag\n", + "gauucacuuccaaagagacauauuaugcaaggaagcaacuuggaagaggaaagaaaagaagucagga\n", + "auccuccaguacagucaagcuuucagaugacugcagucccagcagauacaugacuccaaucucaucauccacuccaaaacuaaccuacagaaacuauaag\n", + "agaccuaaggagaagacugaccagcuucuucugaagacuucugcccucuaaagacuaaggccuaauuccacugguuucuuugaauuccgugguccuaaguccauuuucag\n", + "acaaaguuucuguggaaagaccuacggacaaagacaucucuccuuggcagagugagcuaggauuaccagcucuucagccgcagcugaaggcpagucc\n", + "gugcgguggcggcggcggcgguggcggcggcgacugcugcggugaaggaggaggaggagccgagcpcgcuggcaccgaggccugacc\n", + "aucuuugguccagugcgguggcggcggcggcgguggcggcggcgacugcugcggugaaggaggaggaggagccgagcpcgcuggcaccgaggccugacc\n", + "auucccuauaaggagccccugcuggugcaccagaacuaccpccaucugcccaacugccccagacucuggcagupcccccgauggcagupcaccuccccgugaaaccugccaag\n", + "agaaaacugcugaggaaggcacpapuggcugugcgagguacugccpcugagcucucauggaggcucucucuguucucugaagugccuuuggaguuuaugucugcac\n", + "cucuuucucacugcccugaaguuaaccagcgcaguccuccgugcgucccgcccgccgcugcccucacucccggccagg\n", + "uccuaagucagacuuugugcuugcucucccuaggaaugcugauaccugauucuaguuauggauauggaggcaaggagaaguuguuagg\n", + "acacuguuaucgccccgcccccucggagcuuuuucuccaguuaacugucggaguagcpcuccggcgccpcgac\n", + "gcguagucpacgccpccgaggcuuugcuapaacacuguuaucgccccgcccccucggagcuuuuucuccaguuaacugucggaguagcpcuccggcgccpcgac\n", + "gcuapaacacuguuaucgccccgcccccucggagcuuuuucuccaguuaacugucggaguagcpcuccggcgccpcgac\n", + "gugugugugcgguguuaugccggacaagapaggugaccguggcggcggcggcggcggcucuguuuauugucccucucg\n", + "agaguguaucagaagaagacacaacuugaacacauucuucuucguccugauacauauauupucaguggagccauugacgcag\n", + "cugcucucagcggcggcggcapcugapcacagccagcpcggcgcgccgcggacuccaaggcagcccgccaaaag\n", + "aauccugaacaucaucauaaaaagacagucaccaguccugcucaucuggaggacuguucucacaaucuucagcaaggag\n", + "acaaaaucucucucugucgcccaggcuggagugcaguggugugaucuggcucaccgcaagcuccgccucccpuucacgccauucucuugccucaaccuccugaguagcupacuacag\n", + "aaucuugaaagaaaucccaagcaagagcugcucuccucagcauuuugcccagagagaauuuggaapuuacuggacaggauuacuacuuaaaag\n", + "agauaaccaacugcaaucuugaaagaaaucccaagcaagagcugcucuccucagcauuuugcccagagagaauuuggaapuuacuggacaggauuacuacuuaaaag\n", + "aagcaagagcugcucuccucagcauuuugcccagagagaauuuggaapuuacuggacaggauuacuacuuaaaag\n", + "agacaaacccaaaacauuuaugugcauagaaaaaaauucuggaaggucguacacagugaauuucucugagugaaaagauugugg\n", + "ggcggcapcugapcacagccagcpcggcgcgccgcggacuccaaggcagcccgccaaaag\n", + "pccgcgcgcggcggcccgaggcggcggcpacgcpacgcgaggacgcggcuuugugcaggcpucgcpcgccc\n", + "guggucguugcucccugacuggccgcggcggccuccaggaagcggaaaagcaapcggucgagcupccgccgcgccccacugcucgccgcgcugcucuuugaccucgcapugugaagaag\n", + "ugapcuuugcuaugaccucaguccccucacggagccacgacugccccuugcugccacagccuuuccaagacccugcccggcccugccccauccucagccccgagucacc\n", + "agauucaugcugguccuaucccacupaccgucgcugccacucagccagagagccagcaucuuggcaapcupccuggagugaagcuggaapcuagc\n", + "auccugccugcguuagcggcgguggaggaggaggcagagaggaguggapcggaguagacggaggaggcugcugcagagaagaaagugucagagccg\n", + "aagguaagauaauuupcugcgagcapugcaucuuggagcpagaccuugacaucaaacaggaagagucuuaccpacaaggagacaacagcccagagaggcugucacccagg\n", + "gcuuuuugccauccupcgcuagapaauugcgcugcaauucauuaaauugccucucagucucaacagaugacaaaccccuugcccuugccucugauuuaag\n", + "uucgcggugccaccgccccgcccacgccuccucgccggccuccgagugcgucacgugacpucgguggcgcuggcgguugcugucagcugauucccpuugguggcagcggcgguagcagca\n", + "aguguguucagaagcacagaagccugaggapugaupuggcugcpcgaucagcugagcug\n", + "acgugacpucgguggcgcuggcgguugcugucagcugauucccpuugguggcagcggcgguagcagca\n", + "gauagugaacuuuacuucuupacggacacacacaagaagaagaggaagcacuccucugaugauuacuacuauggag\n", + "gacagugguucuuguucugagugccgauaaaccagugugaaggaggagagagguggapcugguauuuuggaggauucagcauagaagaacagucugcauuugugauacaccag\n", + "auauuucgucuuuggaaucgucacagaagaaaaagaaaaaguccagcccacagucuacugauacagcu\n", + "gcucupcucgacugaggcucccuggccgcucgcgcuuuucucuccuucuccaagauggcggcgaucggcggcguugaggcpauccpcgagccgagugaag\n", + "cucuccuucuccaagauggcggcgaucggcggcguugaggcpauccpcgagccgagugaag\n", + "accugguccuguagacpaaggagccuggacacagugacacauucucaaaggcccugcaggaccacc\n", + "gcuuuucucuccuucuccaagauggcggcgaucggcggcguugaggcpauccpcgagccgagugaag\n", + "agaccupcucgagaccauaacuguuuggcuuuaacaguacgupcggccggaauccpaguccggugacccpcuguggucuagcauaaaggcggagcccagaagaapcpu\n", + "gccgaccauagcagacaaagaccccagccaagcccaguggcgcugcggcguucaggacccccguaggccaaaaucccagcccagcccuuccccauguggccagacaaapacgguggagccgg\n", + "ccpaguccggugacccpcuguggucuagcauaaaggcggagcccagaagaapcpu\n", + "gcagauuccucaucuacaggcgcuaguggacuggagacggcuggcggcugucccpacpaagagagcuuuggugccugapaagauggcuuapcccggucccuuaagg\n", + "guggaggaggupccaccgaggaggcuccucgccccccaggcugccaccugguguaccagugaucagccupccacagcaggcccccapuagcc\n", + "gcagaggcgccauuuugcgaacggcgagcagcggcggcggcgcggagagacgcagcggagguuuuccugguuucggaccccagcggccgg\n", + "auuuugcgaacggcgagcagcggcggcggcgcggagagacgcagcggagguuuuccugguuucggaccccagcggccgg\n", + "gagcagcggcggcggcgcggagagacgcagcggagguuuuccugguuucggaccccagcggccgg\n", + "acugugccaacauggcggcgcccagguccuaauucpaaacgugcaccuugacuaauucgguuuucuguggcuacgagagcag\n", + "auucgcccacccacugugccaacauggcggcgcccagguccuaauucpaaacgugcaccuugacuaauucgguuuucuguggcuacgagagcag\n", + "aaaagaaagaaagaaagaaaaggaggcacagagaaaugaagaaagcuggucaagaucaucacacagcaaggaagugaug\n", + "acccacugugccaacauggcggcgcccagguccuaauucpaaacgugcaccuugacuaauucgguuuucuguggcuacgagagcag\n", + "gauucgcccacccacugugccaacauggcggcgcccagguccuaauucpaaacgugcaccuugacuaauucgguuuucuguggcuacgagagcag\n", + "gccccucgcauuggcacaagcuguaucccauugcccapagaucgccaaucacccaucaauaucaucuccagccaggcuguguacucucccagccugcaaccacuggagcuuuccuaugaggccugc\n", + "pccggagccgcagcccgaacgagcggaccgagccgaccpcaggugcacggcugcpacggcagcggc\n", + "gagccuacuucgcaguagcaggaccgcugcuguggagcuggucgcaggcggugugugccggucgccuagucaggagaacuaguccucgacucacg\n", + "guaguuugagcucccuaaaagaggaagguggacucuacapacaaacaguuggaugcugcaauagcaug\n", + "guuccucaccacuccccaccgcuacaacuccaaaaccacuuaucccuacagaggccagcaucapucuggucagacuuccucagaguccaucuccauccccggagcaucugu\n", + "cpaacpaagccpacccagaacucuugucuuucaggauaaaguggccaguguguacgaagccccpcuuuuuccuggaccuggagcccaucccpagccuuggacgcugugcpag\n", + "guuugucagacaccaguccggaccucagcucucgaucuaguucccgaguaagauuuagcucccpaaagcgugccugaaacaagccggagugagccu\n", + "acucggucaccgcpcugcggcggcupcpcuuucpcgcccgcpacgguuccgcccucucacugcacccccpcuucucuucgcaag\n", + "ucaaaaguagcuagcguaagaggaagauuuugcgagguuccccccacuuuuuuuguucuuaaaaagaacaaa\n", + "ggaucacagucugaaacgacagcaaggaagagguaggcapaaaacuaacuggaaggaaguuuaaauacagaaagagcaaaguauuaucuaacuauaaca\n", + "ugcacucggucaccgcpcugcggcggcupcpcuuucpcgcccgcpacgguuccgcccucucacugcacccccpcuucucuucgcaag\n", + "aguuaccuagcaaacaaucuucauguuaagacugagcucaaauaccacuucuuccuuaauggucccugugaucacuccaggaaauguaau\n", + "acgacggacauaagaaagcucgaaaugcuuaucucaauaauuccaauuaugaagaaggagaugaauauuuugauaaaaauuuggcacucuuugag\n", + "cpccccgcagcgccggacgcugguugcgcgcucccaggcgccgagcggccccpcacgcgcgcgcgccaccggcccggcag\n", + "acggcpccccgcagcgccggacgcugguugcgcgcucccaggcgccgagcggccccpcacgcgcgcgcgccaccggcccggcag\n", + "ggacgcugguugcgcgcucccaggcgccgagcggccccpcacgcgcgcgcgccaccggcccggcag\n", + "aupuaguuucacauacagucagcaugacuguauagcagcgguggcacugcuauucuuccaucug\n", + "gguuggaaaguccaagccauaggacccaguuuccuuucuuagcuuacguuaucuaccagagcaccgupcuguuacuugccuugaguuggaagcgguucgcauuuauaccg\n", + "aagagccuuggaauucagacucuguggagguggcuugagcuuuucauccuggugaccacagaccuggaacaaacuaaagccagacacauacu\n", + "cuguuucugccuuccpuuugagaguuuaggacccupuuggupucagapagapuaccuuccucccggaccgcupugcapcgccuupuguagcacccagaaca\n", + "cgugagugcaucuccauccacguuggccaggcugguguccagauuggcaaugccugcupagcucuacugccuggaacacggcauccagcccgauggccag\n", + "agguucucuuacaucgaccgccuaagagucgcgcuguaagaagcaacaaccucuccucuucgucuccgccaucagcucggcagucgcgaagcagcaacc\n", + "gcagguucucuuacaucgaccgccuaagagucgcgcuguaagaagcaacaaccucuccucuucgucuccgccaucagcucggcagucgcgaagcagcaacc\n", + "aucgaccgccuaagagucgcgcuguaagaagcaacaaccucuccucuucgucuccgccaucagcucggcagucgcgaagcagcaaccaug\n", + "caugguaguaggcacaaupcugguaccacgugcugaacapccaaggcgacaucauuauucagaccacacccauaugcagcauuuguagcag\n", + "aucgaccgccuaagagucgcgcuguaagaagcaacaaccucuccucuucgucuccgccaucagcucggcagucgcgaagcagcaacc\n", + "agaaccguggacuucagccccauccccagcagcccacgaagacacugacccugcagaaacgccugucagguuuaugaggaucccaaccaggcccccaggcuccacccgacucucgugaag\n", + "auuaguccuuggcucuuaucuuggaagcacaggcgcugacagccgucccagcccuucugucugcpccugaaccaaacggugcc\n", + "auuaguccuuggcucuuaucuuggaagcacaggcgcugacagccgucccagcccuucugucugcpccugaaccaaacggugccaupaacugucugcacagg\n", + "ccacuaagcacagcuggcauccugagcuccucuucugccgcuuccaacaggucaaggaauaaggcucgcuaucggaccaaagccgugagcucugagguggaugagagccucuuuggagauaucaag\n", + "uccccagcccapccagagcgacagccccauugugcugcuccgagauaagcauacccuucaaaaaacucucacugcuuupcuuggaucgcaagccagagaccauccagcucaucacccpac\n", + "aacacuapccuuggcggcgccgaggcggcagcagaaguccggagucapcguguggcugaggag\n", + "cucugcucgccccccaucucaccccccaagcggauacuggucuucucgucggauugcccaugcacuuguugcagaaacagccaag\n", + "gaccaggccuccucuucccaccuguccagcagcaugaaagcagcaugauuggccgaccgcaggagaagcccccagaaccaggcccccaacucagccaucugcggaggucaag\n", + "gcccuggcuguggagaaugcugaaggaagaagacgcagaagcaggacgacccugaaagauucagccucuucauccucaaacag\n", + "acacguggcgccuggcaagugaacaaucgcggugagapcgcgccgcagcuccucaacgccgcaacgcgccggcccaacugcaggaag\n", + "gguuauaaaauuauacaccauggcccuccuaaagacacucuaggaaaaccaugucauccugaucuuaaaacaccugcaagaaagagcacaguacuucaccauua\n", + "acacguggcgccuggcaagugaacaaucgcggugagapcgcgccgcagcuccucaacgccgcaacgcgccggcccaacugcaggaaggucugugcucuggagccapuaaau\n", + "gcagcuccucaacgccgcaacgcgccggcccaacugcaggaaggucugugcucuggagccapuaaau\n", + "gaguccguuugaggaaguccccgaggcgcacagagcaagcccacgcgapcaccucuggapagcgccugcag\n", + "aaaggaaacccucccagacccucugaccaaapacpupacuuccuggcacugcapccccuugccug\n", + "uccguuugaggaaguccccgaggcgcacagagcaagcccacgcgapcaccucuggapagcgccugcag\n", + "agagugaccagaugcucapcaggaguaggcagcuggucuaaauccacagagcagaggaauagaucugauuaaugapagucaaguccugag\n", + "gcuguacuuuucupuguguguuapaggcuauguuccugacccucccccucupugagaapuccccgccauguccucp\n", + "gcuuugcuguacuuuucupuguguguuapaggcuauguuccugacccucccccucupugagaapuccccgccauguccucp\n", + "gcpuggcpaacccpucucgaggcgccagccucgcccccgcccccacgacccuggcggccucpuccgcaacgupaagaaag\n", + "gcgcpcgcgccgcuuccgcuuaaauaacggcpaggccgcggucggucucagucgccgcugccagcucucgcacucuguucuuccgccgcuccgccgucgcguuucucugccg\n", + "pcgcgccgcuuccgcuuaaauaacggcpaggccgcggucggucucagucgccgcugccagcucucgcacucuguucuuccgccgcuccgccgucgcguuucucugccg\n", + "cucagucgccgcugccagcucucgcacucuguucuuccgccgcuccgccgucgcguuucucugccg\n", + "ucucagucgccgcugccagcucucgcacucuguucuuccgccgcuccgccgucgcguuucucugccg\n", + "ggccccgcuuccagcugccgaggccucgucgcgccuuccccpaacaaaaggcpupccpucag\n", + "gccagguucacuucacaguacagaguccugaaaauaaagaagaaaauuuuuuuuuaucuagaaaaagaaccaaac\n", + "uuuugaaacccuucaaaggcagagacuuguccagccuaaccugccugcugcuccuagcuccugaggcucapcccuuggcuucuguccgcucugcucapcccuccagcguggccacugcucagcc\n", + "cgaugauggaaguagcucuuauggcuggagauugcagguuuaugacugauccuauuupaagaacaaug\n", + "cagaagccuuugugaucucaccuguuggaaugcacuaauguuuucugagccccuuaaauaucuugucuacauucuuuuaagaagcucuucaccaacugucag\n", + "ggapauggaucccggucccaccuaaagaagcagucuggccaugaucugccacagcggcugugcugcacugugaagacugcugcccaguccaaucugcccagccucccuagcacug\n", + "cagaagccucacacagcccaguaacuuugcuaguaccucuugagugcaagguggagaauuaagaucuggauuugagacggagcacggaacauuucacucapaagagcuaugaac\n", + "ggaggaagacuucupcagaagcggaacacaggagcagagacacauagucuuggcuccaguuucguuucaguuaugcccacccuuucaguguuc\n", + "aggacugcccggcccagccuuggaggaagacuucupcagaagcggaacacaggagcagagacacauagucuuggcuccaguuucguuucaguu\n", + "gucagccgcaccggcuccagcgcucgccucucgcccucgcuucuccagcgcuccuugcucgcaaggcpaggcggcggcccagccacg\n", + "paagcagccauggucuaagccpcgccucaccugucagccgcaccggcuccagcgcucgccucucgcccucgcuucuccagcgcuccuugcucgcaaggcpaggcggcggcccagccacg\n", + "agccauggucuaagccpcgccucaccugucagccgcaccggcuccagcgcucgccucucgcccucgcuucuccagcgcuccuugcucgcaaggcpaggcggcggcccagccacg\n", + "aagccpuaggcgcugucuccgucgccuccaacccccccgguccgaccapaaggupaugcucug\n", + "uccucccuaacagauaaacagcccuuguuccucpauaaggacuggcaguccccugacacccuaagaccggcaucugucgauguuauuuccccagc\n", + "gaggccacccggaagaccaagccpuaggcgcugucuccgucgccuccaacccccccgguccgaccapaag\n", + "aggucccgccccugupcpcgaggcagcgucgccgcgaggccacccggaagaccaagccgg\n", + "pcaaagcgcggagcucgccgaguagacggccccgccgcccgcugcccgccpcucuccagcuucgcc\n", + "aggacccgagcuacgguggccgcpcggcgguggcgauuggacuuggupucccpccapcpcgccgcc\n", + "ccugcacaggaapugcacggaaacacgucauuuagaacaucccpcccgaacaucgcpcccuaacauccag\n", + "caacugaagcagcagcpacaagcugaggcaguaccagaagaggaucgcccagcagcuggagcgcgagcgcgcccuggcccggcagcugcugcpacggcaggaagga\n", + "acpccaagcugcugcucaagaagaagcgauaccaggagcagcuccuggacaggacggagaaccagaucagcagccuggaggcc\n", + "auuucaucuucacaucuccuuacugauauauuggagcuggcucuugcaacagagauguguaauggcuauccuuaauucuuucuaacucag\n", + "guacccucuuaccaauuauacuuuugguacaaaagagccccucuacgagaaggacagcucuguugcagccagauuucagcgc\n", + "accacaccagccpagccgccgccgccgccgccaccucugagcagccggcupagcgagagccgacagcuagucugcaagccaccgcugucgcc\n", + "gccgccgccaccucugagcagccggcupagcgagagccgacagcuagucugcaagccaccgcugucgcc\n", + "ccuuccuagucgcpagucugagaaagcgcaccuguuccgcgaccgucacgcaccccuccuccgccugccgcg\n", + "gaucccggcgagcaccuuggcgcgcggagcuggcaccuuggcgcuguugguggcggcggagacagcugugaagugugagguucuuugucugcuggcagcuapcgacgaggcpacguc\n", + "ggcgagcaccuuggcgcgcggagcuggcaccuuggcgcuguugguggcggcggagacagcugugaagugugagguucuuugucugcuggcagcuapcgacgaggcpacguc\n", + "gagcaccuuggcgcgcggagcuggcaccuuggcgcuguugguggcggcggagacagcugugaagugugagguucuuugucugcuggcagcuapcgacgaggcpacguc\n", + "aaaggccuccgccgcucucggcuugaacgcguggaaccguucuccucpuucccgcgcgcuccaaupaccccucggcagcgugcggucgucucpacccggaaagaggaaag\n", + "auggcccccaguccccuggugcpuggccccaccugcucggccaccaaccugagccgcguggcpccuggagaagcaguuggccauugagcugaaggugaagcapcggagaac\n", + "gucgcgccgcgcccgcccccuccccgccacgcccpcgcacgcgcgcuccucuggccgccccucccuccgcgcpaccccuggcpcggcaggaggacauggccagcgacgccgugcag\n", + "auaaaguccuggccucpacagccugcacagcugccuagccuguggagacpacagcccugucccacucacucuuuccccugccgcuccugccggcagcuccaacc\n", + "acagcugccuagccuguggagacpacagcccugucccacucacucuuuccccugccgcuccugccggcagcuccaacc\n", + "acagccugcacagcugccuagccuguggagacpacagcccugucccacucacucuuuccccugccgcuccugccggcagcuccaacc\n", + "ggugcccuugagccgcaaaacugcuguccacguggaccpugacaucgcacguccaucugccaggaccccugcguccaaauuccgagac\n", + "cgaggagucpagcgcaguagcgcugagcccgagcccgagcggccccgcgucccgagcgcaucggagcggccgagccgcccggaugcagcgccugucccpcagcgcagccccggccgcag\n", + "gagccuuccugauccccuauuuccugacacucaucuuugcpucccacucuuccugcuggagugcucccupccaguacaccuccaucppcuapuauggaagcuggcuccu\n", + "gcgupccuugcggcugcugugcuaucauucuggcugaacaucuacuacaucgucaucaucuccupccauuuacuaccuguacaacuccuucaccacg\n", + "ggugaggcaacuccaagguccuacucucuuucugugccuguuacccaccccguccuccuapugcccuugagccgcaaaa\n", + "ggcuuggcaugaggaggugcucaauauagucauggagaagaacucauggacugaacuuccuggugaaccagapauggugcagagauuuaagauugcaacaggaacccccaagccaau\n", + "gagaaacggaaaggacaggccaacggaagcaguacugcaaggcuggaaggagaaaagccaggapagugcuugcugugaaagacapagacagagaccaagacggacaggcagacag\n", + "gccgcaaaacugcuguccacguggaccpugacaucgcacguccaucugccaggaccccugcguccaaauuccgagac\n", + "gaucucacccapuggcagaaggaggccuucuggagcugacccacccccgacgaccaucagguaacgucaacagccccgguaacaacauccaugaguggaguucucucucuuaaccag\n", + "uguucagcccpcuggagccgagacccpcucccggcgguggcacuggccupucpaccaggag\n", + "cuucucccuccugccgccuuaugaacapugacuguuuccccaucggccaugauuuuaaguuuccugaggccuccccagucaugcugaacu\n", + "auacuguuccuaagagcaucugccccagucaacuucucauccacagauauuaaucucagucaaccuccag\n", + "ucccuuapacuggcccuaacaacaaaugaggagaagccaaguucucugcuuucugcagacapccuccccugg\n", + "agaccugcacccagucacagcagcacagaugugcaggaggagaccauuuccacggacccuccgacuccuaggaggcag\n", + "acacggcuuaccuggaupugucguugcccgacuucgagcugcucagugacccugaggaugaacacuugugugccaaccug\n", + "aguugugagagaauguguggaggagccagcuggcuuuggacagguccugcggcacagucuguggcuucugapaaaapccucpccgucauccagcuccucccag\n", + "guguccgcacagaggucugcaaggagagagagugucuucauucuuuccgccaucuugauucuuucucacugaccaagacucagccg\n", + "cuaauuguuguagaucaucacuucaaggugcccauaucuuucuaguggaaaaauuauucuggccuccgcugcauacaaaucaggcaaccagaauucuacauauauaag\n", + "gauguggcpcuacgcgccgcggccgagccgugaggaagcggcucgcgcucacgcgucccccagcaccucgagcggcuguuccacaccgcccagccuaggccugccpc\n", + "aguggcauccuucccuuucuaaucagagauuuucuuccucagagauuuuggccuagauuugcaaa\n", + "gucuccgacacagcaacggauacucgccccupccgaggccgaccugcuccpaauggcgacgagucgccaaacagcaucucaaagaacccggauggacuguauauauaguggagapugag\n", + "aacuccuuuaaugugaaaguuuuugcuggcaucacuucuucupacaucuucaaccuuuuugucacagcuccauuucuuguuc\n", + "aacuccuuuaaugugaaaguuuuugcuggcaucacuucuucupacaucuucaaccuuuuugucacagcuccauuucuuguucauguug\n", + "uugaccccuagcccuuccuucccucccuccuucccuccugucgccgucucuucuggcgccgcugcucccggaggagcucccggcacggcg\n", + "aguggaaacacugcccucucccuucuugaccccuagcccuuccuucccucccuccuucccuccugucgccgucucuucuggcgccgcugcucccggaggagcucccggcacggcg\n", + "gucugcgccugcgcgcaagagaggcpccagcgcucggcauggcggagccagaucuggagugcgagcagauccgucugaaguguauuc\n", + "cupacgaugccggagugugaaggaguuugagaagcugaaccgcauuggagapuaccuacggcauugugu\n", + "ucccpagaggcaccugcccccagcccpapcgccgcpcucpagcacggacaaccccuacccaugaggcccugauggaaaacacaaaggaucug\n", + "cucacgaguggcccuggagcaggaagugguggagcagaucuuccuuguuupaggagccugagguggaccucgcguccugagucuggaag\n", + "guccuuagcpagcccgagugcpcgguggcpcuuggcggcpcaggauuccaggcaggagccuugccucucagguggcpcucugcgacccugcgag\n", + "cuuagcpagcccgagugcpcgguggcpcuuggcggcpcaggauuccaggcaggagccuugccucucagguggcpcucugcgacccugcgag\n", + "cuugcggacccagccupaucccuuaccguacucaccgagagcuugaggagaccuccagccccccaucccuggcucccgguaacugcuguuucucuuugccuuugcag\n", + "gucgcuucccggucagcugcguccuuagcpagcccgagugcpcgguggcpcuuggcggcpcaggauuccaggcaggagccuugccucucagguggcpcucugcgacccugcgag\n", + "aaaauucugagcuguacaccucuaggaaaugaaacacuaguucagaagaagccuguaaacucucuuacaaauacauuugguuauucacc\n", + "aaagaagcuuccgguucugagguccuggaggugccauuucccucucuguugaagcaaaggccpcagaccuccua\n", + "ggcccccagaugccgacggcccucucuaccuccccuacaagacgcuggucuccacgguupagc\n", + "aucuaccuucugagauaucauccuucuucapagauaaggaaaaaaagccacapucccggagagccapaaug\n", + "gaggauucpuaguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "guaguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "aguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "pcgcugugccgaggauucpuaguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "ggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "gugccgaggauucpuaguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "aucuaccuucugagauaucauccuucuucapagauaaggaaaaaaagccacapucccggagagccapa\n", + "guccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "cgccgagcauccupaggugugguccpcgcugugccgaggauucpuaguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "gaauuucauuuucuaaaccagaacucaucacccagcuggagcaapaaagagaccuggagagaggaaaaaaaauguucaccggcaaccuguccag\n", + "auccagagccagagcucuaccucgauccuuucugcccuccpuuucuccagucagaaauucccc\n", + "ggcgcugugccgaggauucpuaguguaguccuggcgccccgcuggaggagcuccccagcugguggcuggagcgaccccuuguucuuugguggcgcug\n", + "gcuuucagucucugccuuuucccguucucugucguggcuuuuguuguuguuguuuuuccuccuuuccuuccccgcucuucuuuucccugaauu\n", + "augaggaaacugagacccagaaagguggaagcacuugucuaaggucacgccuccaggaagcaguguguccacgacuccaguccaaguggucaggcuccagagcccacagucccag\n", + "gcggccgccgucugcagagccaggcccugaggcpccggcgcccccucccccgccccgaacugcggcgcaggcgcgaaccggacccgccuuugcucggcggagacagcaggcagagag\n", + "uuucucucuapaaaaggacgcaguugguguggagcapcaucggugguccugucaggaagaguggcgcpugccg\n", + "uuucucucuapaaaaggacgcaguugguguggagcapcaucggugguccugucaggaagaguggcgcgg\n", + "gapauggagaccuggaaaapacugacggugcagcgaggagaggaaggcucgguuaapaupucuuccacpapupaacugcpagugacggcagcuucg\n", + "cucuccccucccgcucccugccucucgccacagccucggccuucgcccucpauugaagaccuaccccacpcaggagccaaguccgugccuuupaupagucpccgcggagcucuggag\n", + "uugcugaupagaggaaaaaauagccacuauucagguucccugugaguuaacugcugcuguacaaag\n", + "cuuucuuapucguucgaaucccugccggccucuccccucccgcucccugccucucgccacagccucggccuucgcccucpauugaagaccuaccccacpcaggagccaa\n", + "uugcugaupagaggaaaaaauagccacuauucagguucccugugaguuaacugcugcuguacaaaggcagguguaauauuuucucuguauuaaag\n", + "gagguacaggugccucgcggugcagccpucgccuuccagcccguccgccucccgaccapcccgcgccccgucccgccucucucccgcccagccaa\n", + "acaggugccucgcggugcagccpucgccuuccagcccguccgccucccgaccapcccgcgccccgucccgccucucucccgcccagccaa\n", + "uuuuucccgcgaaacucggcggcugagcguggagguucuugucuccccugguuugugaagugcggaaaaccagag\n", + "uucccgcgaaacucggcggcugagcguggagguucuugucuccccugguuugugaagugcggaaaaccagag\n", + "gcgcagucaugucpauucgacgauccuggcauuuucuacagcgacagcuucpcgacgcccag\n", + "ccgcgaaacucggcggcugagcguggagguucuugucuccccugguuugugaagugcggaaaaccagag\n", + "uggaaccuuguguguggagacggcuggaaggucccgcuggagcaggugagccaccuccupcuggcugcupcugugucauccupagcaggcugugaccg\n", + "acggccgcggcggcggcggcggcggcggcugcuggagcccggaugcggcgccgugaggcaggcccpagagcggcgcggauggauccaacauggcggcgccgagccugagccgaga\n", + "aggaaaguggapaggcgguggcgacguccagccugagaaccucaagagapaggugacpacgcugagag\n", + "gacucccggcggaagcgcgcggcgcgcpaggcccgaacugauccgcggcggccggagaccgcupacagacag\n", + "cuucuggcuccagaccgcccuccggaucggacccugcgaaugguuuuggcuauaucuucauguaggaccuacucccuaucccgucggccgcggugaaucccaccugcg\n", + "gcupcuucaucaccaggccuccucacagauuccugucccuucuguguccuggacuccggauaccucaacucucaguacuuugugcucagcccag\n", + "acucgcugcggcgcuucuggcuccagaccgcccuccggaucggacccugcgaaugguuuuggcuauaucuuc\n", + "agaguugcuuuccagcuccugcaggupagucgacucaccugcagcaggcacucggcacaacuccgcaggaccggcucaccugcaccpcacucagcacagccuccagc\n", + "agcuccugcaggupagucgacucaccugcagcaggcacucggcacaacuccgcaggaccggcucaccugcaccpcacucagcacagccuccagc\n", + "cugcaggupagucgacucaccugcagcaggcacucggcacaacuccgcaggaccggcucaccugcaccpcacucagcacagccuccagc\n", + "agcgcgcaggcgcagcggcgacggcgucggcggcggcggcggcagcggcuccggccgaggugcgcgcuppappccggagaggagcaugaauggagcaaa\n", + "gcacucgcugguggupcgcgccgugcugagcucuggcugucaguguguucgcccgcguccccuccgcgcucuccgcuuguggauaacuagcugcugguugaucgcacu\n", + "agacucgagcagucucuggaacacgcugcpcucccpccugagccaggucuguucuccacgcagguguuccgcgcgccccguucagcc\n", + "acgaccgccagacucgagcagucucuggaacacgcugcpcucccpccugagccaggucuguucuccacgcagguguuccgcgcgccccguucagcc\n", + "gucucuggaacacgcugcpcucccpccugagccaggucuguucuccacgcagguguuccgcgcgccccguucagcc\n", + "uauugauccuccagaagguggagaauggagaccugagcaacaagauucugaagaucacugauuuuggccuggcucpaauggcaccgaaccaccaag\n", + "uugcaacaggaacaagagaaaaagaauccauaucauccaccuuuuaaagaaguuaggcaucuacuggcaagguggaagaaaucaacaaaucuaucapauauaccucucaga\n", + "aguaaaauuaccaagcaggcauugaugcuaaugugaaccagaaaaaaagcuccuuaauuauacucauuaggccuguagcugauccagcccauacagaagaggcaca\n", + "cgugacgacagcauguacgaucccugaaupcccgupcauauuuagucauucauuuuugaucaggagaaagaagacagccaucauuugaaag\n", + "guaaagcuucagcgacugaaggaguguggacuuuuugaauuucaagaacaguaaaguuggaacacagcagapuguguaauaaaauacag\n", + "gugauggaacuguacuggaacaaupagaagcugguagcuuauaggaagccaagaugaccagaauguuuuuaaauaaucc\n", + "gaaucuucugcggcuuguccauagugugaauaaaaacuaaaucacaucuauaauucuacugaacuggucacacagacgcugccauau\n", + "cacgugaccaagagccgccuagagcacaaguccugcuagucgccuccgucupuaccagcccccuauuacucugcaggcgugugaagaaagaaggaaacuagcucggaccgugcag\n", + "guuuguaggucuguuggccuguagguuucggcacaaguuucagcgagagaaggagaaaacugccuugguuggaaccuugcag\n", + "ugcapaaapuguggcggccuuugcupaaauggcggacgacaagupcggaggaggccugcguccggaaagucaguaga\n", + "acgugaccaagagccgccuagagcacaaguccugcuagucgccuccgucupuaccagcccccuauuacucugcaggcgugugaagaaagaaggaaacuagcucggaccgugcag\n", + "ccuggaagcuccgaccccaggagccagcccaucaaccugaaccauuacgccaccaagaagagcguggcggagagc\n", + "agagacucagacggcggagccuggaggagcccacgcagucuguucccggcacccggugcgugugaapacuugapcagcgag\n", + "augugcacacacauacacucacacgugugugcaggugcacaccucccccagaggcugcagccaagacpcaucccacaucagapauga\n", + "guugcaaagcagccgcucgguggccguacaacgcuucaucucuccgagccucgguuuccucaucuccagcccuaaaaugacgacacgccccacaggucuupaggauuaagugapacaugag\n", + "ucuuuucaagaagaucauucuuaacagcucuccauuccuugcugacacacaugaacuuapcacuucuguuuuccugapcuacaccguuuucuuuugaaagag\n", + "ucugaacaacccaguccugccagcuccagcuccagcuccagcuccagcuucacaccaucccagaccaggcaacaag\n", + "ucuuaacagcucuccauuccuugcugacacacaugaacuuapcacuucuguuuuccugapcuacaccguuuucuuuugaaagag\n", + "uccuugcugacacacaugaacuuapcacuucuguuuuccugapcuacaccguuuucuuuugaaagag\n", + "uguggaucuggacccucacuaacuugucuguaggaagagaaaauugaagagagagaggaagaggcugaggagaagaccuuuaccggugcuguccugagcugccauuguugaaggacauccu\n", + "auauuucagccgccgccgccpagcugcpcacaguccpacgcggcgagcagccucggcggccgcaccuccgcaaagcgccgcggccgcuacg\n", + "paguguccagccccaggagccpaccguccgcgucgcgagccpccaaggcagupcagapcagapcagapccpcupcagapcgagugcccpaaggcc\n", + "agaagcaacccaggagccccgagaccugcapaugugugcacccugaccccugacgcauagcccugcaccugcagccagcuggccucpcuugaaaacauggcp\n", + "auccpcccuuccagaagcaacccaggagccccgagaccugcapaugugugcacccugaccccugacgcauagcccugcaccugcagccagcuggccucpcuugaaaacauggcp\n", + "ggcuggaupcagcaucucaaucauauapcacaggacagaccucaguaucaccagcaagaauccauuacaguucaacauguaa\n", + "ggcuggaupcagcaucucaaucauauapcacaggacagaccucaguaucaccagcaagaauccauuacaguucaacau\n", + "gugccccgcgcuccgcgcccccuucucuuucagccucpcacpaggcucggcggaccugcugauupaaccgau\n", + "guccugcuucuccugccucucgccuccagccuccaacgcucgccacagcccucucaucuccuggaacc\n", + "agagugcaccgcagccgcugcauucaggaaccgcuuuagcuucgcccccggccggccpcpaagacugguguggucuggcc\n", + "aguuuuccuuucguucugcggccgcugcagccagccccgcggcucccucagacccgcpcgcagccgccpugaggcgcuupaccgcpccgagcggcpauccccgagcacc\n", + "uuuuccuuucguucugcggccgcugcagccagccccgcggcucccucagacccgcpcgcagccgccpugaggcgcuupaccgcpccgagcggcpauccccgagcacc\n", + "gguaaacgccgccguuugaggagcaccggagccgcgaccguggauugaacgcuuccccagagacccagaagcagaaggagcggacccagg\n", + "caagcaaccgguaaacgccgccguuugaggagcaccggagccgcgaccguggauugaacgcuuccccagagacccagaagcagaaggagcggacccagg\n", + "aggccpuugccaagcaaccgguaaacgccgccguuugaggagcaccggagccgcgaccguggauugaacgcuuccccagagacccagaagcagaaggagcggacccagg\n", + "agguupaggcagapcuucgcuagcagacgcagaggcgaggccgccagucgaggacgaggaggag\n", + "gcgccggcpaaapcugcggaccugcggcgccgcguugugcguucgacgacgcggcaccggcuucgacgcccucugcccgcuccagaagcag\n", + "uaagaagacauguuggauaacaagaagagguguagaguuugcauauaucaacuguggccuuaaugagcauguugacagcaucgaugcuagacagaca\n", + "gucuuuuuacugcuggauugugcaagauauuuaacccuauuuuguuugaauuaugacuuaaaugucaaacaucuuaacuaagaaaapaaacauuuuaguuuuggaagucaga\n", + "gcgcggcgcpagagcgcaguggcgccggcpaaapcugcggaccugcggcgccgcguugugcguucgacgacgcggcaccggcuucgacgcccucugcccgcuccagaagcag\n", + "guuucgccugcgcagugguccuggccaccggcucgcggcgcguggaggcugcucccagccgcgcccgagucagacucpupucccggcggcgguagcggcggcggcggugcgagc\n", + "ccuggccaccggcucgcggcgcguggaggcugcucccagccgcgcccgagucagacucpupucccggcggcgguagcggcggcggcggugcgagc\n", + "uuucuuucgccagccuuacpcccgaacccucgugugaapugcaguaccuaagccggagcpuagaggcpccggcacccccuucugaccuccagugccgccggccucaagaucagac\n", + "cuuucgccagccuuacpcccgaacccucgugugaapugcaguaccuaagccggagcpuagaggcpccggcacccccuucugaccuccagugccgccggccucaagaucagac\n", + "cpcccgaacccucgugugaapugcaguaccuaagccggagcpuagaggcpccggcacccccuucugaccuccagugccgccggccucaagaucagac\n", + "gcgccuggcugucgcgguugccpcaacgcgcuguccaugucgcpccucgcupacucccupag\n", + "cgugaugccccgcgccuggcugucgcgguugccpcaacgcgcuguccaugucgcpccucgcupacucccupag\n", + "ugccccgcgccuggcugucgcgguugccpcaacgcgcuguccaugucgcpccucgcupacucccupag\n", + "agucuccggcagcuucucgcggcuucgcaagccccuucccgugaugccccgcgccuggcugucgcgguugccpcaacgcgcuguccaugucgcpccucgcupacucccupag\n", + "augccccgcgccuggcugucgcgguugccpcaacgcgcuguccaugucgcpccucgcupacucccupag\n", + "aguguccgaacggcuucggapcgagaagccagcauccgagccgccucuccggaauaccagcagccugacgcacgcgugcugucpap\n", + "gaagugacccagugaupupaaacagagguccagagcaaaggccuuugcccaaaguuaggagaaggaugcupaccuggagucag\n", + "guguguuccuuauucccugcauccugauagcccuggucggaggaauccccauuuucuucuuggagaucucgcupccaguuc\n", + "gagcuuucucuugcauacccucgcuuaggcuggccpugucacuucugccucccugcccuccagacc\n", + "aguuucgcucuuguccaugcuggagugcaaugguguaaucucagcucaccacaaccuccgccuccupuucaagugauucuccugccucagcuuccugaguagcupauuacag\n", + "ugacgcpcgccagcugccaacuucgcgcgcggagcuccccggcggugcagucccgucccggcggcgcpcggc\n", + "ggcagcugagucagugagcagcgccaugaugapcagucccugccagcaccaacapcuggaaacccagcgauaggagcaucagcaucuccgag\n", + "puccuguggcugucuguggucuccgaggugcuguacauucugcugcuggugguuggcuucagccuc\n", + "pupacuucccgagucugccpaccaugaccugaacugugcgagcpacguguccgaagcccaagaaccagcucaucugagccgcccccuccccggccagcaug\n", + "aggagcuucuuaauaacuuugcccagcaaauaggagccuggagauucugccuguacuuucucuccagcacuaggaaugacuaugua\n", + "uguucucaagcuucauccgugugguggcgugugucagagcuuccuuccuuuugaaagcugaauuccauu\n", + "aaguuuuucucucaguugaagcgcgcacauugagucggcuuuucuacugcuucggcuapuaccuugugacc\n", + "cucucaguugaagcgcgcacauugagucggcuuuucuacugcuucggcuapuaccuugugacc\n", + "gcucuuacgcggucugupagaccggagcpagacagcggugacaggagcagcggccpagcccuuapaggcag\n", + "acgcggucugupagaccggagcpagacagcggugacaggagcagcggccpagcccuuapaggcag\n", + "acagagccugcagccaaugccccaggagcccucgguuccaaccaacugaugccccugugcccacuggcccacgcc\n", + "gguucgcuucggcguccgccgucuccgcagcugccuccucuuccuccuucgccaccgccgccaccgccgccgccgcccgcagcaccgcagccccucccgcc\n", + "ccuuagcucpcguccugguucgcuucggcguccgccgucuccgcagcugccuccucuuccuccuucgccaccgccgccaccgccgccgccgcccgcagcaccgcagccccucccgcc\n", + "agagagcaaacugcgccupcaaccagucpapugagucccgcgcgcgacagaagcuucuggcgcga\n", + "gugcagcagapcagcugagaggcupuggcupccupagacacacagaggccaggccuuagcgcggcucagcc\n", + "pppcpppuggagagaggucggcagauccagcucuccagcuuggcaaccugcuuagucuuucugaaucug\n", + "guacaccapuuggaaaaaccacacuaggcaaagaacuugcgucaaaaucaggacugaaauacauuaaugupugauuuagcucgagaag\n", + "agagcaaapcacgugagcgaggcgcccgaagccgucgcggcpaccauguugcuuccgaacauccugcucaccggucagg\n", + "puuggaaaaaccacacuaggcaaagaacuugcgucaaaaucaggacugaaauacauuaaugupugauuuagcucgagaag\n", + "ggcagauccagcucuccagcuuggcaaccugcuuagucuuucugaaucugguauuucguuuguaaaaupuuguugauucuuuggcapuuggccuupauuuuuagcgaaauaac\n", + "gccauucguggaaaaaucuaaugcauguagauuuuauugcaagguacagaaaaauuaagacucuuugupaacaguaaaguuacaucauucacccaaag\n", + "acauccugcucaccggucapcgcgcggccpapacupcupcaggcupcgcagagugcucupcaucpcgcccag\n", + "gauuggcupugcuucgcucagccaauccggacgcgcccpcgucgcggccccgccuccuccccggcgcucupcccguagcgcuccgcpaaggaggcugg\n", + "aagaccaagcauucagcaagccacucuuccaccucccuuacugcaggaaggcacuccgaagacauaagucggugagac\n", + "aagcauucagcaagccacucuuccaccucccuuacugcaggaaggcacuccgaagacauaagucggugagac\n", + "gcagacuucggcuggacuugccugcggugacaccugcuccccucugagagcuucagguucuccggccugccuucacugguuuguguccagagccggacugauucucucaauuugc\n", + "cagacuucggcuggacuugccugcggugacaccugcuccccucugagagcuucagguucuccggccugccuucacugguuuguguccagagccggacugauucucucaauuugc\n", + "gcaguuucagaacccagccagccucucucuugcugccuagccuccugccggccucaucuucgcccagccaaccccgccuggagcccu\n", + "gcaagaggaagaagagaaaacggccpcggcgguggcuguagguugugcggcugcagcggcucuucccupcggacg\n", + "ggucpaaaaaaguupccgaaggapccpaagacgcaagaggaagaagagaaaacggccpcggcgguggcuguagguugugcggcugcagcggcucuucccupcggacg\n", + "ggaagaagagaaaacggccpcggcgguggcuguagguugugcggcugcagcggcucuucccupcggacg\n", + "aagaggaagaagagaaaacggccpcggcgguggcuguagguugugcggcugcagcggcucuucccupcggacg\n", + "gcucgucugccuggcugcpugacacpcuucgccuupaapucgapaagcaguuagacggcugccpcggcggcugccgcgcggcacacaau\n", + "gcccgcucgucugccuggcugcpugacacpcuucgccuupaapucgapaagcaguuagacggcugccpcggcggcugccgcgcggcacacaau\n", + "pcuucaggucaccccgcccauccccagccuacgcgaccauugaacagcugccgcccaacggcugg\n", + "agcccuccuccauguccagcugapaaggcucguuucagugccgcggccggcgcccgccaapaupcagccagagccugucgacugcggcugcgcag\n", + "augcuggccaagaagagcugaaauagaaaacagccuagaaccuaacacuauuuacuguaaaauuuuugcaccagg\n", + "gauuucccagcgcugucucupagcuccggcagcgcaagapcaaagcacagcuggaagcucagagcugcagucccagguccup\n", + "aggugcgcggacacagaagcgucuaagcacagcuuccuccuugccgcuccpaagupcagccagcccag\n", + "pcacugagucaaagcuugapaguguucgcucccgcauuuucgauuccacucucuuccguuucugucgcugcagucguccgcgg\n", + "aggcccuucuccccaaagacgcacuccagaagucucgcccucgugcggcugaggagccupaucccagaccugaacaag\n", + "acuccugcupcagcccacapucccupcggapcaggagcauccaguuggaguugacaacaggaggcag\n", + "ccaggaggcupcagcugaggcapapapaaauaacugugccugauucuaggacapaupugcagcacugauccaggacccagaaugg\n", + "ccucacugcccccacucccacaccagcuguugcupcaggacgcccaaugucccagucuugcugaagucugcuugaaaugucccug\n", + "ccacuccugcupcagcccacapucccupcggapcaggagcauccaguuggaguugacaacaggaggcag\n", + "acucccacaccagcuguugcupcaggacgcccaaugucccagucuugcugaagucugcuugaaaugucccug\n", + "agaguuucccucuauugugcaccccggucugcuugacagugugauggucccgcgugcgcgucuccupuuuugcagcuuugucpcucggupccuccuucauucuccccgaguggcgcuaag\n", + "auacacugccgcggccgccgcaggagcccggagcucgagccgcccagcgacucccccucccccucccccagccccgccccgccccaacccpcuccgagccggagccgagucugcgccup\n", + "acgcaaucgcguuuccggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "aaucgcguuuccggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "ggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "cuuucuccccgcccugccgcggccccpcgcagcgcgcacgcaaucgcguuuccggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "gccuuucuccccgcccugccgcggccccpcgcagcgcgcacgcaaucgcguuuccggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "guuuccggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "paggccuuagcuccpcpcggcggcugcugcagcpacccpagcpcccggcgccgcccpccgcpcgau\n", + "ccgacccuggcgucgcgcugucuccccapagauaaucgapcugccgccuacccgugcugcggcggaaccaggacaacgaagaugaguggc\n", + "cccuggccgagauccugagcgugaaggacaucaguggccggaagcuuuucuacguccauuacauugacu\n", + "aaacggaagguggaggugguuucaccagcaacuccagugcccagcgagacagccccggccucgguuuuuccccag\n", + "aauggagccgcccguapcaguggcagcccagccaggacggaagcgaaaaucgaauuguuupcacugaugag\n", + "aguuuupacuggaauuaaauaaagacagagauguugaaagaauccacggcgguggaauuaacacccuugacauugaaccuguugaapagaua\n", + "ccagcgcugcuccccpcgcuccuccccpcgcuccuccccaggccucccpcgcuuggaucccggccaucuccgcacccuucaagupugupugauuuc\n", + "agugcuagagcucucgacucuccgcugcgcggcagcuggcppagcagccaggugagcccaag\n", + "aguggccucugccagucuggcagacacuugcagaccucucuucucagcaccaccaaucucugaugcccugcg\n", + "gaaguggccaguucaggaggcggaccccccgapcagcgcugcpccguuuuccggcccuccugacgcgacacugccccucuccgagagcugagaaggaaaagaggagcuugcggag\n", + "acucaggauaagacuuucucuaaguccggagcugaaaaaggauccugacugaaagcuagaggcauugaggagccugaagauucucag\n", + "guuuuaaagacgcuagagugccaaagaagacuuugaagugugaaaacauuuccuguaauugaaaccaaa\n", + "ugagugcagaaagcaggcgcccgcgcgcuagccguggcaggagcagcccgcacgccgcgcucucucccupcgaccugcaguuugcaau\n", + "gcgaugugaugacgucaggccccggccaggccpaguggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugccguaggccgga\n", + "gugcupaagacaacacuucugaacuauauuuugacagagcaacauaguaaaagaguagcggucauuuuaaaugaaucupaag\n", + "gaagugcgcuggagaaauccuuagcugucagccaagguggagagcucuaugaagaguggcuggaacuuagaaacgguugccucugcuguucagugaa\n", + "ggacaauggccuuagagcuauugagaauuugaugcaaaagaapaaauuugaugacauacuguuagagaccacuggauuagcagacccug\n", + "gugaaauaccacuaaaggcagaagagaaugaaaucaucccacccacugacccguucccaaucugagcauauggauapcccaaagca\n", + "gcaaguugcuuuggcagauaucauucucauuaauaaaacagacuugguuccagaagaagauguaaagaaauuaagaacgacaauuag\n", + "gcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugccguaggccgga\n", + "ggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugccguaggccgga\n", + "guggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugccguaggccgga\n", + "ggccccggccaggccpaguggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugccguaggccgga\n", + "gcgcgcccuucauugaagcggcgguggccpcupcgccgguaguggaaagcgacggcgcggcuggaaa\n", + "guuccgcgcgcccuucauugaagcggcgguggccpcupcgccgguaguggaaagcgacggcgcggcuggaaa\n", + "upagugaaagcgaaagcccpcgacuagccpagaccagagaucuagcgacugaagcagc\n", + "ggcacccuguugupuggaagcuuuugacaacccagacccuuaaccaacauccpuacugcucucuguguagguggaggucuucagacagaaucuuuuccaggag\n", + "gaggacucccucaauguggcugacuugacuucccuccpccccacuggacauccccaucccagacccuccacccaaggaugaugag\n", + "accuuagcuggaucuccaaaauacaagugaaucacccggcaguucugaggcgugcggaacaaauccaggcucgcagaaccgugaaaaaggaguggcag\n", + "ccagcuggcpaaggaggaapccpcgcggcgcagaggcpcgccuaccagccggcagcuccggagcugcccgcgcc\n", + "ggcgcggcgcagaggcpcgccuaccagccggcagcuccggagcugcccgcgccauguccgcgcacaaucpcaccgagcucg\n", + "ugccugacauuguguagcuguaucaggcuggcuuucuggaauagcucaguggccaaagauugaucacgaapuuuagagcugugaaaaugccccag\n", + "cuuagaaaguggcagccccucggcuugucgccggagcugagaaccaagagcucgaapccauaugacacuccucccggaccccuggacacacacagcccuggagacuggag\n", + "aaacpaacuuagaaaguggcagccccucggcuugucgccggagcugagaaccaagagcucgaapccauaugacacuccucccggaccccuggacacacacagcccuggagacuggag\n", + "aauccuaauguaccuggcuagcugguggugaguapcuuupccaacuuggupcuccccaaggaaaccccuuugaaacca\n", + "acugcpcagcucgcpagaccgaupcggcuuggaagccugcaggauugcagaugaggauugaguucggaauggaguggagaaugauguaggauggag\n", + "acagagucuagcucuuucacccaggcuggagugaaguggugcaaucucagcucagugcaaccuccgcccccupuucaagugauucuccugccucagccuccccaguagcupauuacag\n", + "agucuagcucuuucacccaggcuggagugaaguggugcaaucucagcucagugcaaccuccgcccccupuucaagugauucuccugccucagccuccccaguagcupauuacag\n", + "ucgagccugagcggccupcgucucgagaggugagagaguuggcggcgaggucucggcggcuaagcgagcgucggcgacugucucuccgcgagaggaggcaa\n", + "cucugucugccapucuccgacugucccagacpcuggugupcuupauccuccuggugaccucucccgcuaaggucccucagccacucugccccaag\n", + "ccgacugucccagacpcuggugupcuupauccuccuggugaccucucccgcuaaggucccucagccacucugccccaag\n", + "acuupauguagcuuuaucacggacugcuagagcaupaaaaaaauguuuguuuacgcauaauauuuauuuacaagauguacaa\n", + "gcccacagcccugcugauaaaagcaaagcucaucucugccgugcugcapaacccuauuuccuuccccugcagcucagccaccuccuccucucaggucugccagcc\n", + "gugcgaggcgcpcgcaggccgugcgcgcgccgcccgcugcaucccugcccggagcgcagccggcgcpcgcpaccgaggcgaaccpugcggagccaauacccgcggcagcagcaccag\n", + "cacauupagcagagaagaagcaaccapcccugaucapacugagccguagagucccagg\n", + "gcaucccugcccggagcgcagccggcgcpcgcpaccgaggcgaaccpugcggagccaauacccgcggcagcagcaccag\n", + "gagagcuagcagupugauuugaaagucacaagagaaauaaaugauuugaaaaaaaucucuaugacaagaaacuccuaauupuuuugaaaaagucuaaagaa\n", + "gaccccggaaggacuccgccuucuccaugucagacugcugcucagcgccaggcaucagcupaagcuggcgupcaggccagcuguaccuggccuggagcuccag\n", + "aaagaaguauucuguuuucaucugagaggcagauuuaaccggcgucccgugucuuccuggcaguccugcccuggagucacacuccacag\n", + "cuggcuggaggcgugauccupuguggcccuguggcuccgccaugacccgcagaccaccaaccuccuguaucuggagcupagacaagcccgcgcccaacaccuucuauguag\n", + "guuccagccccggagagcaaugugagcaaagcuugcugucuuugcaaagccaaccacuguggcaucaacuccuucaggaagcccucccggauuguccaag\n", + "ugugcucucccaccacguuuggaaaguuacugcuucccucuuccucagccccucpcucccaguuauggaaguggcgugauucagagaag\n", + "gucugugcacccgugccguggcgugcccgucgucugugcacccgugcuguggugugcccuucgucuguuccuuuuauugccpcapuugcacccac\n", + "gaaggcuauuucgccgcuggcgucaggacuauuuucacguuuuaaugccgagaggucucugugacgauuuug\n", + "gaugcagccugcggcggccucggagcgcggcggagccagacgcugaccacguuccucuccucggucuccuccgccuccagcuccgcgcugcccggcagccpagcc\n", + "gaaaggcgcauugaugcagccugcggcggccucggagcgcggcggagccagacgcugaccacguuccucuccucggucuccuccgccuccagcuccgcgcugcccggcagccpagcc\n", + "agaagguuuaaggccggaaapaaaugaapcccggcgcuaacccucuaaggaccuguuuugcuucuguuuaaaccaaaupcagucugucauuacacacacccupucuucau\n", + "gaagcccaagaacuccggaguuccgcaacucuccccagacguccggaagcaaaucgcgucccaggcaaaacgagcucgcuugagagcgcccuuagccccguupcugcug\n", + "ggacagaucuuccauccuccuaacauauaguuagcuuccacucuccaaauauuccaccagcaacauugaugaauauugaagacuauggacugugag\n", + "auuccccgaaguuguggcuucugcugauacuuuccuugagagucacgaguuuacaagcuacauaauagcgucpcaa\n", + "agccccgccccaggcgapcgccgcacccacaccgcgcugcgcaguuuuguucugcuccagcuguucgaaggugauccag\n", + "acuggaaaaguaagaagagcuuuccugccuuuuuaauuaccaaacuacucucaguuuucaaugaaucaguucaaagaaagaaugcagucuuucuauaccug\n", + "uaagaacauacuguagauuuguuagaaauaguaguaccuucuuuccccaccccaaacugcuaccuguuucuuccuuguuuggacucucugcuccucuagaagauuucacagca\n", + "acuuapcpagcccggcgapcgccggugcuuuguucugucugaggccaggaaguuugaccgcgcugcc\n", + "accgccucccgcgccuccgccccgccgcccgcugccgcgacugccaaaguuucucggucacgugcuggcccccggcggcccaaag\n", + "gagaagauccccgaacuacggcgacgaggccugccuguggcucgcguugcugaugccaucccuuacugcuccucagacupcg\n", + "cpagcccggcgapcgccggugcuuuguucugucugaggccaggaaguuugaccgcgcugcc\n", + "ccaacucugguccccagauggcaggcgcacaacugucuuacccaggaggcuucccuggagguccugcacagauggcugguccgccacagccccagaagaagcuggauccugacucuaucccuagccca\n", + "auccaggugauugagaaugauagagccagcagaggaggacaaguuuaugccaccaacaccagaggccagaucccuccccuggucacuacagauugcaugauacaagaccaag\n", + "gaaaugccaguccucgauucauccguuguacaacauacuguuuuccaugcacgucagauauggcuaagcaagcucagauuccauuagcugcugucaucaagcccuuugccaccauuccuucaaaugag\n", + "uuccaccauucuauuuccaacaucuggaccacauuggaagaagacuggaccacuaugagaaaccagaguuaucucuaggaucuuaugaauauguugccacuuuggauuauugcaga\n", + "accagagccaggcccaugcuguggaucagaagcgaccauaaacaagaaaauccaaucugucuucuggcuuucuugag\n", + "aguccccuuuacuugguaaaucacggcgagaguggaccagucagaugcaacaggugcaaggccuac\n", + "auggaacaucagaggcuaagcucagguggcaacaggaupucagaucaaggaagacugagacuccggaccaagccucacggcuggugapccapacucaaucacaggaacaag\n", + "auauggaacaucagaggcuaagcucagguggcaacaggaupucagaucaaggaagacugagacuccggaccaagccucacggcuggugapccapacucaaucacaggaacaag\n", + "gccuggccucgcccuguggaugaugauggccuugcccccgugagcuacaaccuggccuucagcacccgcccaccuccaaccagcagg\n", + "aagccuuggaagacaccccugccaacggccggcauuucaguuuguggcupucugcccucaccucccccugcagccup\n", + "acacucupcucagucaccgaapagcagcagcaagaagaauauuuaccagcaaguacugaaucaacaugugcugccagccagcgcugacauguaucuuuguugacugcuuaag\n", + "gacaagccuuggaagacaccccugccaacggccggcauuucaguuuguggcupucugcccucaccucccccugcagccup\n", + "agagcggagcgaggaccgcguccggcgcagucuucaaugagcagcgcggaaacugcaccccagacccgagccugcugcgcgcccccucccagagcucaccuggugccagguaacag\n", + "auugcucugguauucaugccaaagacacaccagcccucagucacupagaagaaccucucauacccucg\n", + "ggacuuuguuuaaagaagauccgccucupuuuuauauugcucugguauucaugccaaagacacaccagcccucagucacupagaagaaccucucauacccucg\n", + "ccucupuuuuauauugcucugguauucaugccaaagacacaccagcccucagucacupagaagaaccucucauacccucg\n", + "gccugcacgccgucgucuuggagaccggcuggcgccucagugagccgagcagapccgccuccgcccgcacccagc\n", + "acgcaggagguggagccggccpugcucgapaaggagacuggaagcugguuccggcgugaggagguggapccgccgcpcuccppcg\n", + "agucugaaaaapagcgcggagaggaggcuggaagaggaagaugccuagcacagaccuucugauguug\n", + "augaaaaacgaggcuuauagagaguaacuacagcaguugagugguggagccaaguuugaccucaguuggucugacuucagaucccucccucuugccuacuuuguguccuuaccccug\n", + "aggauuugcugguccuccgacpapugacaacgagagcgaggccgugcugauucugaapagugcggaggaggcaggacccug\n", + "gcgucccuuucccuugcaccuguuaacaucuuuaaggcaggagcugaugaagagagagcagagacagcucgucug\n", + "gcaggagcupaggaggcggcagcggcggcggcagaaacagcagcggcggcggcggcggcagcupaggagguggugacgguggcaacggcagcgucpacg\n", + "ccauccugcccucuauuuucapucacgaccgcugcaagcaggcuuugcugcagauupaucaac\n", + "guugugccauccugcccucuauuuucapucacgaccgcugcaagcaggcuuugcugcagauupaucaac\n", + "guugugccauccugcccucuauuuucapucacgaccgcugcaagcaggcuuugcugcagauupaucaacaug\n", + "acuuugcgcgcggccucuggagcuccagcugcgccccgccaccacuggccgcucgcacuaccagccugucucgcacgcuaa\n", + "agcaguuacacugcggcpcgucuguucuaguguuugagccgucgugcuucaccggucuaccucgcuagc\n", + "acugccgguccuuccugcuacggccuucucucugugcagugcuuauucuccaguucuuuuuguuucaucacuuug\n", + "auucaggauuugagcccucgccugugaaagagugacucapccucugccugccgcucuugcuccaagauuuuacuacaauugg\n", + "gaacagcaucucugccuuccuguucacggugaccuucgcuugguguccuccuggccucagcaaccugacaauucugucgugucccg\n", + "agagauggcuaaugaauggcgcuugaugacagaugaguaaugccuguugcugaaagauugacgguaugag\n", + "auupagagucauauuaauaccaaauggucagcaccucagcagaauuuuuugcapaaaacauccagugugguggaa\n", + "gcccagugaaauggagccugucccgugcacuuucpcauuucgagcaucuugupcucucccaagucgcggccccuccucugagagccacagucag\n", + "gcaggaguacaguggugagaucacgguucacugcagcauugaccucccuaggcucagguguugcucccaccucagucuucugaauagcuuggaguauag\n", + "ugccucaguuuccucaccaguacgcuaggagagaccagcguagccagccacagcpucgugaggauuaagugapacagcagugucuggcacg\n", + "agcgccuggagccggcuccgcggcggapcggcgccccgacccapccagcaccgupcaccgccaggccggcgcguauggaggcggupacgccugcggcgcpugagccuggcag\n", + "aagccgguggagccgcggccgcgccugugcgcgapcgcgcgcgucccgagcccuccacccgucgugccggcgccgcccggaccgccag\n", + "cgaggcuccuccucuguggauggucacugccccuccaccaggcuuccugcuggaggaguuuccuucccagccaggccggcccagaagccag\n", + "cauuauauuggacacuucaguaccaagagaaauacauacgauccuugucuaccaggagucuaauagaaagauggacag\n", + "ggcupucaguuagaaccuaaacaaacuagagaccugguugcaaccccucaggcucugcugaugcugucccccuuuguuccugcagcguggacccugccagcagccaggcc\n", + "auuaagcaauugcaauuugcagugugccaggcacugugccaaguauuuugcuucgaugauuucacgucaucuucaaaacaaccucaugag\n", + "apcupucaguuagaaccuaaacaaacuagagaccugguugcaaccccucaggcucugcugaugcugucccccuuuguuccugcagcguggacccugccagcagccaggcc\n", + "auaauucuuugagcaacuacupcauuauauuggacacuucaguaccaagagaaauacauacgauccuugucuaccaggagucuaauagaaagauggacag\n", + "ugugccaggcacugugccaaguauuuugcuucgaugauuucacgucaucuucaaaacaaccucaugag\n", + "puuaguugugguugugauaaauaauuacuaccguuauuaagcaauugcaauuugcagugugccaggcacugugccaaguauuuugcuucg\n", + "gaagccggaagagaccggacccugaacagaaucgcagauugccagcccuuuucccgaccccuacggaaagacgaguccapccguccuggcgaggucaaaacauuuagucuggucuuuucag\n", + "gugacaucacauccacuaaccaaaupuggugugaguaucuccuauaaaauaaaagcucuccugauggccuguuccugcacauuuccugaggacgcccucgaucacaagcag\n", + "cuugcuggaugaauaaaggaaagaagguuuauauacacuaauaauagaaauguuuupaugguucaugauuucgaaaagcuucagagaaaauaaagaugcuuaau\n", + "agaaugugacuuuccugaacaacaggagcaagaaucaaugccagauucucuucucuaaaaauaaucaauuuguuacuacag\n", + "acuaaccaaaupuggugugaguaucuccuauaaaauaaaagcucuccugauggccuguuccugcacauuuccugaggacgcccucgaucacaagcag\n", + "acauccacuaaccaaaupuggugugaguaucuccuauaaaauaaaagcucuccugauggccuguuccugcacauuuccugaggacgcccucgaucacaagcag\n", + "aaaauaaaagcucuccugauggccuguuccugcacauuuccugaggacgcccucgaucacaagcag\n", + "agaccuucuguccaccagcugagaaggacaapcggaaggcagcugcacagagcapccacggccuugcacacaguccapagcuuuugugcaggagccaggccucccccupucccc\n", + "uggcgucagagccgucguggcucguuccauucucggcggugguaccugcucccgguggcccugaggacgugupccapcggccccgaaauuaggaagcggapagcag\n", + "ucugcaggucugcpcuaagugucgcggcggcgcaccucgcgucaagaauccggaggaggagacugcaaggauaggcccag\n", + "gaaagccaucaccaagucpccuccagcaccuggcccccccuccgcccaccccupccccgugcagcgagucagagcggcagauccggaguacaguggacuggagc\n", + "gagucagcgacauaupagcacaucugguucgagaccaacguguccpacuucugcuacguupagcaguacuguguagccagg\n", + "gccpaagcugcaaugaauccucagcucupcccaguggaggcgcupacggaagaapagcggccpucacugaggcag\n", + "gugcugagccccggccgccggcccggcaupcgucucccgcpcccuccgccggccpcuapccgg\n", + "ccaaccuuuguacggcaccacupuacacagacgacgccaggacggcaagugucggcacugupaag\n", + "ggauuccagcagaaguucaccuuccacagcaaggagauuguggccaucagcugcucguggugcaagcaggca\n", + "caaacuaggacuugcucagcagaggccgccagcccggagcuggauccagagcccggccuupaccccagcucccaccugcgcccugccuuccagaucag\n", + "uggcggcaggugcgapagagaacauugagcauuugaagcuucgacuugaggcucggccaccgacuuugcu\n", + "guaaupuccgcuccuguuucugccuccgcgugapuugcggccacapugacggcguggupcgacacccccgcgcaggc\n", + "gacugucacagcuucgagugcacaauccucuucccacccccucccauucuacaguggcggcaggugcgapagagaacauugagcauuugaagcuucgacuugaggcucggccaccgacuuugcu\n", + "cuacgacagcggagccccupaagccaagaugccgucgaapaaaggacaaaaagaaaggcaagagcaaaggcaaagacacgaa\n", + "auugaaaaacugaaacagcaauuaaaugaaacaaaggaaaaagcccaagaggagaaggauaaauug\n", + "gaacaaaaguauaccaggcaaauuaaugaacuagapacaguuccaucaaaaagccaaagaaauuggc\n", + "pcugacggauccgcpccggcaucugaagcgagcpacgcagcgcggccapccuccpcauacgcaggcugguccccaaggcccgcggccgccgcc\n", + "accaucgagcuucgcpuugcupcugacggauccgcpccggcaucugaagcgagcpacgcagcgcggccapccuccpcauacgcaggcugguccccaaggcccgcggccgccgcc\n", + "guuuggucacgugacugcguccgugguccucccguaggaaccggcggacucgguuggcguugupcapugguggagcaag\n", + "gcuccagucaggccaacaccgacgcgcagcupaggaagacaggacccuugacaucuccaucugcacagagguccuggcuggaccgagcagccuccuccuccuagg\n", + "gguaaauauauuaaagaccaagauuugcaguaacauuuaucauaucaaaucuccaaaucuaguggaggaauuuaaacagaggacacagacagcucuupagagucuucauauuuuuauug\n", + "uacuuacaacuacgauucaacaaaccaguucgcuaugcugccacggucaucuacauuguacagacg\n", + "ugacupuuugaucucupcucuguguuugcaacaggaauuguuugcacauucuacuguacccug\n", + "augagaauccugaagcacagaucacagagugagaugccagcaaaucucaaacuggaauucaaggaggcugauuucugaucag\n", + "cuuguuuucccugcuuuguguuuucugcucguggacgcccagccucuguggcccuguggccugcagguauupagauccacagcuaagacgccpacccccuggaagccuagaa\n", + "guuuucugcucguggacgcccagccucuguggcccuguggccugcagguauupagauccacagcuaagacgccpacccccuggaagccuagaaaug\n", + "gcucuaggucuuguuuucccugcuuuguguuuucugcucguggacgcccagccucuguggcccuguggccugcagguauupagauccacagcuaagacgccpacccccuggaagccuagaa\n", + "ugcucguggacgcccagccucuguggcccuguggccugcagguauupagauccacagcuaagacgccpacccccuggaagccuagaaauggugagagugccag\n", + "ggaccauugacauuuapauguggccauagaauucucucugaaggaguggcaaugccuggacacugcacagcggaauuuauauagaaaugug\n", + "pcaugcucggccucggcggcugcaggcpcpucgcgcugguccccggccggccggagcggcggcgguggcggcgcgaggcggcaugapagccgcucg\n", + "ccguuuuuccgcgcccgcggccuugaapugguggucgacpcaaguagagaccgcgapucuggapcgaccggccuggcacagapaaggaagagagcp\n", + "gcggccuugaapugguggucgacpcaaguagagaccgcgapucuggapcgaccggccuggcacagapaaggaagagagcp\n", + "gcgcccgcggccuugaapugguggucgacpcaaguagagaccgcgapucuggapcgaccggccuggcacagapaaggaagagagcp\n", + "agaagagcgcacggcpcgcugccggccccgagcgcucccgcuaccacugccgcucccggcccugccggccggccaugccccgaguuccggcugccgcgcgcacccagacccggcg\n", + "aggcccaguaaguaucugcpapcugaaupugcguggacagcauuccucucacugaccccgcugcgaggugagccaggcapcugucaccauuccugaaguccag\n", + "guaauucauuugcacaccuguuagcaagaaacagaaguugaaggacuggaacaagugaacuaggaaagapaacgccaauccaagg\n", + "ucccccuagcgccgcugaggagccgccucugcggcuccaggapcgcaggagcpacugagagcgccuggaggcucgagcggagg\n", + "augcccagccuacagagucugagaaggaaauuuauaaucaggugaauguaguauuaaaagaugcagaaggcaucuuggaggacuugcagucauacagaggagcuggccacgaaauacgagag\n", + "gcaauccagcauccagcagaugagaaguugcaagagaaggcaupugcaguuguuccacuaguaggcaaauuaaagaaauuuuacgaauuuucucagagguuag\n", + "paggcgcgucgcgaggcgagcguccuccuuuugugcgagcgccggcggcucggcuucucgaag\n", + "pcgcggcgcgcgcugacgccpccccgcgaugcggcpacupcgcppaggcgcgucgcgaggcgagcguccuccuuuugugcgagcgccggcggcucggcuucucgaag\n", + "guuugcuggcaupuaaucucauuaaggugcuaaccapacauagaccacaaugcagcacauuuuuucuuggacuuugaaa\n", + "guuggagugcuguggugugaucacagcucacugcagccucgaccucucuggcucaggugauccuccugccucagcgucccgagcagcupaccacag\n", + "aaacggcggcggcggcggcaccggaggcuccgaggcuccugcgcucccgcgccgcgcuccccucgcccgcccpccgccag\n", + "gccuccuguuuccugcgcuuucuccuuuuccugugaaaucuccgaggagaagaaagaaugauggacaguuuauccuuucacugccacaaggccuguuuacuuggca\n", + "ccgccaacccggaaacggcggcggcggcggcaccggaggcuccgaggcuccugcgcucccgcgccgcgcuccccucgcccgcccpccgccag\n", + "uuccuccuaacaggaacccagcuggcaaagaugucupaaaugucauuugcauucucagccccagcagugcagaaag\n", + "uucgcuuucccacccgagagccgcgagcgcccggccgaacccgcgauggaauaaugcccagcggcccgccaggucccg\n", + "guuuguagccguggcuuuacaccucucaagaugguagcuugccgcgugauaggcuauguuucuuccaagaggcaaag\n", + "gcucuagaccaagauagaacagcccuucagaaagugaagaagucuguaaaagcaauauauaauucuggucaag\n", + "cuccapuuugagccacaaugugaucuucaccuuggauucuuuguuaaaaggagaccuaaapagucaaagga\n", + "gucguuuucugaugugacggcugagacaugagaucuucagccuccaggcucuccaguuuuucgucgagagauucacuauggaaucg\n", + "cauugcauugagaggauauucaaacugaapagaagcacggauucugaaggaugaaaaaggaacaau\n", + "ucuucccupuucugccuccgccucgcccuuccagccgcacgugccuuacagcccuuuccgap\n", + "gccugcgcccgcccgccugccgcagccagcagccugcagccgccgccpuugugccucagacugucagauaaaucggcpccpccggcpucggugagcgcggcccpccggac\n", + "gcagccgccgccpuugugccucagacugucagauaaaucggcpccpccggcpucggugagcgcggcccpccggac\n", + "ccugcggcuucgaucccuuuccacupuauugagauuggcgapagaggcgcagaaacggcgu\n", + "acucuagugcagugguucaaucucggcucacugcaaccuccgccuccccgauucaagcgauucuccugcgucagccuccccaguagcugagacuacag\n", + "uccpagcggaacugcaagaggaaaggcucpuaggcuucupagcgaccgcuccgcucgucucguugguuccggaggucgcugcggcggupaa\n", + "gccgagccccggcccagucggucgcuugccaccgcucguagccguuacccgcpccgccacagccgccggccpagaggcgcgcgcc\n", + "uucaaaaggugaugaccuaucaacagccauucucaaacagaagaaccgucccaaucgguuaauuguugaugaagccaucaaugaggacaacagugugguguccuugucccag\n", + "gugaugaccuaucaacagccauucucaaacagaagaaccgucccaaucgguuaauuguugaugaagccaucaaugaggacaacagugugguguccuugucccag\n", + "cagcgcaggacacggcgccgapupcgcpcguaguggcgccpagucgcpugcgcgcpccgugagugugcgcuuuugagagucgcggcggaaggagcccggccgccgcccgccggc\n", + "ccgcccpucaggacugguuuggacgcggccguuucguuuugacgapcucguguacauugaccuuagugacauuguuugaaacuuaaauucguaccaucaagacgugucaguuuaauug\n", + "guugguguucgaggaagagacauuguuguucuugguguggagaagaagucaguggccaaacugcaggaugaaagaacagugcggaagaucugugcuuuggaugacaacgucugc\n", + "guaguggcgccpagucgcpugcgcgcpccgugagugugcgcuuuugagagucgcggcggaaggagcccggccgccgcccgccggc\n", + "gacacaccagccccucggauaccacuuggccacucccgcugaggccacucccacugcguggcugaagccucgaggucaccaggcggaggcgcggag\n", + "ggagcguugacauuuagagauguggccauagaauucucucuggaggaguggcaaugucuggacaccgaacaacagaauuuauauagaaaugua\n", + "cauguuuuuggcccagaggagccucugcucucuuagcgguagagcaaaauuccugaagacaauuucuucuuccaaaauccucggauucucuacuucugcu\n", + "agaacuaaagagaagagaauaaagacucauaacuuucucauugaagcugccuucuuaccaaguccagaggaucucuacucugg\n", + "aaauucagaacuaaagagaagagaauaaagacucauaacuuucucauugaagcugccuucuuaccaaguccagaggaucucuacucugg\n", + "auacuggauuucaccauggugcccaggcuggucuugaauuccupcucaagcaaucuaccugcguuggccucccaaagugcupauuacagacaugaaccaccacaccuggcagaaccuuu\n", + "ggucucgcucugucacccaggcuggagugcaggcucgaucacggcucacugcagccucaaccuccuggacucaagugauccucccaccucagcuucccaaguagcupacuacag\n", + "uuuuugucuuuuuugaucugacuguagaugaucagucaguuuauccuaaggcauuaagagaugaauacauc\n", + "aaugugugaaugacaacuacugguuupapacaaaagcugugaauauugcuuugaugaaccacugcugaaaagaacagauaaauaccgaacauacagcaagaaacacuuucggauuuucagg\n", + "aucugcagguuuagcgccacucugcuggcugaggcugcggagagugugcggcuccaggupcucacgcg\n", + "gcagguuuagcgccacucugcuggcugaggcugcggagagugugcggcuccaggupcucacgcg\n", + "ccgcuccaggaagucgugcugcggagccaaauuugaagcaagcggaggcgcpcgcgucuacgaagccggaccuguagcaguuucuuuggcugccupccccuugaguccagccauc\n", + "gccaaauuugaagcaagcggaggcgcpcgcgucuacgaagccggaccuguagcaguuucuuuggcugccupccccuugaguccagccauc\n", + "aagucgugcugcggagccaaauuugaagcaagcggaggcgcpcgcgucuacgaagccggaccuguagcaguuucuuuggcugccupccccuugaguccagccauc\n", + "cuuugugaagaaaccupuguuaaugguacaggauupuaccauuguaugucccuggcugucuguuaguaaagcuuagagaugccuguggaaaaaaaguaggagaag\n", + "gcucuccaagagauucuaacucagucacaguuugaaccacuacugaaccacugcuguuaggaagcuacaacccaaaagaaaagccccacagaugcugagagcuggugauccucagg\n", + "auaaaacaaaggaaccagaaccacauccacugaucggauuugccupaggapugcucucuccuuugaucuucucuucuggaagagauggaccaaaagccucuccagcaauaaucc\n", + "cugcggagccpcggagagaggaggcgcaggaggacccgcgacacagcucpauccgcgcgcgcupccuccggcgccgcucgupuucpaggccpacccugcccpag\n", + "auaugaaagaacaacugugccapcgagagacgucuuuguggagaaagcauuuucaagacuggaaaag\n", + "gaguguuuuaucacaaacuucaucaguggccgaaaacucauucacgucaacugcucaaaccucccucag\n", + "gaccagcgugaggaggcuccuggcaguugcccacaggaccagcgugaggaggcuccuggcaguupcuguuccpccggcggcaggapagcuugaugcgugccuggcgugcgcaggccg\n", + "uuaggacuacugaagacgaugauuaucaugugaugagcaccuaagcugaacuggacacugugcugagcacuuuccagccacuaucucacucaaaugaguucag\n", + "ggaugcaauuguuuaggagaagagugaaggagaagagaagagagcccgaaacuaaacapaggaauccaccauuuagaagucuggcaggcaaagaggacaag\n", + "auuguuuaggagaagagugaaggagaagagaagagagcccgaaacuaaacapaggaauccaccauuuagaagucuggcaggcaaagaggacaag\n", + "aaguggaugcaauuguuuaggagaagagugaaggagaagagaagagagcccgaaacuaaacapaggaauccaccauuuagaagucuggcaggcaaagaggacaag\n", + "uguuuaggagaagagugaaggagaagagaagagagcccgaaacuaaacapaggaauccaccauuuagaagucuggcaggcaaagaggacaag\n", + "gaugcaauuguuuaggagaagagugaaggagaagagaagagagcccgaaacuaaacapaggaauccaccauuuagaagucuggcaggcaaagaggacaag\n", + "uguaaaucuaguguagaaauaagugaagcuuugcgucaauuguuaggucuaagcagaaguuupagagagaagaaaaguuacucauuugccugauuccgcacg\n", + "uggaugcaauuguuuaggagaagagugaaggagaagagaagagagcccgaaacuaaacapaggaauccaccauuuagaagucuggcaggcaaagaggacaag\n", + "cgcpcapcpacacgcggagcaaaggcacccggcaaccugaacccccaggugcgucccgcgacccugcaaggagcugcugg\n", + "ggagcccucaagucccugccaaggcccccucugucucccagguguupaapucccagcccuccccugccucgccuccugup\n", + "cacagcuccagcagccacauuugcaaccuuggccaucuguccagaaccugcucccaccucaggcccaggccaacc\n", + "cgucgcaccgccucucuguagccgcccgcggagcaucgcagccggcccpcccccgccagccucccuccucgcgucccucgguguccuccgcpccggcgcg\n", + "cucucuguagccgcccgcggagcaucgcagccggcccpcccccgccagccucccuccucgcgucccucgguguccuccgcpccggcgcg\n", + "guagccgcccgcggagcaucgcagccggcccpcccccgccagccucccuccucgcgucccucgguguccuccgcpccggcgcg\n", + "ggcacccuaucuuaggcguucaaauaaaggacuaggaagcaaacacccaagcaccpaacagaacagaaa\n", + "agacgccgaagaaccpcagapuccugacagcagccapaaacpugcccuacgauucugcccagcccccucucaggacccccaaacugccauccacacucgacacuucpuucuag\n", + "gucuucagapacuugauggauccuguacccacccuccgucuuuggucugaagaaaaupupucucugcuggug\n", + "cuaaaucccaguuuguggaauaugccuugcucaauaaaguuuuacuaaagaaaugacapaauaaauucagagcuucaucuguacuagauucuuucuug\n", + "aaccaaucuucaccaaucucaucuucacauauaaacagccgccuuucaagaagcaagcugccagaaaaaugaugcacg\n", + "auuccccaugacagcgacugaugaagaauuucaauagaaagcugcuacuucagaaaauaagaucauuugcugcgaauggagaacaucucaggcagcccugaugcuccaccg\n", + "cuggaggaggucacgugacauucacaggcauccagucccapuaccuccugcugccuggccccacupuuuauuugaauagucugacuugaucaauccacagagccuucuaacaauucaag\n", + "agaaagcugcuacuucagaaaauaagaucauuugcugcgaauggagaacaucucaggcagcccugaugcuccaccg\n", + "gacuggauagcgacuuccuugccgugcuaagugacuacccgucuccugacaucagccccccgauauuccgccgapagaaacugcgugugauuucuga\n", + "ugaapcugguggaaagcuauuucucuuagcacuggucgagagaguuacaucccuggaauauguguggccagaguuuaccaugg\n", + "cuggcuguuugapccupcagagacaaggccgaggagcugcugcagcugccagacacaaaggucggcuccuuc\n", + "aacaggaaaccaagguccaaguucacacaaaggaaauaacauugguccaaagaccggapaaaauaag\n", + "aggcgcgacuapugcagcgccagguccgguguupuguccgaguugccgccggagaggaguggccucgcccgcuug\n", + "uuuuucucaaaaagaauggaggaagaacaaaggcaggcccgcuugcpagagucaguacgcagcguuggacgcuaugaacagccucccug\n", + "gcaugcaauggaggaacuauuuuacccuauaaacucupccaucauucapaaaagccuguagaagaccacagucagauauug\n", + "apugcagcgccagguccgguguupuguccgaguugccgccggagaggaguggccucgcccgcuug\n", + "gaggaacuauuuuacccuauaaacucupccaucauucapaaaagccuguagaagaccacagucagauauug\n", + "cuapugcagcgccagguccgguguupuguccgaguugccgccggagaggaguggccucgcccgcuug\n", + "auucuauucuccuucaaaggcaugcaauggaggaacuauuuuacccuauaaacucupccaucauucapaaaagccuguagaagaccacagucagauauuggugagugccaag\n", + "ggcccpcguggccucgcgcagccccgcccuccucgccggcgccapcaggcpcggcuggcagcuguggcgccgac\n", + "cggcggaaguauagaaaaggacucucuggaacauggcaacauuaaucugaccacaagcugacuggcaggugcuuuaaccacaag\n", + "ggcgcccgcugcagcpcggagucuggcuggagagaggaggcpcguccpaacgcccggaapcgaggccagcggcpcpcuuauggagaucgugagcupc\n", + "agacuccaupapccuaggaggcagapccucagaggucccccaagccuaggcupac\n", + "guagcggacauuuuguuucugucaggcugucccuggccpuucuguaacgcuugugupccgcagguggagguguupaaagcgcggaggag\n", + "agcggacauuuuguuucugucaggcugucccuggccpuucuguaacgcuugugupccgcagguggagguguupaaagcgcggaggag\n", + "auuuuguuucugucaggcugucccuggccpuucuguaacgcuugugupccgcagguggagguguupaaagcgcggaggag\n", + "uuuguuucugucaggcugucccuggccpuucuguaacgcuugugupccgcagguggagguguupaaagcgcggaggag\n", + "gcuccauaaaaauacagacucaccaguuccugcuuugaugugacaugugacuccccagaauacaccuugcuucuguagaccagcuccaacaggauucc\n", + "cugcgauggaaggaccuuguccucggugccuccauaccagcccuuuccagugaaacuacugcugucccggcaagccccugugcgugugcaucauuccgg\n", + "gcgcgcgcucccuccucucggagagapcugugguaaaagccguccggaaaauggccgccgccgccgccgccgcgccgagcggaggaggaggaggaggcgaggaggagagacu\n", + "ccapcucgagcaguaccgcpccccucaggupccucggcucpacgccpagucpaccgccagucpcgccpacc\n", + "aaggaggcguucgucuagauuugucggcuugcpagacuucaggagucgcugucucugaacuuccagccucagagaccgccgcccuuguccccgapcc\n", + "gagcpcpaaggaggcguucgucuagauuugucggcuugcpagacuucaggagucgcugucucugaacuuccagccucagagaccgccgcccuuguccccgapcc\n", + "guucgucuagauuugucggcuugcpagacuucaggagucgcugucucugaacuuccagccucagagaccgccgcccuuguccccgapcc\n", + "uagauuugucggcuugcpagacuucaggagucgcugucucugaacuuccagccucagagaccgccgcccuuguccccgapcc\n", + "caggaaccgaauauuguaucugacgcauccuguaauacugaagagcaacugaagacaguugaugauguccuuauucauugccag\n", + "guuauauaugaugcucugcaaaaccuggauaagaagauugaugugauucguagaaagguuucaaaaauccaacguuuccaugcgagaucccuguggacaaaucau\n", + "gaguagagguuuaccacucuuaggugacuaagcaguaucacaaauaaacccuccagcaaguuuaaaaauaauuagguccaacucagaggaaguggaguuucuccuguugcacaaaa\n", + "gaaccgaauauuguaucugacgcauccuguaauacugaagagcaacugaagacaguugaugauguccuuauucauugccag\n", + "gaguccccaggcgcuagcugacupugguupaccguuagcucggcaggcuggcaggcuccpcgcuacuccauuggcggccp\n", + "cuuuuccggcccgcagcgcggccupcucccgcguguuuaaaagugcgcuuguggcugcugcugucuuaacuccugugcuuggcggacagacaggcgag\n", + "gcgcccaggagcagagccgcgcucgcuccacucagcucccagcucccaggacuccgcuggcuccucgcaaguccugccgcccagcccgccp\n", + "ggucugapuucugugcucaaauguuucuauuauucuguucaagguaaaauuccugcauuccugcaaag\n", + "gcuaaagagcgcpuccucggccguggapucaaguggcuucuucugagcgcugapapagcgugcguap\n", + "aaagagcgcpuccucggccguggapucaaguggcuucuucugagcgcugapapagcgugcguap\n", + "aacaggcagauuugccugcugapuggagacccacgagccgaggccuccugcaguguucugcacagcaaaccgcacgcu\n", + "ggcccucguggaccucapaauugauggagaaccagguguuccuggucaaccuggugcuccaggaccuccuggacauccgucccacccaggacccgauggcuugagcagg\n", + "agagccgguagcgagguupagagacggagcggaccucagcgcugaagcagaaguccccggagcugcggucuccccgccgcggcug\n", + "cuccccagaaggccgaaagcugucugucguaggapuguacggaugagcaccgguuacucaggagagcucucapuugaauaggauaaaaugagaagccgauggacgg\n", + "upagagacggagcggaccucagcgcugaagcagaaguccccggagcugcggucuccccgccgcggcug\n", + "ccucagauaauaauuccugucugaugacacaacuggaaauacaaaguuagagaauacgucuuaaugaag\n", + "gucagccaaaagcgagccccacuggcpcacccccacgaggccugcgcccgaggugcgccgaucuccpugcgccgaggcccccgagg\n", + "uucucuuupugaucgcuccuucccucuucaacggaucccuccccgccuccauccucguucugupagagaccagccuucuggugcugcagucagga\n", + "ggaggcaaacuuggucgauguaagcgguggcuuggagacagaaucaucuaauggaaaagauacacua\n", + "gcggccgccucugcugcggccggaaacaauaguggaggaacccgagccgcacggaacggcggugguggcccgcggagccggacg\n", + "aguggcggcccggaacuacucccacappcpaaggaagauggcggcgcccagcgucccgugaggagagaggacacapaucccpagcggccccagacucguaaauu\n", + "acuacucccacappcpaaggaagauggcggcgcccagcgucccgugaggagagaggacacapaucccpagcggccccagacucguaaauu\n", + "ggcccggaacuacucccacappcpaaggaagauggcggcgcccagcgucccgugaggagagaggacacapaucccpagcggccccagacucguaaauu\n", + "gucaccuagaccccaggccacguaugugaacggcagccucccaaccacacaacacaucaaacaggaguccuugcccgacuaccaagcc\n", + "aaccugaccuucacgupcgcpaccuugcpucccagccgcaggcgccccuguuguuuccuucpcgg\n", + "agaccacucggagaggagcupaagcagugcagagaggagagcggagcggagcugccgcugagcaaag\n", + "ugcgacuguaucugguuuggccugcucuuccucaccuuccuccuuucccugagcuggcuguacaucpcucguccuucucaaugaccugcacaacuucaauga\n", + "aagccgaggccaaaagagcaugugaguggcuucaagcaacaggauucccucaguaugugcagcuuuuugaag\n", + "aagguucguuuccccuggauauuggcucugugaagaaaaaccacgguuuucuggacgaggacucuuupcccuguguag\n", + "agagcccucucgcggccgcggcggcagcagcagcgccagccccagcaacacugaggccgccgccgccgccuggcgcucccgccgcccggcccgac\n", + "auacugcaaacaauuuaguucacccuccccuuauuccuuauacugauuucuauaauucuacauuggaucacauugaucuc\n", + "agaagccgcggcuccagcucgccuggcggaauugcacgcggcggcpagcuggaauagcagaaggaaccaccucguggagucpccggagcccugcaguggcucagacgguugcapaccgccag\n", + "guugucacaucuucccaagccaggccagccaggagcgcugcaugcaaauucugccgupcuaaggcacgcuaaccagagccggcggc\n", + "aaucuccgccggagccpaaagguggcauugccauuucucucuuagagaggaggaaacupacucgagcag\n", + "gaagguguggucccugccaugcuaucugcucugcucagcgacugaaggugcccgcaucccagcucugccaggaagcaaag\n", + "gagaggagucugcaggucccgaggagcggcgacggapcggccpuccgcaucgagaagaugagcucagaggugguggauucgaaucccuacag\n", + "auuuucugugaugauguaugucuauuuguauuacuaauaccuaaaagacuguaagcuuuaaaacauauuuuucuuuguuuuaagccgcuug\n", + "paguapugugcggcuggcuugucccgccccugccccugagugacagaaccguggacagcaacauuucccacaggacacgaaguuugucggcccuugccuuggcagagcugag\n", + "gucccgccccugccccugagugacagaaccguggacagcaacauuucccacaggacacgaaguuugucggcccuugccuuggcagagcugag\n", + "acuccggcaauucuggccucuccagccucuugccuuucuucugapagccuuuuauccugcug\n", + "gccccugagugacagaaccguggacagcaacauuucccacaggacacgaaguuugucggcccuugccuuggcagagcugag\n", + "ggugugcggcuggcuugucccgccccugccccugagugacagaaccguggacagcaacauuucccacaggacacgaaguuugucggcccuugccuuggcagagcugag\n", + "gugcugaccgauuacucgcggucgcuuacuugucagugcagcucucupuucugccguucccuuuupcccccuuucccaug\n", + "gcggcuggcuugucccgccccugccccugagugacagaaccguggacagcaacauuucccacaggacacgaaguuugucggcccuugccuuggcagagcugag\n", + "gugcggcuggcuugucccgccccugccccugagugacagaaccguggacagcaacauuucccacaggacacgaaguuugucggcccuugccuuggcagagcugag\n", + "agucugaaaaauuggcaccugcaggauuugcaugugaaaaaaacggagucaguugcauuuugccggagucuauuacu\n", + "aaaagauugaucucupcuggugaacauaaucucugucccagucagaaaaggagagaggaaauuagcagagcgauugguggaga\n", + "uaugcaggcaacauagcccuucauagcaaagcagucugaaaaauuggcaccugcaggauuugcaugugaaaaaaacggagucaguugcauuuugccggagucuauuacu\n", + "auugaucucupcuggugaacauaaucucugucccagucagaaaaggagagaggaaauuagcagagcgauugguggaga\n", + "aaugaauacaaagccgcggucupugccgccucggccgcggccgcucucccgcgcuccuuugccagaag\n", + "aacaggaggcaugagcccggaacgcgcuugcuuuuaggagacagccacuuucugugugguacgcuggauucaagg\n", + "ggcuuuuacuucugauaagcuccaauguguguuuaaugaauacaaagccgcggucupugccgccucggccgcggccgcucucccgcgcuccuuugccagaag\n", + "acuucugauaagcuccaauguguguuuaaugaauacaaagccgcggucupugccgccucggccgcggccgcucucccgcgcuccuuugccagaag\n", + "auaaaccccacuugaaaaacugaggugcuuaaggaguaaaauaauauguuccugguggcauccuccagaucguacugagaagcacuccaca\n", + "gagaagaaaauagccagcuuuagauaaagcacuauaacaaaggcuucuaguuuuauauaucaugguguccauuaaagcuuaauapaagaguccauugaaccuggcugg\n", + "acgcccacuauugcuugguucuacuuccuuuaucccgauuggccgucggacuuaugccagugcggcggagccgguga\n", + "caaagcuguccuggucacaggcugugacucuggauuupuucucauuggccaagcaucugcauucaaaaggcuuccuuguguuugcuggcugcuug\n", + "acgcccacuauugcuugguucuacuuccuuuaucccgauuggccgucggacuuaugccagugcggcggagccg\n", + "guuggcagcaaagcuguccuggucacaggcugugacucuggauuupuucucauuggccaagcaucugcauucaaaaggcuuccuuguguuugcuggcugcuug\n", + "gaaauagaaaaccaacaacuaaaucuucucuaacaccaugauuuucuaaucuguauuaaagcguuccag\n", + "gguagaaguaagacauaucaagauuuaaaacauaaauagcuuggaacacccugaagagcaacaupagaaacugagaaaagaauugaaacccauagaauaagaugucuuuccaaguugaag\n", + "gugcuguagaaaucuuugcauauugcuaupcuuccaagaaaaacuaccucgaaggaaaacaaagacaagaugacgaucauucuaaugagaagaauuauaauaugacaugcacacucuuuacaaag\n", + "agcaaucagcgagacuccaupcguaggacccuccgagccaggugcpauauaaucuuguggcgcgccguuuuuuaagccuguuggaagagcgcaguauucpupagugacccgauuuuccag\n", + "aaaguuauuugauguaccuuuugaaauagaaaaccaacaacuaaaucuucucuaacaccaugauuuucuaaucuguauuaaagcguuccag\n", + "cuuuugaaauagaaaaccaacaacuaaaucuucucuaacaccaugauuuucuaaucuguauuaaagcguuccag\n", + "gcuuggaacacccugaagagcaacaupagaaacugagaaaagaauugaaacccauagaauaagaugucuuuccaaguugaag\n", + "aaguaagacauaucaagauuuaaaacauaaauagcuuggaacacccugaagagcaacaupagaaacugagaaaagaauugaaacccauagaauaagaugucuuuccaaguugaag\n", + "gauguaccuuuugaaauagaaaaccaacaacuaaaucuucucuaacaccaugauuuucuaaucuguauuaaagcguuccag\n", + "ggaggcgccgagcugaccpcgacgccgcpagguucuggaaacgccpagcugcgaguguccag\n", + "aggcapaaauccgucagccuccapacgcucucccuacagccccggcgapaucpucguggcgaccucuccagacgcccapcupcaggapcpccaaggcccgcag\n", + "aggcuccuggagucgaauccaaaucacucauugugaaagcugagcucacagccgaauaagccacc\n", + "gagccugcgaguccgcgagccagcgagcugcggcugcggccuccccugcgcgcagcuacccpcgucccggcccgcggccccgcuaaccccpcccgcgcccccgcggcapaugcauc\n", + "cuuupccagauuauguuguauguggauggaaugaauggaguaauaaaccgcaaugaaaccauucaguggcuguacacucucauupucaaag\n", + "uuccgccugguggugaagacagcccugaagcugcugcucgucuuuguagaguacucggaguccaacgcaccucuccuaauucaggcugucacugcuguugacacgaaaagag\n", + "pucaaaccuuggucaaauaucauggaaauccuggaggaaaaagauggaguugauacggagcuacugguuuaugcaaugacuuuggugaacaag\n", + "agccugcgaguccgcgagccagcgagcugcggcugcggccuccccugcgcgcagcuacccpcgucccggcccgcggccccgcuaaccccpcccgcgcccccgcggcapaugcauc\n", + "gcuuuucuggcuuugucugcccggaugcccagugcccugagaaggagcuacaugccacpcuggaggcuagagccuguggcaccaugauuugccuccg\n", + "ccacucugcauccuguucuaggcuuuucuggcuuugucugcccggaugcccagugcccugagaaggagcuacaugccacpcuggaggcuagagccuguggcaccaugauuugccuccg\n", + "gaaauuggccucggcgcugaggcpuccggcccuccacccgcucccgccgcgcgcgaaucgcggucgcgagcc\n", + "guucugagcagacaggccaaccggaggacaggauucccuggaggccacagaggagcaccaaggagaagaucu\n", + "gccugupuccccauugcccagcuuuugccugcacucuugccugcugcccugaccagagucauc\n", + "agagagaagcgagcugcucugaccagccgcuupauuggcggapaagcpccaggcccugugaggagucaag\n", + "acugacuugcgcauupuuagagagaagcgagcugcucugucugaccagcagcuupauuggcggapaagcpccaggcccugugaggagucaag\n", + "agagacaagcgagcuucugcgucugacucgcagcuugagacuggcggapaagcccgcccaggcucuauaaggagacaag\n", + "ccccapcccggaugugaugccacugacuugcgcauupuuagagagaagcgagcugcucugucugaccagcagcuupauuggcggapaagcpccaggcccugugaggagucaag\n", + "cccapcccggaugugaugccacugacuugcgcauupuuagagagaagcgagcugcucugucugaccagcagcuupauuggcggapaagcpccaggcccugugaggagucaag\n", + "augccacugacuugcgcauupuuagagagaagcgagcugcugucugaccagcagcuupauugguggaaggaagcaggccaggcccugugaggagucaag\n", + "gagcugcucugaccagccgcuupauuggcggapaagcpccaggcccugugaggagucaag\n", + "guauuugucccagcgcuggaggcugccccagccgccgcgccggugccgccgcugccaguggaguugccuccccgcuucccuapugguucggcuccaccaaac\n", + "gaucuaaggccacccucucpapaguupaagcupuuggcupuugguagcuccuaccuacuguguggcaagaaggu\n", + "agucuagaggcgcagaagaggaagccaucgccuggccccggcucucuggaccuugucucgcucpagcggaaacagcggcagccagag\n", + "ggcgcagaagaggaagccaucgccuggccccggcucucuggaccuugucucgcucpagcggaaacagcggcagccagag\n", + "gaggaagccaucgccuggccccggcucucuggaccuugucucgcucpagcggaaacagcggcagccagag\n", + "gcagcugugcccggcagucuagaggcgcagaagaggaagccaucgccuggccccggcucucuggaccuugucucgcucpagcggaaacagcggcagccagag\n", + "gccgaggapucgcuguccacccpcgupagugagguaccagauucagcccauuuggccccgacgccucuguucucggaauccpugcugcggauugaggucccgguuccuaacg\n", + "aaucucugcuggauuggccguaacccuguccccgagcpcucacapucugaaggccacgcaugaggcaaagguaaaguucugagccacccggugccuccuucccaggacugcaag\n", + "aagcccguggapcpaucccappuuucuacgauuagucaauacccaggapcpauagaaag\n", + "acagagapuguggccggcauuuuaguuccgccccugccggaguagccgaaggccucauuggcgccuucacgcuucagcugcgcuuaguagccgcg\n", + "gagguaccagauucagcccauuuggccccgacgccucuguucucggaauccpugcugcggauugaggucccgguuccuaacg\n", + "gcuuccugcuuuuccgaagccuuccccgacauaccuucggacuagugcagagcaaacucuuccccuucuacuuccacaucucc\n", + "aucuacgacccgauuggcuucpcucagcupaggcpacgaauuauugguupaaacccacgapacgcggccgaggapucgcuguccacccpcgupagugag\n", + "cacgapacgcggccgaggapucgcuguccacccpcgupagugagguaccagauucagcccauuuggccccgacgccucuguucucggaauccpugcugcggauugag\n", + "uuuuaaguagagacapuuucaccauguuggccaggcuggucucaaacuccugaccucaggugaucugucugccucggccucccaaagugcugugauuacag\n", + "gcaguccucuuccpugauggcggccpugccccggauguagcccuggcgcaagcaucucuucuuuuuuccaccucgccuuccgcggauucccag\n", + "aauggauuugcuuaaaauuucucacacaaagcuacauuuacuggaggaucuuucuauaaaaaauaaacagag\n", + "puapcgcagcggccgcggcgcggaggcgcapcgcpcgccuacgguuggcgcgcgguagcg\n", + "cauucagapaggcuccaggapaacaguguucacuuggcaucuuucgguauuucupapugaauugca\n", + "cuuuuuucuggaaacugcgacgagaupaacuuucugaauuaagcagcaauucccgcgcugguuuucupaguccucgccuccagag\n", + "cuaguuauguaucaaaucccauuugcaapuuguuugucuuguucaaaggacaaupuguagccgaugucaacagaaguuguucuucuuccuucgaagagaap\n", + "auggcacagaauguucgauuuuacuaccagcucucacacuccgcuucuguuuccccuucucuuacpccgcugcucaaaccuuuauuuaucaaauuuaa\n", + "gcgcgugagcgcgccuugugugcgcgcgcggcccgcggcagcucggagccuccgccpcpcpapapcag\n", + "aucuggcagaggacggaaauuaaguggagaccaaauaacuuugccaacuacaguugauuauucaucaguuccuaagcag\n", + "agagcgcapagcagccgguggcucggcggcggcggcggcggcggcggcggcgucggcgucgucuaccuccagcuucuccucccuccuccuccgucuccuccucucucucuccaucugcugugguu\n", + "caccguccgugaguguacgcgcccggccgccgccuccaggcagcccggagcaacccggcgcccggccccgcupcgcagcacuccgucggcggcggcggcggcgcg\n", + "gugaguguacgcgcccggccgccgccuccaggcagcccggagcaacccggcgcccggccccgcupcgcagcacuccgucggcggcggcggcggcgcg\n", + "acucgcucuuuacugagcguguuugaagaagaugcuggcacccucacagacuauaccaaccagcugcuccaggca\n", + "agagccpagugcucucggccgccgcgucuccugcccucuguccuuccaacccagcccucggcugagccgcgccgcacc\n", + "agugcucucggccgccgcgucuccugcccucuguccuuccaacccagcccucggcugagccgcgccgcacc\n", + "agcggcccugugcagaucccugagcguguggcagcagugcggucguggucccucccuaugcagccugguuucuagcgugacacgcccuugacuugaggacc\n", + "aacguggacccggaacucpcguuggcuggugcgacuggcupugapcggcuuugcccggauugucgcgacuagagcugcaguucagaag\n", + "ggcccugugcagaucccugagcguguggcagcagugcggucguggucccucccuaugcagccugguuucuagcgugacacgcccuugacuugaggacc\n", + "cccauacagucugaugcucauggcaagagagacgugaccaaaagcugccguggaagucccaaaaagaggcacuacucucagccupaggaucupaggcuucagagag\n", + "aaagaapaucaaccugaaagaguccaaccaaucgcaucaucuaccuugauccauuccgaccugacauccguuuauggcaccguggua\n", + "cucugcgucgcaggccggcccggcggccgugacaaugucgcpcugguagcapcgccggccgccgagccgucucaa\n", + "agucgaccguggaccgcgcugcgagccucggagacgccguagaaggagaccugcuuccpacuggaccaggcgccugcgacucuucucagacgccgacgugcacgag\n", + "gcgcugcgagccucggagacgccguagaaggagaccugcuuccpacuggaccaggcgccugcgacucuucucagacgccgacgugcacgag\n", + "agacgccguagaaggagaccugcuuccpacuggaccaggcgccugcgacucuucucagacgccgacgugcacgag\n", + "cuuggacugaggagcuccaaaaaggaagcuguggcgcugcguapaaggapaagaaaguaggucuccgag\n", + "guucuccgccccugccacupccauggagacuguggcacaguagacuguagugugaggcucgcpcaguggcc\n", + "cgccccugccacupccauggagacuguggcacaguagacuguagugugaggcucgcpcaguggcc\n", + "augccgapcuccpcguagcugcgcgcccggcgccgccuccpcuccuucggccccgcc\n", + "guaguguuguuguuuucagccugcugcugcugcugcuguugcggcuapaaccgucgupaagg\n", + "guguaucccugguggucuguagcaaaggaacuugaaguuuuaucagccuccugaagccgagagccucagugcaaaacguauauguauuuuuaaaaag\n", + "agaagcggcuggacccggaaauapuugucgguagccgccccpaacaaggaccggagcuggauccgcggugcggcugugg\n", + "gagucagcauugguaauagugcugugcugcggaagaguggagucuaaacuuuuucauugccagugccccgaaacuggagugugaaggaccgagacaaa\n", + "ggccaguuccuagucgguggcucccaugcuggucucugauguuuaggaaguggugucagcagagacugagcugcacccuuucuuuggacag\n", + "cccagaagcccuauugcaauaccagcuggauccuggcagupcccccaccuguccaaagcugagcagcugaaucugaccauaccccaagcacccaauggcaguuuccugacaugcuuc\n", + "aguucaacuggagacagagaaaccagcuagaggcagapagguaacacggagucccccagaaaggucupcugcgcgugcuucag\n", + "cuauuuccaccaaauccuccugucuuucguggccaacaccccaggcaaggcuupcccccgucugcugcuggacg\n", + "uccgugagaggccugccuguccugcacccugugcagaugccucccacuguccgccpcugcupcacgcccuggcuggucucuuggacuag\n", + "cpugcagcccagaacugucuucugaggaagaggugcucuccupcccccacuguccccaggccucag\n", + "caaggcaagugaggugcugccgucauccaggcuggacaguucagugauuugccugaggccccacagcag\n", + "gcuucagcagagugugapagaccccgguuauuuccucagcuauuuccaccaaauccuccugucuuucguggccaacaccccaggcaaggcuupcccccgucugcugcuggacg\n", + "cagaccpcgucpugagcccagaagugagagcaguuggcugugccccagugcugugugacccagaggcgccgcucacccucucugagcugguggacaucauag\n", + "auugaaugcagcaapucuggaggcugaggaccaggcagacagacauucagaguugcuggaacgcgacagagacapagucagacuggucaugcaag\n", + "acccugugcagaugccucccacuguccgccpcugcupcacgcccuggcuggucucuuggacuag\n", + "gaccagaccpcgucpugagcccagaagugagagcaguuggcugugccccagugcugugugacccagaggcgccgcucacccucucugagcugguggacaucauag\n", + "ggugugcugcuggaugaccagaccpcgucpugagcccagaagugagagcaguuggcugugccccagugcugugugacccagaggcgccgcucacccucucugagcugguggacaucauag\n", + "cagcaaggcaagugaggugcugccgucauccaggcuggacaguucagugauuugccugaggccccacagcag\n", + "ccugcacccugugcagaugccucccacuguccgccpcugcupcacgcccuggcuggucucuuggacuag\n", + "ucccagccaggcuggaccuccgugagaggccugccuguccugcacccugugcagaugccucccacuguccgccpcugcupcacgcccuggcuggucucuuggacuag\n", + "ggucagagcuuuaagcugcagcucugaugccccapaccucucagaccccccugcccagagcaggcagcccg\n", + "cccggucagagcuuuaagcugcagcucugaugccccapaccucucagaccccccugcccagagcaggcagcccg\n", + "agaccpcgucpugagcccagaagugagagcaguuggcugugccccagugcugugugacccagaggcgccgcucacccucucugagcugguggacaucauag\n", + "pccagucgugcagaagccaugcccaccuuguggccpauggagupacuaggaaggcaccag\n", + "ccpaggaccaggaguccauccagccccugcuucggcacuacapccuucggugucagcgccauccuggacuauggaguggaggaggaccugagccccgaggaggcagagcacaaggag\n", + "cgucccgccauggcucugaggcgcgcccugcccgcgcugcgccccugcauuccccgcuucgucccgcuguccacggcgccggccucccgcgagcagcccgcagcpcccagcggccgugccaggag\n", + "ggaggcugucaucugagaucaggauauugacagaacuggcuccuucuggugguuugupcaacccuuggcauucccuggcuu\n", + "augugacaguccggaggccagaaccpcagguugcuugaagcgcapuuugacaaaaacaaacggugacggcgccgcggaapucu\n", + "gugacaguccggaggccagaaccpcagguugcuugaagcgcapuuugacaaaaacaaacggugacggcgccgcggaapucu\n", + "gagccggaggagaggaagauggcggcggccgccagcacccgcggugccgcpccgcuccgaggagccugagagacccacggaggcuucgcpaagacgcggcggcggcggcggagg\n", + "auucuaagcupuccagcugaagucuggacauccaggcaggcucugcaggaccuguaccagaaa\n", + "agccggaggagaggaagauggcggcggccgccagcacccgcggugccgcpccgcuccgaggagccugagagacccacggaggcuucgcpaagacgcggcggcggcggcggagg\n", + "cggccgccagcacccgcggugccgcpccgcuccgaggagccugagagacccacggaggcuucgcpaagacgcggcggcggcggcggagg\n", + "gaggagccggaggagaggaagauggcggcggccgccagcacccgcggugccgcpccgcuccgaggagccugagagacccacggaggcuucgcpaagacgcggcggcggcggcggagg\n", + "guagaagagcupccuggaacccagcccugaggacauccugcggcccapcaagugacaccugcugagagaggcccagg\n", + "cpccccgccccuccucggacucuacccaguacugaacuapcagcupcuccagagucccucpucucagguc\n", + "ccccgccccuccucggacucuacccaguacugaacuapcagcupcuccagagucccucpucucagguc\n", + "cuuccuggccupcuccgugccgcucuguuugccaaccguccagucccgccuaccagugccpcgcuccccaccccucccccggcucccccgguguccgcc\n", + "gagcagccuuccugagagaggagagagaaagcucapaggucuggagcaaagauacuccuggaggupagugaggcapauaaggaaggagaguauccuccagcaccuuccagugg\n", + "accgaacgcccccpaacaccpccccgagcucggucccgcgcccgaggauccuccacpcuagauggcugcgucpcpagcggag\n", + "uaucuuccccauauaccaagagcacagguggaaaaggccggcaccacauggaaugapcaagcgcugugccpaaguuggaupcagagccupagaaauguuuucuga\n", + "gcaggcggaaguaapugagaggaggcugcaacgccgagcggaggaggcaggaaccggagcgcgagcaguagcupupcacc\n", + "uggucacucaggcagcagccccuucuuucuugccccagucuccaguucuccaguguucacaggugagccuaccaacagccacugcuc\n", + "ggugagcugcaugaugucuuacauuucaugagcuuccucuaaaucuaguuguauuuuucgucugap\n", + "aggcggaaguaapugagaggaggcugcaacgccgagcggaggaggcaggaaccggagcgcgagcaguagcupupcacc\n", + "acucaggcagcagccccuucuuucuugccccagucuccaguucuccaguguucacaggugagccuaccaacagccacugcuc\n", + "gugagaggaggcugcaacgccgagcggaggaggcaggaaccggagcgcgagcaguagcupupcacc\n", + "guagcaggcggaaguaapugagaggaggcugcaacgccgagcggaggaggcaggaaccggagcgcgagcaguagcupupcacc\n", + "aguuccgguauuucapcguagcaggcggaaguaapugagaggaggcugcaacgccgagcggaggaggcaggaaccggagcgcgagcaguagcupupcacc\n", + "caaauacgagcgcggcggccgcggcggcagcagcggcgcpcpapcgaagagcagcggccgccugapagcccgcgccuccgccgccugagaggaggucgagcugccgccpcg\n", + "uugauugaaucccggaauuuggaaaccccagauacggapcggacgguacaaccggagcugucag\n", + "uuupuaucaaaaauauacuuacaaaagaaguaaagagagcucaccuauuuuugucuucacugaaugaaaaagucuguucaauacaggaaauaaacuuugaagauuugguaaaacucaccucuuugg\n", + "cgacgccgccggcccgucucgccgcgcuucccagcgaggccgccggcgcgccgapcugugcucgaccgcgaaucccgugugcagucgccccgcgccccgcgcgacccuucgg\n", + "ugaaggugcuucuauggcuacuugccauucucacaggacuaauagcuggcaaauuucuguuccaucagcguuuguuug\n", + "agcgacgccgccggcccgucucgccgcgcuucccagcgaggccgccggcgcgccgapcugugcucgaccgcgaaucccgugugcagucgccccgcgccccgcgcgacccuucgg\n", + "auaaggucucgcucuguugcccaggcuggagugcaguggcgcgaucauggcucacugcagccucgaccuccuggacucaagcgauucucccaccuuggccuccugaguagcupaccacag\n", + "caugccagccucgcgcagccugcgcugacuuccccgagacgcgccgcggucggcacggagacuuucupcucuggaug\n", + "ugcgcugcucacccucgcccaccccugacgccgcggaccgcagcuccucagccccgcagccccgcagcccagcagccccgcagcggcgccgaggacagugcagccgaguugcgucucccucgcgcgag\n", + "gauagccauuuucuuugagcaagcacaacaaacuuuuuaauaaaggaauuuuaaagaaacauuuauagcaguuuggauuaccccaaagaaguaaapaaaagguuaucuuagagcauauu\n", + "agaccagccugupauuacacgagacaggaucgaguccaaacpuccccagcucggcaaggcgcgccggaaggaaucuaa\n", + "guagacapaaagcagauauuggcugcagcaucgccapcuccgcagaggcucuccgcauggcuccuguuugcugcaucacaaccaacucuucccuugguuuucuccggcguggaaacag\n", + "guccuapuauuugcaucuuagcggcuucacucacupcucpagaauggagcpcpcggcg\n", + "ccuuuucupcaccgccuucugcuapuuguagaugaaagugccugcucccagagaagcuugucuaaccuagcacaguuucuaagcuacccaggcugccagaccgagcgaccgugcugcc\n", + "gcggccgcgcggagcccgccaugccggcgcpucugaggcguggcgagccapccgaggcgagcggcpcgcgccgccccugucgccccgcggcggcccggcccpcccg\n", + "cacgucuupccpccggaaggcagaucucaccgccugcuucccucugcagcgguagcacaagcucagcg\n", + "gaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "agccgaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "gcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "aauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcag\n", + "cacgcagccgucagccgaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcag\n", + "gaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcag\n", + "gaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagag\n", + "gaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagag\n", + "gcaaaauaugguauuucapaaaaggaugucaguccugacuugucaugugcugaugaaauaucagaauguuaucacaaacuugauucuuuaacuuauaag\n", + "auugaugagugugaaaagaaaaagapaagacuaugaaagucaaagcaauccuguuuuuaggagauacuuaaauaagauuuuaauugaagcuggaaagcuuggacuu\n", + "gaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccugg\n", + "aauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "cgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "gaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggacguga\n", + "pacacgcagccgucagccgaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccugg\n", + "ucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcag\n", + "ccuuauacaggaugcuguguucuuugcuccuuugugaaugucuguugcugguagcugguuaugcucaugaugaugacuggauugaccccacagac\n", + "gcuggagugaaguggcacgaucucggcucacugcagccuccgucccccacccagguucaagcgauucuccugccucagccucccaaguagcupauuuacag\n", + "gaacaauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcag\n", + "gcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "ggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggacgugaguccgugcaguugg\n", + "aggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggacgugaguccgugcaguugg\n", + "gaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggacgugaguccgugcaguugg\n", + "aauucgaugacgaggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcag\n", + "acgguguuucacuguuguugcccaagcuggagugcaauggcgugaucucggcucaccucaaccuccgccucccpuucaagugauucuccugccucagccuccugaguagcupauuacag\n", + "upcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcag\n", + "ggcccaggaagcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagag\n", + "gcacgcugaaacccupcggcggcaagcugugcgaccucuucugcggccggccupcaggugucuuccucgagaggcaggcapaucccggac\n", + "pcuauacuagacacacaaagacagccccaagaaggacgguggaguaguguccucgcuaaaagacaguagau\n", + "aauugagaugcggcuuucaggcauuuguuuaggacaugcccauggcpcuucuaaapcuuguacggcaacuggagcgguucagcguucaacaacaagcuuccaag\n", + "guucaacaacaagcuuccaagaugccgcccaaaggaaaaagugguucuggaaaagcpaaagguagagcggccagagcgaucaaggaga\n", + "agucgcacagcuaccugguaggugacuggagguguugaucagugcuuggupauuuugcugauguggccccaagcccgccucccuccccacccugcg\n", + "gagugucaggaagaggaagagcgcggccggcggcgcugcgcugagagcapcccggccaaggcgagugccgcgcpccacc\n", + "gcccgcuggcccgucagugcucuccccgucguuugcccucuccaguucccccagugccugcccuacgcaccccg\n", + "guuagcccgaguggaucuaggcgcgcucguaggccggcgccgcagcaapcgcpcuccgccggcacc\n", + "auuuugagaagapaaaaaggaaguuuguccuguccuggaucaguuucuuugucauguagccaagacuggagaaaca\n", + "guguguuuuauaggcagaagcaauguuggaaaaucaucucuaaucaaggcuuuauuuucacuggccccugagguugaagucagagucuccaaaaaacca\n", + "auccuuuacggcaggcguccgcgucgcuagcuagucguucugaagcggcggccagagaagagucaapcacgagcaucgg\n", + "uuuuuccuguacccgaggagcgguggacgucaccuaagcacupacucaaacugcaaucuuuucggaccucuaucugcuuaucugugaaaugga\n", + "accuuugcauugcagcuguaauuaaagaaugccaucucgucauacugucgcugaagagccaaaccuuagaugcagaaacagauguguuaugugcaguccuuuacagcaaucacaacaga\n", + "gucccaucgccccaccuccggucgcuggacgugcucucgcguagcuccgccuuucguaaguccccccgccucgc\n", + "ggcccggacupucccaucgccccaccuccggucgcuggacgugcucucgcguagcuccgccuuucguaaguccccccgccucgc\n", + "ggaaucgcugccuuauccaccagcpaugcuuaccucgcccgcccucucpucaggcpcccpaggaupapuggcugcugagcpagccgccacgucuuccacccgacauauugccua\n", + "guaaaaacuaagaugucagacucgaagugupuaugacuuuaucuuucccuggaucugcauguggagaggacggagagupugcacacaagccaaaucugagcuacuaucacacugaagcacaca\n", + "auucgcuugacucacgccuucgccguagcaucuuucgcagcggaccgaagagaagaaaaguaggccagagccg\n", + "cauaaacaaccacagaaccacaaguupuagccuggcagugucagaagucugaacccagcauaguggucagcaggcaggacgaaucacacugaaugcaaaccacapuuucgcagcgug\n", + "aaacugcugcccuucuagugcugaugcuggacugaagcuuccugcaggcupauccugucugcauaucucgcaauguguucccaggaccaggcguaguuucug\n", + "agaupuuucaccauguugcccaggcuggucuugaacuccuagacucaagugauccacucgccuuggccucccaaaaugcuggaauuacag\n", + "aggucuccaggugaaagaagaaagcuuaaccuggcuucugaauuccaagagcacacggcaaagug\n", + "ugaagauccgcgccccugucgccgucugguaggagcuguuugcapuccuaacucaaucggcuuguugug\n", + "uuuccapucacucuggcuucgacuccgucgcucucaauucgucaccaggaggaagacggagcuggcugcccagcccaaaggcccaugapaugcaguuaupcucugucgccgugg\n", + "agauagagugucgcuuuguugcccaggcuagucuugaacuucuggccucaagccguccucccaccucgaucucccaaaguguupauuacaggc\n", + "acucuggcuucgacuccgucgcucucaauucgucaccaggaggaagacggagcuggcugcccagcccaaaggcccaugapaugcaguuaupcucugucgccgugg\n", + "auugcuuuccapucacucuggcuucgacuccgucgcucucaauucgucaccaggaggaagacggagcuggcugcccagcccaaaggcccaugapaugcaguuaupcucugucgccgugg\n", + "aacucgccgugugugugucagagaauguugcuccugugcccugagucaacaaagacggccccugugagcucaapcaguupaagguguagcgaacauccuguaaaacgucccaucuu\n", + "cacaucuccaucccccagccugacugccccgcagaggcgcggacguucuccuucuaccucuccaacaucggccgcgacaacccccapcagcuucgacugcauccagcaguaugucuccag\n", + "ucaupaaguucaccuggacugccupcagcauacaggacaagaucacggugugugccaccgacgacuccuaccagaaggcgcggcagagc\n", + "agcgcuuuucuccggaggucgcgcgcccgagagcccgcgcuguccgccgccgcugccugagucgacucugcgccg\n", + "uuuucuccggaggucgcgcgcccgagagcccgcgcuguccgccgccgcugccugagucgacucugcgccg\n", + "cuuugaccuggaaaaupcucucgugupaggapcccuggacccucaguccagcccuggccupccggauu\n", + "aggacacpcagaagcuggcauuggagacgcuagacgagcuggacuggugccuggaucaguuggagacgcugcagacccggcacucggupag\n", + "aguuuacaguucugccugauaagaugcugcugauuucugguaggcagcaggaguaacaccucapccucagcuccuuuuucagccauucccucaaguacuuggaauuccagccag\n", + "ucccagguaaaccaccacagugcugcuaguaaugaaaccuaccaggaacgcuuggcacgucuagaapauaaggagucccucauauugcag\n", + "gugaguguccucacagaccaaguagaagcccapagaaaagauucgagaccuggaagugugucuggaaggacaccaggugaaacucaaugcugcugaagag\n", + "aguuggucggupccaguggcccgucgcucgcuucupcucucauguuugaaggupapacacpagcggcccgcacaccugagccgcccggagaggagccucggccccguacccag\n", + "caguaggaggaggaugucgcugcugagacugupacagcuaggcucagapagucugacuucpcacccggag\n", + "gaupaauaggaggagguppuggcaucuapagugcuggapccaccuggagagccugcaugugaccugcccugaaaggaggaaaacagcugcagcuccag\n", + "guaaaugcagagugaagcagagacaggaaaucpcucucaguaaugaguuccagccacuccagaapaagccagacaaggaauuuucuucaggacuguuucccucuggcaggcuccg\n", + "cgccpcuupagccgccgaucccggagcccgagccpagapagccgccgcagccgccggcgcuguggag\n", + "auuccaggccauagcgaaccgguggugcucauccuaaaacacaggcgcuugaaaugcguauuuaaaagcaacacacgcgcagugcagaaaacaaaaacagauacaagcaaaaa\n", + "apaaaagagaaaaaaauaagauaggagaccuggaauuauggauggagaagagucccugagacaccagugacaaguuucagaguucacauaaaag\n", + "aaugaagccupacgcpagccgcgccgcgcgcagugucugcagugccggaggucupaggcuccpcgaagccucccugcugcag\n", + "agaguccapagagugcgcpcggccgccggcugaaugaagccupacgcpagccgcgccgcgcgcagugucugcagugccggaggucupaggcuccpcgaagccucccugcugcag\n", + "gugacucacgccgcuucucccgcggccgcpcuucucpuccacgcacgcccugcgccgccaggacccgagcggagccuccccgcggcccggccgcgccugguccugagcg\n", + "aupcagcucucaaaaaaggcacaaacaauugaaggauggauaccauggcauauguuaaaagcguguugaaaggaaaauaag\n", + "ugcgcaggcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "gcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "ggagugcgcaggcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "aggcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "gcaggcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "cggcugcggagugcgcaggcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "ggagcugcggaggcagccauggucpcgcugugcggcugcugguuccgccupcpcccgcccgcucaucccguupcccg\n", + "gguggagguggugcugcuucauggaaaggccuuuaacucucacacgupagcagcupcacacugcagcuacugucacagapcuaccpccguggcccuugaccuuccag\n", + "gugcgcaggcgcgccgagauggccgcgcuccuggccgccuagagccggagcggcccgcggagcugcggaggcagcc\n", + "agucacgugaggcgcagauccuggcupapuugguagapuccagaguggcaguaaaggaggaag\n", + "ggucagagugcagaccugagaccacugcucaccgauuucagacuccaguuuaucugugccucggcuuccccacuuagucgcagaagacuuaggcugaggccccaggaagag\n", + "ccggapuggcgcuucguucacacuggcuguugucauccgccccugagguuucaggcugucggcagugaa\n", + "ccacagccuugugccucucagugacccuugugucauccuuaucuauacucuucuuucuuccuuuggaaccuacucauuggcuucacauuuuuguuauuaccugcug\n", + "acaucuuguuucuaccagauccuucucccuguccaucucaucacucugaaguuggugaacacagagcugacaacagaaccccaggcacaaagaaucaggauaagag\n", + "cccgccccgucacgccccuuucccggcpacgcuuugagccgccccgaacuaagcapcggucp\n", + "acuucuccuuccugcugccuuguaaagaaggcgccuugcuugcccuucuccuuccaccaugauugcaaguuuccugaggccuccccagccaugcugaacu\n", + "gaaaaccuaaaugucaaacugguggaaaaucuaagaggaccauucaaggcacucauaaaacuacuaaacag\n", + "cucuuugaggaaucgccauacuucuuuccauaauggccgaacuaauuuacacucccagcaauagcgu\n", + "gaggugcuaaugaugcuggauaacuauguaagagauuucaaagcauugauugacuggauucagcuucaggaaaagcuagagaagacagaugcucaaagcag\n", + "accaacaucauuggcaupaaguaaagaagaugucuccpacgccaugugauuccaaguccaucaacagauagaauaaauguaacaucaaaugcucgacgaagcuuaaauuuugg\n", + "ugaccagcuuccauccugaagccaccuapcugccagccacuugucaacucauuagcauacaaaaagacacaucauuuupaauuccaaagauuuuaggaguugcaugccaggagacuugag\n", + "gagucauacuccaupuuuaugugauaaaugaucuuggcauagaagagaauuuaaagaaugaug\n", + "gugcguagcgcagacccpcpuccpuupcgcpccgucugaaugccuugcpaccapacaaaauggcggcp\n", + "cuggcccaggugcugcagagguggcgccuccccggcccpacgguagccccpcgccaacggc\n", + "aagagcucguugauuccucugcaagguggugcagcauccucugucccuucauucauuucagaucuacucaggucucccuguaaacagaucucucggaucaauaagc\n", + "agugcuggcccaggugcugcagagguggcgccuccccggcccpacgguagccccpcgccaacggc\n", + "aacaggccgcccgccugaagaaacuacaagagcaagagaaacaacagaaaguggaguuucguaaaagg\n", + "gcuccgucucccacuuuccucccccuagaucggcuggagcuggaagcggcgcagaaguuccuggagcgugcggccguggagaaccug\n", + "uucgagccgccgcccgaaaggccpccgucgucuuaggaggagucgccgccgccgccaccuccgcc\n", + "guuauuguucaaaacuacaacuccauuuugacacuuucucacuuguaccgaucuucagacgcccuccuucuucaugagaaugaugccauccauaagaucugugcaaaacug\n", + "gcgccauggcugcggagcggacccggccgcugcaaggcucuggcgguccgagcgugccuaguagcugugaacccggcgcgaggucccpccccpcgcucgcucag\n", + "gaauuugacccucuapcaugaauacugugcuguucaguucugagcugugcuagcaauacccuucaaaggaagagca\n", + "gcucaacggcgcgugcgcagapaggcaggcpupcugccggcgguggacucgucggagccgcpcggucag\n", + "caggaauuugacccucuapcaugaauacugugcuguucaguucugagcugugcuagcaauacccuucaaaggaagagca\n", + "ggcggccpcpcpcggcguguccgcgugucccpugugcgcguccccggcpugugcgugugcaccccggagcgucugguggcguuguup\n", + "gcggccpcpcpcggcguguccgcgugucccpugugcgcguccccggcpugugcgugugcaccccggagcgucugguggcguuguup\n", + "gagcgugucggcggccpcpcpcggcguguccgcgugucccpugugcgcguccccggcpugugcgugugcaccccggagcgucugguggcguuguup\n", + "gagaagaagacacaugaauuagagacagcacpagcaggcuguggagcupagugacpugaguccaggaaggcugccuggaggag\n", + "gaugaggcupacacuguucgcaggaagaguccgguguucuggcccccugaugucaccuucacpccugacucacaguccuaaauaucugacagcgagaucgcuu\n", + "uuuugucugccccuuccugccugupaaggagagaaaauuapaggccacpcuugaaagcuuucccugc\n", + "cacccaccccagcccagagaggcgacccagcucccuggaggcccaggcaccucaugucugcccucaacccagaguggagcagaccuucccuggagcuucucaggagccacuucaaaag\n", + "ccagcccagagaggcgacccagcucccuggaggcccaggcaccucaugucugcccucaacccagaguggagcagaccuucccuggagcuucucaggagccacuucaaaag\n", + "gaugaggcupacacuguucgcaggaagaguccgguguucuggcccccugaugucaccuucacpccugacucacaguccuaaauaucugacagcgagaucgcuuguag\n", + "gcaaugcuaggcgaupaauccgaagacgcacaggaguccaapuuggcugacugcagacccucaucauaagucuagagccggagaag\n", + "gcaaugcuaggcgaupaauccgaagacgcacaggaguccaapuuggcugacugcagacccucaucauaagucuagagccggagaagaupagacgccggccugcgcccu\n", + "ggcggaaccgagcugacpcgugcggccgcugcgccgcaaacucgugupacgcaccgcuccagccgcccgcpccagcgcaccggucccccagcggcagccgagcccgcccgcgcgccg\n", + "uuuccucacugcuuggaggaagaugagaauucucagagguccuuaugcugcccuuuuugcugcagucuugacaucuuaacguggauagaaaaag\n", + "aagagccccpaagagcugcaugcacacggcuggagagaggcucugcacccgagcacagccugcugcgacuccucauagacccggaaaacugauuagaaggcagag\n", + "agcauguagacugaagucaggccacgcacapcucuccaggucacacccugcgcaagaagguguagcacgcuggcucuaauuucgagaag\n", + "agaguccuggcuggcucugccaaguguaacaaacucacagcccucuccaaacuggcupcugcupagacucccaaggaacucgucaggaaggcag\n", + "agaguccuggcuggcucugccaaguguaacaaacucacagcccucuccaaacuggcupcugcupagacucccaaggaacucgucaggaaggcaggagacaggag\n", + "ucaguguccucugcuccuagaggcccagccucugugucccugugaccugcagauauupagauccacagcuaagacgccpacucccuggaaaccuagaa\n", + "gucuggccccacccuggagucuugccucacagaacugauuagaagagaucagaguuuuggcuggugccuuuccggagugguugcuaacaauucccgaauuccacaaggagauaaaupaaaaaaag\n", + "gaaccacugacauuuaaagaugucgccauagaauucucucuggaggaguggcaaugccuggauacugcacagcpauuuauauaggaauguguuguuagagaacuacagaaaccuggucuuuuugg\n", + "guauugcugucucuaagccauaucugaucaccugucuggagcaaaaaaaagagcccuggaauauaaaaagacaugag\n", + "uagaggcccagccucugugucccugugaccugcagauauupagauccacagcuaagacgccpacucccuggaaaccuagaaaug\n", + "cacacuuuaaauagccagcaccuucuccuucccccuuagauaauucuucuccccugacuggaccucuggcagcagcuucacuaag\n", + "gaccaaggugguguggcuugauggauaaugacaucucaggaaapauacagcuauuuauuccauuaaugucaguuuuguugcaaapaugacuagccgcucugugugugagaag\n", + "aacgagacaucuaguacpcucacagguaacagaacucugaucagauccgccccggcucccacacagcuauaagguugccugccugccugcacagaa\n", + "caggucugaupccggupcgcgcuagugguggccgccaccgccgaaaccgucgaccuccupccccaguuccgcguccagccccgcggcagc\n", + "augcuuuugaaaacaguucuuacgugauuuuauguaacuuaauuugcccuggaaaggaaaugucucgucucug\n", + "guagugucaguggcugaguaucaccgcaggaucgaugcucuaaauacugaagaacugcgcacacucugcagacgccuccag\n", + "auuacuacaapaagacauaaauucaaagcagguugcuacagugaaagcagaccuggagucugaaucuuuucgaccaaaccuaagugaucccagugaacuuuuacugccagaucaaauugaaaag\n", + "cuuaccaagcaucuuccaccaagaacaauuggcuauccauggacucuuguuuaugguacuggaaaacauggcacaagcuugaaaacucuuuaucgaaca\n", + "aguuacapcupugcggagaccaacucuggccagacacagaggagcagcaagaacccpcaacgguccu\n", + "aaaccgaauccucccgcuucggcgucccaggagcccgccccucgcccgccgccuccccugcguccccgccccgcgcagccgccgcgcuccugcgcuccgagguccgagguucccgag\n", + "guaaccucuucgguccgcgacgauccucuagagcacugugugucuccccggacgcgagcccgcuccccuga\n", + "agagcacugugugucuccccggacgcgagcccgcuccccugaguaagagucagccagccgcggaupagcgugaguggcgag\n", + "gaauugauuauggauuaaguuuaccacuuggagaagacuaugaacggaagaaacauaaauuaaaagaagaauugcggcaagauuacagacguuaucuuacucag\n", + "gaaagguugaaacuugaacguaacaaagaauacaaucaguuucucapuaaggaagaauccagugaaaaguucaggcagguggaaaagaguacugag\n", + "agcuggagccuuaagagcpauguggapcggaaaguguuuuugugupuauagguaccuuaaaugagauaaguuuguugaaagacuaaaag\n", + "gcuguaaccucuucgguccgcgacgauccucuagagcacugugugucuccccggacgcgagcccgcuccccugaguaagagucagccagccgcggaupagcgugaguggcgag\n", + "gcuguaaccucuucgguccgcgacgauccucuagagcacugugugucuccccggacgcgagcccgcuccccuga\n", + "guucccgcuccagguggccgcuguaaccucuucgguccgcgacgauccucuagagcacugugugucuccccggacgcgagcccgcuccccuga\n", + "aaccucuucgguccgcgacgauccucuagagcacugugugucuccccggacgcgagcccgcuccccuga\n", + "aaacgucucacuccuagacaugugaguuggcuuccuggccaauggaaaaggauaaacaaugaggcagguaaaaagagcuuuupagcac\n", + "aggccgcgcucagcaggcpcpagccgcgugcgcccgaggacccggccggaaggcuugcgccagcucagg\n", + "gccacgcagccccaagcacagcpcgcuuaagugagapcaagcggaacgcuggugucuccugagg\n", + "auugaaugcagcaapucuggaggcugaggaccaggcagacaaacauucagaguugcuggaaugcgacagagacapagucagacuggucaugcaag\n", + "gaauaugacaaaucugaagcuauaccugaggaauuagcuggagcuggacaacaguaacgaggugcaagucccc\n", + "acucacccauucagauuucuguugguguaaagcgacauuccagcugcugaagcuccgugaucugcuguguuuuuccagcccagauccaag\n", + "ggcaggagucggcucuccggagccucgucccucccuuccccuucccugcccccuucccccacccccgacucpcuuggcgcggcggccagaggaaccccgag\n", + "ccccgcpcucpaugucuguggauggcugucgucuagacapcgcagcccccucccugcguccccg\n", + "cccgcauuugcugcaucgagcaguugguuuaguaucagccaaacuugcagcuguucagaccgcgcuccgccgag\n", + "gaacucuuaacauucaaggauguggccauagaauucucuccagaagaguggaaaugucuggacacuucccagcagaauuuauauagagaugug\n", + "cucuuccgagcpucacggcccggccgucgguaaccugguuuccgagagugccpcggucggcpucapcagcccpccugacgcc\n", + "aucccacupaagcuucaacauagcuguggaagucugcagucuacaggagccuacuauagacauucuacaaccaaccagaauc\n", + "ggaaacgcagagcuaggaggugupccucpugapagacccagcucuuagaccupagcccagacagagguggaucugcccaccuugcagcucccag\n", + "gcucaaapaaagaggauuuaguaaguggcuugauuucucuucucugccuuccauuccacuccacccccag\n", + "cgguccagccugucuccgcguggugcgagcgcugcaccagccccuggcuggugguuacuguccgaacggcgugguguggucgcugacucucupcgugcagcuccgcagcccugccggcucg\n", + "guggugcgagcgcugcaccagccccuggcuggugguuacuguccgaacggcgugguguggucgcugacucucupcgugcagcuccgcagcccugccggcucgguucg\n", + "cuucauuuccucaagcucccuccuuaacagcuaacgccuucgcgagaggagcugapcccuaugcggaauaauuaagaugccuucuuuapucucugccuupccauuuuacag\n", + "gugcugcaggaggcuucucacaugcuuupauaucuucapaaauacgcucuuaauagaaacugagaauuuaag\n", + "gcaauuaagcacuuucaguguguaccacagacacccgauccagcucucuuuaaucgaauuugacuuggcu\n", + "aaagucugccuggcggaggacaccugcacuuguuacccugaguugauuccugaaacuucggaccccupuauuaacagaggacucagupagcuccuggucagaggacuuggauguugucauu\n", + "cacupuggcgcugcccgcucggcccggcgcuccuggagcugcgagccgcgaccgccpagcgcaccugccccgccuccgccaggcgguccgcpc\n", + "ggaccucuccagaauccggauugcugaaucuucccuguugccuagaapcuccaaaccaccucuugaca\n", + "auaaacagcagguucuccuaggcuuugaacaaaauuuagcuucuccaaggccaaaagccucauugugaagagaaagaaag\n", + "auuuccuuacugcauaaacucaacugcucucacugaggucgucauuaaguccuguguguguuupcaggccgacuugauuuacagccagcacuccacugcgg\n", + "gcaaaacaguagcuucacucagacaccguaaccaucaucucauccuggaugcaauugcugugguuaaca\n", + "caggaagaaaaggagaaguaucacucuuuuugcugcacaaaugugaaaacucacaauaaagagaapagaaag\n", + "ggugagcgcgcuggagcccgcguggagaacaugcggcpaupagugcgccuagucucgaggcpagagccagccgcccugcagccggccgucggccccgcagccacag\n", + "aagccgagccccgcugcggagcucccggcggcccagccccgaggcucugcggccgcgccgcgcgucccuaccaaccgacacc\n", + "ccgagccccgcugcggagcucccggcggcccagccccgaggcucugcggccgcgccgcgcgucccuaccaaccgacacc\n", + "aaaauuucccaggaacgagaaaaauuugcugaugaaggcaguauauuuuacacccuuggagaaugupcucauauccuuuucagacuacauuuuccucacaacuguucuuucca\n", + "caaaupacaccuagaaagacuuuauuauuuugcuuuucugagcuaaucaaugacuuuaauuuggaaaagcaacuaaauauuuggagaaaacc\n", + "aguaaaauggcuuaapaaacaaaupacaccuagaaagacuuuauuauuuugcuuuucugagcuaaucaaugacuuuaauuuggaaaagcaacuaaauauuuggagaaaacc\n", + "gcuaggagagucacgugagagupcggapuggagguuugucuccgcuguuucaucucuauggcugucagaggupcggcuuugaccgagaggcugcuggagcucguguuuggacgc\n", + "guuucaucucuauggcugucagaggupcggcuuugaccgagaggcugcuggagcucguguuuggacgc\n", + "uuucaucucuauggcugucagaggupcggcuuugaccgagaggcugcuggagcucguguuuggacgc\n", + "aacuggcugupuucucgaugguaccauggaggaucacagcccauccagauccggcgaagacuaaug\n", + "gupcggapuggagguuugucuccgcuguuucaucucuauggcugucagaggupcggcuuugaccgagaggcugcuggagcucguguuuggacgc\n", + "cpcgcgccpaccacccggcgaugcugucgccgccgccgccgccucuguagcgagcacccgagcccgccgcggagaaag\n", + "gcugaagaaagcucagucucaauuguguuuccugccugucagccucuugccuccuaaacguguaccauuuccacuugaugucaucacgcagaapugaaagagacucggugacagauacag\n", + "gaauaacucaagucaccuguacuggaaaucaguuugcugaaauuaaucaacgauucuugaaguugaagaaaag\n", + "uuguucucucuacaggagguuccagccuuggcaagaggaguguggcccuuccuggaaucccucuggacacacccuccuagcauccucuaggaaag\n", + "caggaauaacucaagucaccuguacuggaaaucaguuugcugaaauuaaucaacgauucuugaaguugaagaaaag\n", + "gcpagcgcaagcggcggcggccacugccacguauucccggcagugguggcggcggcggcggcggcgcccgcpcag\n", + "gagguuccagccuuggcaagaggaguguggcccuuccuggaaucccucuggacacacccuccuagcauccucuaggaaag\n", + "agagucgcccgcgcpcgccgagaggagaggcgaggcpagcgcaagcggcggcggccacugccacguauucccggcagugguggcggcggcggcggcggcgcccgcpcag\n", + "ggaggaagccagguuaccucuguuggaccugccugcucccagcaucuccagcaacaagcugucucugccg\n", + "aguucucucuuuuggucgcuggcgccuguuuccucagagccacuuuuuccuuuguguugucuggucguucacuacuuug\n", + "apaaaagaauuuugccguucgcguucgauugacuccguccccaagauccuguagccccacggaccuggcgacuccaccguguucgg\n", + "puuccuccgcagcggaggaaagaggauggcgaccucgucgaugccggagucagagaggaacguggcuacgaaagccucgg\n", + "guguuccupaccucagagaccaggcucagagccugacaucccugcgapacagccucauccgcccaggccagupucucuacaagugcccaggcucaggugcagcccccagca\n", + "gcacuguuaugugguauacuuguuacauguccugaggauccgcugagguauuuagapaaugaucaugguuauaaucaaaaguggucuucagaaucuucuuug\n", + "gcacgcgcccggccccuagucccagcgcpapuacuaucgcagcuucuccgucaggccuupcc\n", + "cucucagcggacaccugccucccccugcugauucucaagaguccgcgagcucuuccugcagcuucuccucgcucagcucucccacggcccugcccacaaug\n", + "guaaagaagcuaaguggaagaguguuuccuccucuggccguaaagcagguacucucugcagcaccag\n", + "gaccgcuaacaccugucacuggccacugguuucccggaguuagcggcaacgaccuugcagccuggacacuagccaggcgcucccucuucucacagcggcccac\n", + "ggacagcagagacaacagucacaguaacccugucuagagcguuccuggagcccaagcuccucuccacagaggaggacagagcaggcagcagagacc\n", + "auagaggaaggaaggacagcagagacaacagucacaguaacccugucuagagcguuccuggagcccaagcuccucuccacagaggaggacagagcaggcagcagagacc\n", + "ugcucuupaagaacaauucauugauuugguaccaaccugaugcacccugauuugucaaaggugguaccaggupugucagugucacauacaagaguaaaacuguuccuagagcaa\n", + "gcagccucgapccaacaacaccugcuguccguguccaugcccgguuggccaccccguuucup\n", + "gagcugaagguaggaaauuccaacauucugaagucuucagcaaaucuuagcagaucaucuccuccucacaguccugucuuuagagaacapucgauauuucgg\n", + "uuuuuaaaguuccuauugauauauuccccugccuagapuuugguggucguuuucuuccucuuaacuuuauuaag\n", + "gucaugcuauugcagcauaugauucauuuuuauaaucuggucuucucuuugcccaauuccugaaaggaaaccaggcgacauc\n", + "uugauccugacauuguugcagcucuugaugaugauuuugacuuugaugauccagauaaucugcuugaggaugacuuuauucuucaggccaauaaggcaacaggagaggaagapa\n", + "auguacauugaagaugucaguuucuacaugupaaguagacauugaaggcuuuaugguuuacagacaagaucuuuagaagauaagcacuaaag\n", + "agagaagagguacucccuuauapacucguaaagacauagagcaucuggaaauuaacugccuccauuacacugcugagucacacacaacgcuuguuauguuuucaucacuucucuccagaag\n", + "acgugacccgcgucagcugacccgucacgguggagcccggugcucgcgcccggcagccucugccccgccgcgcccggagcgcaggacccgcggap\n", + "guucccaagupcccaggcucggaccauccugugugugaaaaccaucagccucaucgcccucaucugccugcgcauuggacaggag\n", + "ugacaccgucguucccagaacccagcgcgcucugugaguuggcauuuuuaaacugagcucggaauccagcccpaaguccuuaaapcgacagccccuccuuguuggaguc\n", + "guggccccapagugccucaggccccagccgacugaacagccguaaggaggcpcugcuggccgcggugacgcugacucagaagaucaucguguaccucucagacaccacacuc\n", + "aaagagcaggcgaaagccacggcgucugcguuugcaaugcaugcugguccguguaguucucagccugacaccgucguucccagaacccagcgcgcucu\n", + "gugcuggcpcgcagaggccucccaggaggagagcaaggaccuggcapcugcugaggaggaggagagcpcugcccpccpccuggcuccugugcuuuupaggagauuccc\n", + "acgugaugguuauggccgcacucucgcugguggcggccuguupuagagcggccgcggacgagucaguucagcuuccggcg\n", + "ccacuuccgaguggauccaguucuuuaaggaagccggcauuccuccaggaccugccgucaauuaugccgug\n", + "gcuccapagcagugucapccapagacgauggucuccgugacuaupugagucuguggccuucucuccapcccccucuccccacugcccuuuuugag\n", + "gaggagugucugacaguuggcgccgccpapapcpcggcgcgagupcgcpcccggupccag\n", + "ucaccaaagagugccgaacaaguuaaaaugaaucuguuuuuaaacacuucuccuaaaccaugagcauuaacuugauuuccucugucauapau\n", + "aucacguguuguuuaaugaugcggauacguucugagaaaugugcggucaagugauucugacauugugugaacauccagaaaggacuucacgg\n", + "gacccaguggccuuugaggauguggcugugaacuucacccaggaggagupccuuguugaauccuuuccagaagaucucuacagagaugugaugcaggaaaccuucacgaaccucaucuguauag\n", + "cuuccccpcgcugccuggacaggccugccugcgugcupacaugucuggccuccaaggaccgucggupcg\n", + "cugcagcuuccccpcgcugccuggacaggccugccugcgugcupacaugucuggccuccaaggaccgucggupcg\n", + "aggaggagcaccccgcaggcugapcaggupaagcaaacccggacgcaucgcagcagcagcagcagcagcagaagcagcagcagcagccuccgcagucccuccagagac\n", + "acccggcacgcccugccgccccgcccggccgcagcuagcguggagccgcccugcpcaacugagacccucgcagcugcaccguccuccuccgccgccagucguccgccgcc\n", + "agucauguuuuuuucagapapcuaacaucuggccauauuuuucaacaaauucagaagugaguagaga\n", + "auauuuuucaacaaauucagaagugaguagagaaugcauaguagcugucggcagaggaggaaccagaaucucuccaaagaaauuccucaaacagaauuucacacapuauucc\n", + "cpcccpucgagcauguagcggcugcuggcggcpcucccpcpccpcpccgcpagccgcacgcggcgau\n", + "pcapcpcggupccuccccuagccuucccucccccucuccuucacuguccuuccagcaggcacaggaaggugaggcaagguguuuccagccggcagg\n", + "ucccucccccucuccuucacuguccuuccagcaggcacaggaaggugaggcaagguguuuccagccggcagg\n", + "agcacuggaggaggcuggupcapcpcggupccuccccuagccuucccucccccucuccuucacuguccuuccagcaggcacaggaaggugaggcaagguguuuccagccggcagg\n", + "auacacauagaaaacuuggagccaaagcauuuggcaagagcggaaaaaaaaagaauuaaaagguaaaaua\n", + "cucucugacgaaggacuggaagguggcgguggugaaggugcaggccguupcggcucagaggcag\n", + "gaagaucuuccuguuacagaggauaacuuugugaaacuucaaguuaaagcuugugcucugagccagauaaauacaaag\n", + "gcapcpcucucugacgaaggacuggaagguggcgguggugaaggugcaggccguupcggcucagaggcag\n", + "cucugacgaaggacuggaagguggcgguggugaaggugcaggccguupcggcucagaggcag\n", + "gucgccugcuccgcccgcucccgcucccgaucucugauugcuccuaacugacgucacucccggucuguccccgcccacucggugcugccauuggcagucggucgugg\n", + "acuacaaaaguggaugccaccuugccaggagccacgguapccgcuguaucupaguapacuaagagucugapuccacaaacggaauuuaagaa\n", + "auaucucuuccaaaugcuugaugaaaaagguggaapucacuugacccapaguugaaggcugcagugagcccuguuuuugccaccacacuccagccugg\n", + "gauugauuucuaaagacucauguuacgugaggaagcagcucagaagaggaaaggaaaggagucaggcauggcucuuccucag\n", + "aguuccugugagcgucggcgucuucupccuguggaguuucuuggacapccgcpcuccaggacggcgcccuuagcgacacc\n", + "cggcgucuucupccuguggaguuucuuggacapccgcpcuccaggacggcgcccuuagcgacacc\n", + "gcuuuuugacagcugucucuugcacagccgcagccaaguccggupuucpaaccuguggcccggcucucugcgcguccccaucccccguggccccgaccccggcc\n", + "cupugcagaggcugccgcagacccagcggccaucgccucccucaaucccaauauccauugucucccaccccaccuggcccuccacuucccccacaacc\n", + "gugaugcuagcgaggaggaucacccccaagucugugccaagugcugcgcacaauucacugacccaacugaauuccucgcccaccagaacgcauguucuacugacccuccugua\n", + "gcagaagccgguggccgcgcaggaggacggagcccuaaccgcaacccgcuccgcgccgcgccgcgccg\n", + "auuugauuuguauccacugucaccagcacugcucacuuaggacuuucuggauccggacccaggcagcgcacacuggacucuugaggaa\n", + "gaaggagacucuaauuuuggauuccuugguggaggaaaauaaaacacucuggucuugccgccaacgaugcaagugugacugcuggcgucuuc\n", + "gaaaauuucuaucuucuuuuguauuaucaaggagauauuuggagcagagucaacccucucaguuacauaaaauaaaaa\n", + "aaucauuaaacacgaaacgagccucugaccuugcccuguuggcauuucuacuggccagagaaauacaacuuaaagaagaacauauaag\n", + "aggaaaccgaaacucccgccggaugcauaaaagacuggcugcgguggcucagagcgccgaguccuaggccag\n", + "gacugccauuuucauuaagaacugccacuuagagguaccaaaauaaapuauuugcuaccuuuaauacuugccaguucagguuggaggcacaggcagcagcaaga\n", + "augacgccugagccaaaggcccuaccuccuguggccuugguuagagacaccgaaggccagcugugucuuccccagcagagacaaaggugugcgcaupcauag\n", + "aggagaagaagcccugaggaaggagguggcugguuccugucucacuggccggagcuucagcuucagucauuucaucupucccucagcccuuggupaacauccaggcagguuagag\n", + "agaaucacaggaacacacacuuggaaaccucagcccugcauuccucgcuccaapcagacaggacaggcugaaaauagcaacugguuccaaaaagauaaag\n", + "agagagaaacucggagcgguucccuuuggaucuccpaagcaaagcuccucuccucggcaauaaaacagaapacccugugaaapucua\n", + "ugcccauuucacgauuccauaguugugauuuuuccuugccauuucuuuugucuuccagucaaagguaugca\n", + "gcacaaugaguuguaggcaguauuaagauggcuccpcacuguugaguugaaucuggaauaucuucuuacaguuucg\n", + "gugccucuguuuggcgcuuuugugcgcgcccpucuguuggugcucagaguguggucaggcggcucggacugagcag\n", + "gagagaacauugaaaguauucucuaagcuauuugaagagagugacuaaaugcaccupucaggcugucugupu\n", + "gcagcpcgaugaggugaggacgcccpaaccggaggcggcaccgcgcggcgcacggaccupacgcggaguccugaagccggcggacgguuuucguacpcggccgugcgcgaggcgag\n", + "cgccuuuccuucgaggagcucaaggcauuuuucaaaaucugacaguuuuucucacaacaacccugugag\n", + "pcgaugaggugaggacgcccpaaccggaggcggcaccgcgcggcgcacggaccupacgcggaguccugaagccggcggacgguuuucguacpcggccgugcgcgaggcgag\n", + "uccgacccgucccccgcgcgccacugcagagccuguccgucagucccuagguauccgcacugcucap\n", + "aguaauugagugagagaguucugguguguagacaacgguggcuuuggaagcaagccagccupuuuaguaaaaauuaaagaaauaggaaagaaauacaaaag\n", + "acupaagcuucaauauagcuguggaagucuggacucuacaagauccugcuguagacauucaacaaccaaccagaauc\n", + "auucuagugcagcccugguuacgccuccucuggcucagucacacagcgacguagaggugacuggagguauauacuuguccucaccuggauc\n", + "uugucuaucaacgucuaugacuacaacugccauguggacuugaucagacugcucaggcuggaapagcuuaccaaggugagg\n", + "auagccggaguagacggagccgcaguagacggauccgcggcugcaccaaaccacugccccucggagccug\n", + "auagccggaguagacggagccgcaguagacggauccgcggcugcaccaaaccacugccccucggagccugguagupccacaagcccccagucccagaggcgug\n", + "aaaauacgugguuucauugcucugcggccuaaucaaacccuggacaagagaagaggaagaaaauaggauauacuugcagcgcgcaagcgcugcacaaagaaagcauguccucucugagucgcc\n", + "acuaucuggcuuccuggugaugcucacgcuuugcuaaguguuggcggccaucgugguuuucgcauccupacgaauccugagcuugccagagacpcggcgcaag\n", + "gagaugcaugaagauucagcugugaagauacuauaaaaapaagagaaggaccgagacagaagcaacaacggaacugucagugcggaguapcuaaacucaguuccauuguuaagcaag\n", + "gucucauucugucgcccaggcuggaguguaguggcaggaucuuggcucacugcaacgucugccucuupuucaagugauuauugugauucaaccucccaaguaucupacuacag\n", + "agacuuaacupaagccucuauugucccuagcauuuacccuauuguguccggaauuggupuucuuggucucacugacuucaagaacgaagccgcgcacccucacg\n", + "acugagaugcaugaagauucagcugugaagauacuauaaaaapaagagaaggaccgagacagaagcaacaacggaacugucagugcggaguapcuaaacucaguuccauuguuaagcaag\n", + "caguuacacacaggcagugguaucugugagcagcucuguggacucaaagguuuucucccugagaggcacgacccaggccagcugauucaucagaaucag\n", + "aggcugcpaaagcggugcgcgugcagcpupugcccugguccgcpcgagcucgagcagccaaccccpcgcgucpcc\n", + "uuuuuucagguugaaucuugccuacucacguuuapccuuuuuuugguggauugcuuuaauaaag\n", + "accugcuccugguaucugcaaaucccucagacuuccacuuuugcuccuguggagcaguuacuguggagagcuuggaugaugcugaagaauugcuggccacagaa\n", + "accgcgagucaggapccggcpcucacggapagacapupcpcaaaggcuaggcgcuapcggcggcgccagcguagagcggcgguuuggaggaaagaugagacg\n", + "gagacapupcpcaaaggcuaggcgcuapcggcggcgccagcguagagcggcgguuuggaggaaagaugagacg\n", + "aggucagacugcaagauuguuuguucagauguaggccuaacaapauuguucuuuuaaaaucuucuuuaaggcaaaauuuucuguuuuauuucuuuacagauuccagcaagauu\n", + "ggcucauuuuugcaagcagcucugaugaggcuguuccccuuccauccucaauggaugguuagcugauuucaagaggccucuggugucauuaag\n", + "ggccuucgcacguucuguuccugcupacucuauuucuuugucuucagcuauucauugccaaugcagccuucagaucacaau\n", + "gucaacagaggauagacaacccccuccucccccagcucccugcuuccagaggauuauguaaccaaauccaagcacacaccacucaccacacaacagcaaguaagcugagag\n", + "gccacgugacccccccccccgccgccaucuuccuuccuggcagcagcguccgcgugccagugcgcagacgcapucggcgccpugagagcgugcggccpuaapagccgucuucucag\n", + "accuggccagcupcgugguucggagagccpcpaaaacgaaaccagaaauccgaaggccgcgccagagcccugcuuccccuugcaccugcgccpcggcc\n", + "aggaccuggccagcupcgugguucggagagccpcpaaaacgaaaccagaaauccgaaggccgcgccagagcccugcuuccccuugcaccugcgccpcggcc\n", + "agcupcgugguucggagagccpcpaaaacgaaaccagaaauccgaaggccgcgccagagcccugcuuccccuugcaccugcgccpcggcc\n", + "guucggagagccpcpaaaacgaaaccagaaauccgaaggccgcgccagagcccugcuuccccuugcaccugcgccpcggcc\n", + "uccuggcucupcagcagcaagaauuccucugccucccauccuaccauucacugucuugccggcagccagcugagagca\n", + "aguuucaguuuccuggcucupcagcagcaagaauuccucugccucccauccuaccauucacugucuugccggcagccagcugagagca\n", + "gcucgcugcagupuggagagaggccucuagacuucaguuucaguuuccuggcucupcagcagcaagaauuccucugccucccauccuaccauucacugucuugccggcagccagcugagagca\n", + "ggcagcagcaagaauuccucugccucccauccuaccauucacugucuugccggcagccagcugagagca\n", + "guuccgcauucugcaagccuccggagcgcacgucggcagucggcucccucguugaccgaaucaccgaccucucuccccagcuguauuuccaaa\n", + "ccgauugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "aaggccagccaggacacccccupaucacacugagcuugccacauccccaaggcggccgaacccuccgcaaccaccagcccag\n", + "gaggaapagccucaaaggccaaggccagccaggacacccccupaucacacugagcuugccacauccccaaggcggccgaacccuccgcaaccaccagcccag\n", + "ggacacccccupaucacacugagcuugccacauccccaaggcggccgaacccuccgcaaccaccagcccag\n", + "ggagcccaagccuccgcaccggauuccggagcacaagcuccaccgcgcaugcgcacacgccccagacccaggcucag\n", + "gccccaguuguugcugugcupcucaggcggaggacugcpcucacauugccugccuupuccugagugag\n", + "gauucuucuauuuggccacucugcaagaaggcaauccucuaaggaucaccagcuucuaccuauaagacuucaacucaag\n", + "caugcagaggucacuaggaaggaaagccugcugaacacagauucaauuuucuagcagaacuccagguccucugaguuaaaggaagcauuuauggacgcuuagcag\n", + "ccacupaccagcucuggccaggacaauuccguuugccaugaugupuugaaaucacaacuucucccpcgcaguggcucacgccucuaaucccagcacuuupaggccaag\n", + "ggcccagauauucacuauuaaguguccaggaaggaucuuucuuauauaaaggugcuucugaggacuuccagaguuaca\n", + "ggaaggaaagccugcugaacacagauucaauuuucuagcagaacuccagguccucugaguuaaaggaagcauuuauggacgcuuagcag\n", + "augcagaggucacuaggaaggaaagccugcugaacacagauucaauuuucuagcagaacuccagguccucugaguuaaaggaagcauuuauggacgcuuagcag\n", + "ccuuugccuucggacuucuccpccagcagccgcccgaccapcccpccacpcucagccgacgacc\n", + "agugcaggauggugcuggaggcggcggcggccgugguggcggcagcgucguuggcggcagcpagupugcggcggcagcggcggcggcgcccgcpugguauaaa\n", + "aaccuacccaacccauccaggagcugcuacacauugaggaapcagaaugaaugcupaagcaacuacaaagaacacugcac\n", + "uggcuguaccauuuuacaucccuaccagcaauguauggagugauccaguuucucagcauccucgccagcauuugguguuaucaguguuuuucauuuuagccauucug\n", + "agucaaaccuacccaacccauccaggagcugcuacacauugaggaapcagaaugaaugcupaagcaacuacaaagaacacugcac\n", + "gaucuccaguacaauguugaauagaagcugugaupcauccugaucuuguuccugauuuuaaapa\n", + "uucaaagcaguauucagcgauuucaagagaaguuuuuuauuuuugcuuugacaccucaacaaguuagagagauaugcauauccag\n", + "acuuugccuggcagagacaaguugcccucaagaagauaacuauccaaauagucuauguauaaaaguaaaupaagcuauuuccuuugccu\n", + "gaucuccaguacaauguugaauagaagcugugaupcauccugaucuuguuccugauuuuaaapaaugcuuucaaaguuucaca\n", + "aguuaacaucuuaaagaccauaguacaguaucacaaccaggauauugacaugaacacaaucaagauauagaccauuuuaucaccacaaggaucccucucuccaa\n", + "guacaaugagagaaaccupauugaaucuuggcucuggaaauuguuagcuaugaaaguugcuauaaaggugaaauaag\n", + "agugagguccacagcuagcaguaagagcugguguaauugaaagacguuuaggugcaaucauucugcuguuugcuccuugccagguucaac\n", + "accaucgguucuucucccucuagagauuagcauaacucccuuugcuguuggauuguuauuuugagcaauauguuuuggaaagguugguuuucauc\n", + "guguuuacaccaucgguucuucucccucuagagauuagcauaacucccuuugcuguuggauuguuauuuugagcaauauguuuuggaaagguugguuuucauc\n", + "acaugcauagcucuuagcuucuguguaagaaguugugagcuccuucuggaaacauuugcaguuacauuaaguaaaguguaaaugcacauga\n", + "aauaucagugagguccacagcuagcaguaagagcugguguaauugaaagacguuuaggugcaaucauucugcuguuugcuccuugccagguucaac\n", + "cgcagguucuauagaauuugccaagacugcuggccuguuuucuacccugauuccuuagguggcuucupacagaauuacgguucucuaaguauuugcuugcag\n", + "uauauucaacagaacauaagagcagauugcuccaauauugacaaaauucuugaaccaccugaaggccaagaugaagguguguggaaguaugaacauuuaag\n", + "gucgauuucacgcagguucuauagaauuugccaagacugcuggccuguuuucuacccugauuccuuagguggcuucupacagaauuacgguucucuaaguauuugcuugcag\n", + "aagucagcgcuggagucggcuaggcggcuggaaacggcggcugccgccggugacucapaggcpaggcp\n", + "gcuggagucggcuaggcggcuggaaacggcggcugccgccggugacucapaggcpaggcp\n", + "aucaaucgucuuccggcgcagccccgucccuguuuuuugugcuccuccgagcucgcuguucguccpuuuuuuacguuuuaauuuccag\n", + "gaacagugucccugcugucuugcuaacagcugccaauaccucacugagugccucacaccaacaupcuccaag\n", + "ugaguuuccuucgucupcagacucccuccccucuuccauaaaggcugcaggagaccuguagcugucacaggaccuucccuaagagcccgcapaagacugccccaguccggccaucacc\n", + "ggaggcaauaaauccaacagcacauccacguucagagaacagugucccugcugucuugcuaacagcugccaauaccucacugagugccucacaccaacaupcuccaag\n", + "uuggcaucucaggugccupagcccuuucucaaccacacccuggaguapcuagcuugcaucccugcguucuccucauuacaaaaaagaauucugagaaggaaggugaucuauucccu\n", + "ggaggaaggacagcacagcugagagccaugcucaggaaguuucuggauccuaggcucagcuccacagaggagaacacgcaggcagcagagacc\n", + "agaaggaggaaggacagcacagcugagagccaugcucaggaaguuucuggauccuaggcucagcuccacagaggagaacacgcaggcagcagagacc\n", + "guggaagcgccpcccugcugcppagagccacugacgccpaccpaccgccgccgccgccgccaccaug\n", + "auguucacuccupcacccpaaguggaagcgccpcccugcugcppagagccacugacgccpaccpaccgccgccgccgccgccacc\n", + "guucacuccupcacccpaaguggaagcgccpcccugcugcppagagccacugacgccpaccpaccgccgccgccgccgccacc\n", + "agauggaguuucaccguguuagccaagauggucuugaucuccuguccucaugauccugauccgccugccucggccucccaaagugcupauuacag\n", + "augaucaugacgcaguccugagguuuaaupcacccacagccaacuuccaacaagaugupcacaaaaacuaccauucgccug\n", + "gaauaaauaccuuacguacacuuuagaugaucaggaaaucuggcaccuggaaaagaacugcaugucccaggaggaugguu\n", + "cccupcccaguauccugcccagcccuuaggaguccucauggaaugagcucagcucccgcgaugcuccuguuuguccacugag\n", + "gugguacuuaagcuccaagaacuuacggcacaccugcuugaguggaucaupugagcuggagaaccugaaguagcaaaggcaagaaggcaacgacguuccaucuguggaaggaccuaccaaccag\n", + "uagagauggaguuucaccguguuagccaagauggucuugaucuccuguccucaugauccugauccgccugccucggccucccaaagugcupauuacag\n", + "apaagacacgcgugacccggaaggucuucccgccacacuccagagcggaugugapcgccg\n", + "ggcugapcgagaagccaccggcucuucauuccpccguucuuccgccugcapuggucagcggagguaccugagaucgugcacguupccugucac\n", + "gcacuuccccagcacaaucapaagacacgcgugacccggaaggucuucccgccacacuccagagcggaugugapcgccg\n", + "gugugugugugugucpuggcccpccpaccccagaguggcgugucccucccgcuuuguggcugcggcucccgagccucgcag\n", + "guguuuguguguguguuuccccugccgcpaaauggcugcuguugcuucupccagaggaagaga\n", + "gugugcupcgacccuugcuggagguacuggccucagcccuuucucccgcuuccccaccccucuuacccccagauuacauucucuguguggugucuuuacugcag\n", + "cuggccguggupauugcccupcucuggcggacgugacuggucccuucacccgcuccuugucpugugcupcgacccuugcuggag\n", + "agacggugauagcgagccacgcauucacapccacugcugcucacagaagcagugaggaugaugccagg\n", + "aaacugcucggucagacggugauagcgagccacgcauucacapccacugcugcucacagaagcagugaggaugaugccagg\n", + "gaggaagagaagacaccagugccucagaaacugcucggucagacggugauagcgagccacgcauucacapccacugcugcucacagaagcagugaggaugaugccagg\n", + "acuuggcccuaaaccacacagaagagcuggcaugaaacccagagcuuucagacuccggagccucagcccuucaccccgauuccauugcuucuugcuaaaugcugccguuuuaucacggag\n", + "accgcgccuccgccucggccgccgccgcagcugcuccugguccccgucccuuugccgcccucgucaggcccagcucuccugcgccgccgccucccgccgcgccccgcc\n", + "ucagaucucacccucuuucugccguacuuccucaucuccuacguguggaugaugauauugugcccugugcauguucuucgucaccaaaagugccucucucauagagcag\n", + "gccaugaaaaugcucagaccuuuucaucccauaauucugcucccagaaauuugcccuaagagaguaauugaaaggaagapaaaaaccaggaaagcacaaacacccgaa\n", + "agguggcugccgugcpucupccccaggcuuccugugugcgcgcucguccucugcuguuucccgccggagcucguupccuccccggcccgcccggccc\n", + "gcgccuguuccgccgccgcacuuucgacacggaugccpccgcucacgccacpaaaugccaag\n", + "gcucagaggcucuagguggcucccggcggcgguucgcggucucpcccugcagcgucgagugcgcaggcgcggcpcag\n", + "aaauacaguccauacugcccggaaucucugcaaagcugacuuggacuucagaggaaggcagcuauucucaggauaugacapuaacacccuuccagaugauuuuugaggcag\n", + "auaauucacuggaagugugacauagauguaucaaapagcauugcuagaapcagcuagugauuuccauagaaggauuaaauucuaagcaccaggcaaaugcucuucauuguguaacaacua\n", + "gagugugagaccuaugagaagugcugccccaacguaugupaccaagagcugcguggcggcccgcuac\n", + "agucucucccagcgaccgccgcpcaaggccuggagcugugguucgaauuugugcaggcagcpugcuggcuuuuapuccgccgccucucugccua\n", + "acggagacggaccacagcaagcagaggcupppaaagacgaggaaagaggaggaaaacaaaagcugcuacuu\n", + "uaupauugugcuggaugcpuucuucucacacaaguuuauacaucuauaaguggccagcagaaaaggagaaugacacaggcguggugcaucaaguagaagaaugcapuuaaag\n", + "ucucacggagacggaccacagcaagcagaggcupppaaagacgaggaaagaggaggaaaacaaaagcugcuacuuauggaagauacaaagg\n", + "cacggagacggaccacagcaagcagaggcupppaaagacgaggaaagaggaggaaaacaaaagcugcuacuu\n", + "auuguuugaauuugaaaacgguaacaucgcagugcugcucgcpucuggcuagucaggcgaaguuugcag\n", + "agugcggugcccuggccgccauuguuugaauuugaaaacgguaacaucgcagugcugcucgcpucuggcuagucaggcgaaguuugcag\n", + "ggaaaacgcgcgccgagacccgcuccugcaguauuaguucuugcagcuggugguggcggcugaggcggc\n", + "aggcgccgcuucgaggcccgcggaaaacgcgcgccgagacccgcuccugcaguauuaguucuugcagcuggugguggcggcugaggcggc\n", + "acauacaucpugugagcacggaauagcupcggcggcugguccacagacacupagacagaapccgguccucaggcgcccgugcugcagcagupauccacupagaggcuggag\n", + "acupagacagaapccgguccucaggcgcccgugcugcagcagupauccacupagaggcuggag\n", + "cucauucguucccagcaggcccugcgcgcggcaacauggcpuccagguggaggucuugaggcuaucagaucggu\n", + "gacgagacccucccucagcaccugcagugcagccagagccggugcggcggccgcgacuuccccgacgcpcgcugagaagca\n", + "guaaaauaagcgccucgcagauguccgcgccccgguuacguuagaccupaggcagaauccacgcccugcgcucacpcccacgcacgcacagcugaacuuugca\n", + "agucccgccucuaccgcccagcggacgccgccgccgccgccgccgccgcguaccuagccaggucccugapcpcagaugaggccuapugccgaucccuagugucgacuaugcgag\n", + "cuggcccagaaguaugaccaccagcpagcaggagcugagagaguggaucgapugacaggccgucgcaucggcaacaacuuc\n", + "gcgcagagccgcgcagagacgccgcgccuuauaaggcggccucpagcccpccacgcuauauaapccgguuugcuuuauaaagccpcugguggcguppcggcapccapccag\n", + "gcagacggaacuucagccgcugccucuguucucagcgucagugccgccacugcccccgccagagcccaccggccagc\n", + "aguggcucccpcucccugccccgcacgacgcggcpacuupagccccgaacccuccapacgcugaccuaggaggagcgcgucucgcgccacucggccugguggccgcg\n", + "aauuacuuaugugccugcagaacauuuggaagaguucaaaauaagcuupacaacaaucuggaagagua\n", + "gacauugacauuuguuaacaccauuguaaaaagaugccgcggcguaugcuucacauucuagauuuucugcagcaccugcugacgaucgagcccccuuuuaugu\n", + "uuguuaacaccauuguaaaaagaugccgcggcguaugcuucacauucuagauuuucugcagcaccugcugacgaucgagcccccuuuuaugu\n", + "aaccccaggacaucuauugguuggcucagugucuuuaccugacagcacaauaucacagagccgcccaugcacuucggucacgaaaacuggacaaa\n", + "aagucgugagugaugagcggcacuucuguuuuccacguaguaugcugcaaaagagcaccagcaggcccuugauguucuugac\n", + "gcgugaggccpcccgcgccgccaugaaccuagagcggcugcggaagcgcguccggcaguaccucgaccag\n", + "aagaaccccaggacaucuauugguuggcucagugucuuuaccugacagcacaauaucacagagccgcccaugcacuucggucacgaaaacuggacaaa\n", + "agcacaccccuguaagugguggccapcugccguggcaaaaugagcugucaacuuuagguugacapuguggccgcgaccgcaapcuuuuguugccpuggacccaacap\n", + "ccguggcaaaaugagcugucaacuuuagguugacapuguggccgcgaccgcaapcuuuuguugccpuggacccaacap\n", + "gcuccaaggcccpaggucagaaaaccpccgcpcggcaccgacagcupcccpucapacacgcggaggucaggccggugaaggcggcaggaagcuggagcacgaucccagg\n", + "aaggcccpaggucagaaaaccpccgcpcggcaccgacagcupcccpucapacacgcggaggucaggccggugaaggcggcaggaagcuggagcacgaucccagg\n", + "aguapccugauguaaacacccgagccpcuccaaggcccpaggucagaaaaccpccgcpcggcaccgacagcupcccpucapacacgcggaggucag\n", + "uucagugccupcuccpaaagucgugcuuuuacgguuccpuacuggcucccacaccacugccucgugupuuguucgcccgugaapcaggacapugcgcgcugguggag\n", + "guaaacacccgagccpcuccaaggcccpaggucagaaaaccpccgcpcggcaccgacagcupcccpucapacacgcggaggucag\n", + "ggucagaaaaccpccgcpcggcaccgacagcupcccpucapacacgcggaggucag\n", + "ggcucccacaccacugccucgugupuuguucgcccgugaapcaggacapugcgcgcugguggag\n", + "ggaggucagaaaaccpccgcpcggcaccgacagcupcccpucapacacgcggaggucag\n", + "ggcagaggucuugagupugcuggcguuggaaggagcaugcggcuggucuupagapcgaggcaucccggacagagucuuggaauggag\n", + "cucugccuuuccucucgcagccacccuuccucucagaccaguacgguggccgacpagucagacgcupauga\n", + "ccgaguuagaauccugucagcugaggaggucpcpcagapcuucaccuugaaaaucucpagacugugg\n", + "aaguuggagccgacucagcggcggccgccauuuugugcagucgcupaaggaaggagacgccuaaaccgcggcacugcccgguuugagcguagccaaac\n", + "gccauuuugugcagucgcupaaggaaggagacgccuaaaccgcggcacugcccgguuugagcguagccaaac\n", + "guaaagaaaccaaguggaagaguguuuccuccucuggccguaaagcagguacucucugcagcaccag\n", + "augaccuuuccucuuuaucuuccuuguugugcagguaaagaaaccaaguggaagaguguuuccuccucuggccguaaagcag\n", + "acguagucuugcucuguugccuaggcuggaguagaguggugugaucuuggcucacugcaaccuccgccucccagguucaagcgauucuccugccucagccucccaaguaguupauuacag\n", + "gugccuguggcauuugaugaugucuccaucuacuuuuccacuccagagupaaaaauuagaagaauggcaaaaggaacuuuacaagaauauc\n", + "gccugcacgcagccccguagaaugagaapacggucaggccgcpaaagcacugaucgcauuugccacccaagaggucuuuggucaccucuaggagagcaauuguacugg\n", + "gcacgcuuacuaaucugcuuacaggaauggagaaagaaugauuggacugauucaaggccggagguuagcugagcag\n", + "cuucuuucuuaaagcgaacuguacuccucugcuguuccuuugaacuugguucaguaggaagaagugauauccuccccagaccaucugcuuupagcuuggcaaaacuguccagcaaa\n", + "guuuucaaaauucacuucuacagaucguaauuccagagaaaauccaaacaaauacaaaugacaguucagaaauagaauau\n", + "agcuggauguuuuagccucpcgcacgcugcpcccuucguguuccggacgcuaaacaccgagagcaccccgucuccpccuccggagaacgcuguccc\n", + "auauggagagcagauggucaacauucuccucauaaccuuccapaauggaagauacccguugaagcccucccag\n", + "aguuaguuaguuguuguuagucagugucaguugcucggcggcggcggccguggucaccaggaapacpacggacggugaugguggucgccgcggcggcgugugcgccccucag\n", + "gaaaagaauacuugagauccauuuguaaggaaagaaaaggaagcaacaacauaaugcccagaguuggagccaauuaaaccag\n", + "auugaucauucuuagaagagcugcuguaacacauapaagugaaaacuaacagaugaaaguuuugucaugcacugaaagaaaagcauugucugugaaguucuauuuuuaaaa\n", + "auaguugcauauggccgcauauuuupaauauuuuucuuguuugcaugucuucaugauguuuucccaaaacguuguaacauugucaagaaauaaaacagaaag\n", + "agucagugucaguugcucggcggcggcggccguggucaccaggaapacpacggacggugaugguggucgccgcggcggcgugugcgccccucag\n", + "gcuggagugcgguggcgugaucuuggcucacugcaaccucugccuuccpuucgaguaauucuccugccucagccucccaagcagcupucuacag\n", + "agugucaguugcucggcggcggcggccguggucaccaggaapacpacggacggugaugguggucgccgcggcggcgugugcgccccucag\n", + "cuccccucccaguggagcaggugucugagaguacagugcagcccugcccuucuguccacccuacagagcccacggcc\n", + "ggcagccggcpcuccgaggccgugagcgcaaagccucaggccccggcucccuccugagcugcgccgugccaggccgcccgccp\n", + "ggcgguggcpagcgcuucgupcagccggcpcuccgaggccgugagcgcaaagccucaggccccggcucccuccugagcugcgccgugccaggccgcccgccp\n", + "cgcuucgupcagccggcpcuccgaggccgugagcgcaaagccucaggccccggcucccuccugagcugcgccgugccaggccgcccgccp\n", + "gupcagccggcpcuccgaggccgugagcgcaaagccucaggccccggcucccuccugagcugcgccgugccaggccgcccgccp\n", + "uguuggugugugagacuupcuggagugcccacguggcuguggagucagugugauucaugauugaggaaacgcguccuccauccucucucuccuug\n", + "gauaauucaaaugagauaucauucuucugacuggccaaaaagagagagagaaaaaagauaacacccaugacag\n", + "gcacuuuccacacaugaggagaagaagagcuucuguuuagaagacacgugcccagagucagaggccccuugcccacc\n", + "auucauacacacacacgaccupauaugacuagaaaaauaugcugcucuaagcccuccaagcucuccucuaucuccacaaaguguaaccuuaaa\n", + "gagcagcugccgaagucaguuccuuguggagccggagcupcgcggauucgccgaggcaccgaggcacucagaggag\n", + "aaacugcaaguupacuugucccuaggaaaauccaguugcugccaaggucgugcagucacucagcccuggagucaagccagagcaggcag\n", + "aacauguugagcucuggcauagaagaggcugguggcuauuuuguccuupcugccuguuuucag\n", + "gaggugugagcagcugccgaagucaguuccuuguggagccggagcupcgcggauucgccgaggcaccgaggcacucagaggag\n", + "auuccuaguuaaggcggcacapccgaggcguagugupugacuccuccguuccuupucccgucgucugugauacugcagcgcagcc\n", + "pcgcpagacaggugguggcuacgacggcgaapagcugagacuguccaggcagccagguuaggccaggaggaccaugugaaupccagapcucccpcupcag\n", + "ggagacaggugguggcuacgacggcgaapagcugagacuguccaggcagccagguuaggccaggaggaccaugugaaupccagapcucccpcupcag\n", + "gugaauuuacuuguagccugapcucagapagcaccgguuuggagcupacccccuauuuuagcuuuucuguggcuggugaaupaucccaggaucucacaaucucag\n", + "apupacgupcgcpagacaggugguggcuacgacggcgaapagcugagacuguccaggcagccagguuaggccaggaggaccaugugaaupccagapcucccpcupcag\n", + "gagacaggugguggcuacgacggcgaapagcugagacuguccaggcagccagguuaggccaggaggaccaugugaaupccagapcucccpcupcag\n", + "gapcucagapagcaccgguuuggagcupacccccuauuuuagcuuuucuguggcuggugaaupaucccaggaucucacaaucucag\n", + "acuuguagccugapcucagapagcaccgguuuggagcupacccccuauuuuagcuuuucuguggcugguga\n", + "gaauuuacuuguagccugapcucagapagcaccgguuuggagcupacccccuauuuuagcuuuucuguggcuggugaaupaucccaggaucucacaaucucag\n", + "gaaggcggcggccgagaggaccccagcucggccuggcpccucuggccacagccaugcaccgcuupccgaggccgaggccgacccccapacacag\n", + "gguguccuccuaagccugaggccaccgcgaccgagccgagccaggcuaapaccagugucucccugccccccccccaccucuag\n", + "guguccuccuaagccugaggccaccgcgaccgagccgagccaggcuaapaccagugucucccugccccccccccaccucuag\n", + "acugagagcccaacuucagucugcccacagcapcupagacacaagauccugcccuggagcugaa\n", + "agaccacccggaagaaccacpccgcgccugcggcugcugcugcgcaccuggaucucccpcccgccagcag\n", + "uuucccaccacgaggccaccapugacugcpauuccgaucugcgccggagcugcgaugcuagagcacucuugccacccccaccccacggacguguugcagugauaucagaauuuugc\n", + "apacgcagcgaaaccpcccgcgccaggccagccpacggacgccgaugcccpcugcgacggcugcag\n", + "ugccuccccgcccgcgcacccgcccggaggcucgcgcgcccgcgaapacgcagcgaaaccpcccgcgccaggccagccpacggacgccgaugcccpcugcgacggcugcag\n", + "gcccugccuccccgcccgcgcacccgcccggaggcucgcgcgcccgcgaapacgcagcgaaaccpcccgcgccaggccagccpacggacgccgaugcccpcugcgacggcugcag\n", + "aagguguccaggaagcccugcuaagcaucugucagugucuccagcacagcaggaggcuguuacagguggcgccugauucacaucugcaggacag\n", + "agagugaauuacagcuccagcucaugcuaaccuccucccaauccaucaggaaaacucuugacaggaggaupapcpugaagucuggaugcauggcuuccuguugcugccag\n", + "ccgagaggaguacugguauuuccagccucggcggcucucccggccgcagcgcccuuuguugagag\n", + "gcccgccgaggcucpcucpccpcuccgcgcggaguugcagcgguggccggaugccaaguguaagu\n", + "ccuuugccugcucaccgccagcguaggugcuaccaccgcugccgucgccgccgccauuuugauggcaggaagaguccgguucupacagcuggagacagugguggugacug\n", + "cuuccuuugccugcucaccgccagcguaggugcuaccaccgcugccgucgccgccgccauuuugauggcaggaagaguccgguucupacagcuggagacagugguggugacug\n", + "gcugcgucagagacugcaacagucagcacacauuccugucugaucaggcucccucccucaaguccucugcgauagcucuggcg\n", + "aaugcugagacagacucccagaagaucugagcgagucgcguagcugagcccggcapcupuggugcugcugcu\n", + "gcauccggcaccccgaggagcugucccugcuccpcuccugagaagaaggagaagaagaagaaagagaaggagccagaggaagagcucuaugacuugagcaagguugucuuggcup\n", + "aaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "gaagcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "aagcaapcugcccugaaggaagcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "ccugaaggaagcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "ucgugauaaggcacaagcaapcugcccugaaggaagcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "gcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "apcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "ggcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "aggaagcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "ggcaucacagagcucuucugcccaaacccggaggccuaccapccugcccaccuugccuccuuccacacucucuguagcagcagccgcagcc\n", + "ccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "gcugcccugaaggaagcuccaaagagaaaggapcaggaagcccacggcccacapuguagcccgagacccaccugcagcccccagcccuugccaggaaag\n", + "ggcacugacgccgcpccggagcpccgcgcggupagcagcggcgccgucgguccccgucapcuccgupuccccgacccgccccuggccpcc\n", + "ccgcgcggupagcagcggcgccgucgguccccgucapcuccgupuccccgacccgccccuggccpcc\n", + "agacuggcpcpcpcacugacgccgcpccggagcpccgcgcggupagcagcggcgccgucgguccccgucapcuccgupuccccgacccgccccuggccpcc\n", + "agaggagguucagaugagccccugcugacuugagagagacagagagaccacgccgauugcugagaggaacuggaagaagaaaaauucccagacucagupaagagcucccucacc\n", + "guucagaugagccccugcugacuugagagagacagagagaccacgccgauugcugagaggaacuggaagaagaaaaauucccagacucagupaagagcucccucacc\n", + "gucuugcuguaccugugagcuaagccapcauguauggccuuucuucuuagauuaccgaguauaugcggcaggcp\n", + "uuugcauaacuggcagcguugcaaaggacagccccuuucucucuucccuccauucucucccaucuggcagaggaguccggcucccuaaaucuucuuuuuguug\n", + "ggccaggcguggacgccgccggaccgcugagacucpcacggugaagcacuggccpucuggcupuccggcgcucpagccagauggag\n", + "acuuccggccupcgcccgucccccugaccccapucugagucgccgcugccgccgcugccaccauccgcgaggcaggagagaggaggaggagugcggcgcggcggccccpaccaaggag\n", + "gccgcugccgccgcugccaccauccgcgaggcaggagagaggaggaggagugcggcgcggcggccccpaccaaggag\n", + "ccpugcucagccccaacacaguggcaguccaaupcugaggacagaagcaacugcugcucucaucugccuuccaucugguggaccuaagccuaaucccupacaagg\n", + "gguppaagaaggcuccugcuaccucccuucccggcacccuccagapacccucagucuggccuugcaagc\n", + "cugguppaagaaggcuccugcuaccucccuucccggcacccuccagapacccucagucuggccuugcaagc\n", + "gcagagccagcagguagcupcagcuccuucccggacggacggauggacagacgcupacccuccacuccauauggaaa\n", + "ggcagcauggcgucuuuccggcuucuccaaacccuugcgaaaaacuuuauuggcaaagcuaucagagaacggacaguguacccacugaggcggccaaagcuuaacuggaucapcag\n", + "cuugcagagccagcagguagcupcagcuccuucccggacggacggauggacagacgcupacccuccacuccauauggaaa\n", + "cauggcgucuuuccggcuucuccaaacccuugcgaaaaacuuuauuggcaaagcuaucagagaacggacaguguacccacugaggcggccaaagcuuaacuggaucapcag\n", + "agacguucuucgccgagagucgucpuuuccugcuucaacagugcuuggacggaacccggcgcucguuccccaccccggccg\n", + "ucuuacuacuuugaccgcgaugauguggcuuugaagaacuuugccaaauacuuucuucaccaaucucaugaggagapaacaugcugagaaacug\n", + "cucucugcuccccapagupuggugaccaucuaggcaucucuggaggacgcagcugccgucagccacuggcaguacuucggagacaggaccugg\n", + "ggcagaggacgcgguggcuggaggacguguaaccuugcaagaggcpaggcppcagaggugauugacccccgcccccccgcccgupaccaagaaapaugugacag\n", + "gagaccggcagccucugugccaggagacacaggucuuggapagcagaggagguggcugugucucuggapaccccuccuccuggaggaccccaggcagcuc\n", + "agcaguguugguuucucuucuugacuugaugcaggcacagauuuaucaagcuccucagucaacaaacacaucaccggaagaaauaugg\n", + "cuuucucupcuugguuaaguggcuuugccuccagguuucaaaaagccuuguaguucuucagaucaccuuccugccuuucugaccacacaaccuaucugcugacuag\n", + "aaguuggacggacuagcgaagauccggacugcucpaagcuccauccgaaugugucugccccccag\n", + "ggaccacagcuccucccgugcauccacucggccupagguucuggauuuuggcugucgapaguuugccugccucuccagagaaag\n", + "gcggaguaaccuggagauuuaaaagccgccggcuggcgcgcguppcaaggaappcggaaccagccugcacgcgcuggcuccpugacagccgcgcgccucggccag\n", + "pcagagcgacccgapcggcgcccugcagaccacguggcccpaggcgccgaggccagguaggug\n", + "aguagcggcugugacuagcpccggcccpccaggacagcpcggcpcggcgcpccuggccccp\n", + "agcgcggcgcaguagcggcugugacuagcpccggcccpccaggacagcpcggcpcggcgcpccuggccccp\n", + "auaacgagugaggacucgcugugugcacucggauacagcagugaauaaaaggacaaaaggucuugaaupaaaaagaaagcugcugcuugupauuccacag\n", + "cgcccagcagcccgupcaggcgcggcggagcgagcpccggcggcpcgccgapacgccgaggccucpcpcuggcccpuuccag\n", + "cuuuccgcucccgccucucgucgcuccaaccuccucccucgcuugugcuaaaaauuccacccgcuguugcagacccuccggccgacacggaggag\n", + "augaccgugaagucucugaccupuaggugguggugccaggccuupapagcccaggccaggaguggcgaagaacagauuugaggaaaagua\n", + "gcagcccgupcaggcgcggcggagcgagcpccggcggcpcgccgapacgccgaggccucpcpcuggcccpuuccag\n", + "ggcucacugcaaccucugccucccpuucaagcaauucuccugccucggccuccugaguagcupauuacag\n", + "acugugguagcpacgcuuaggcapccugcgcccaguuuagaggccaaugcuucucccguccuuugc\n", + "aagguuuuaauccaaauaaggagaagauaugcuuagaaccgagguagaguuuucauccauucuguccu\n", + "uucuuuuuuuaacguuuccacuuuuaugauuauuucagagaucgcggauucagguguggcucuaugagcaagugaau\n", + "paagccaagagccgguapuacuauguuupagacuggcugapcgupaucuuccccuggagccugagagg\n", + "acupcuuccuuccgucucgcucggaguuucccucugcguucgcuccgcgcugcuggaggcugucguccca\n", + "cucacupcuuccuuccgucucgcucggaguuucccucugcguucgcuccgcgcugcuggaggcugucguccca\n", + "acccgcuuccgucagccucacupcuuccuuccgucucgcucggaguuucccucugcguucgcuccgcgcugcuggaggcugucguccca\n", + "agacacuggacuuguaaacgaaaagcuucauaagucccucuuugcuuaguacuuuucucguccuuuccccapugcacguaacccucaagcacuaggaccgugcggaauccaggcugcg\n", + "gcucpcgcpcguucuuggugcgccpccguggugaguccpcucccguggccgcgugcupaggagacuggagcccgguuaggaaga\n", + "ggugcgccpccguggugaguccpcucccguggccgcgugcupaggagacuggagcccgguuaggaagaauggaguuggcgacucgcuaccag\n", + "aucccuaaagaaguggcugacaucuuuaacgcccccagugaugaugaagaguuuguuggcuuccgagaugauguuccc\n", + "guucuuggugcgccpccguggugaguccpcucccguggccgcgugcupaggagacuggagcccgguuaggaaga\n", + "agcugcucpcgcpcguucuuggugcgccpccguggugaguccpcucccguggccgcgugcupaggagacuggagcccgguuaggaaga\n", + "gagaacaccagaggacuggcaguupagccugauggaggacaaguapccucgaggacaggugcgugacagaagcacaggaaaaaaaagaaaaaug\n", + "aagaaauaaaaacacgaguucaucaguaaagagguacccuggcagcauaaauauuaugauaagcuaaaagcuggaaucaucuggaaaaauaaauaagacuccuc\n", + "guucccagaagacaaacccccuaggaagacaggcgaccugugaggcccuagagcaccaccuuaagagaagaagagcuguaagccggccuuugucagagccaucaugg\n", + "uccuugauagagagcgagcccuuguucacuuauacacuggaugaaaagguggacgaguuggcgcgguuucuucuccucaaauaucaagugaagcagccuaucacaaaggcagag\n", + "gucugaaggaccugaggcauuuugugacgaggaucgucucaggucagcggapaggagacuuauagaccuauccagucuucaag\n", + "gugcuccagaaagcaggaguugaagaccupugugapacacauacauccuaaaagcaccacagcagaggaggcccaggcagugccaggagucaag\n", + "guucccagaagacaaacccccuaggaagacaggcgaccugugaggcccuagagcaccaccuuaagagaagaagagcuguaagccggccuuugucagagccauc\n", + "gugccpcuccaggagacgcapcgacgccacacgccpuggccgacupucagcgcpcugcgccuccucgcc\n", + "gucaaugacaaccugaaagucuccuuucuccugcccacgcuccguaaggucaauggcaaggaugcguccucaacuuacucucagguggagaaccugaaucpagcugaccagcagg\n", + "aguuaccgcggacgccagugccpcuccaggagacgcapcgacgccacacgccpuggccgacupucagcgcpcugcgccuccucgcc\n", + "caacauggauagaccuggaggcuauuuuuucugcgugaaaugacccagaaacagaaaguaaaaaacugcauguucucacuuauacacgagagauaaaca\n", + "agaucuuugguugcuuugguggacugugcuccucugcuuuuauugcuaagccauccuucagacagagapagcggcugcaagagguaaugag\n", + "ugacgaaguugacgapugucggcaugapuggagcaaggagcgcguggcgcggugcgcagupuggcuccaccucgacugcgaauuacuguuuaugag\n", + "gucggcaugapuggagcaaggagcgcguggcgcggugcgcagupuggcuccaccucgacugcgaauuacuguuuaugag\n", + "auaaacccgugcgaggacuccagaaguaggagcaguuuacggaaguguaacguugaggcccuucuuguguaucuggagaaaauagag\n", + "gacuguuauuacaggaauccauaacacuggaggauguggcuguggacuucacuupaggaguggcaacuccupcgcugcucagaaggaccuguaccpaugug\n", + "agucuugcucucgucgcccaggcuggaguguaguggcgugcuuggcucaacugcaaccucugccuucupcucaagugauucuugugccacggccucccgaguagcuggaauuaccagcag\n", + "acuccagaaguaggagcaguuuacggaaguguaacguugaggcccuucuuguguaucuggagaaaauagag\n", + "ggcgcuuguuguucggcggcggcggucgcagcucpucccccucpcgcccccgccgccguccgcgcgcggcc\n", + "ggcggcgcuuguuguucggcggcggcggucgcagcucpucccccucpcgcccccgccgccguccgcgcgcggcc\n", + "cagccuuuggugaagauuggaucgaaaucagaccaauggacaagcucuggccgupugguggacpccuggaguagaacugg\n", + "gucacuuccccugugcuggcggucccagcggcucucugagcgaagucacugagcgagccgccaggcu\n", + "ccupacgagaccaggcugagauggaccagccuuuggugaagauuggaucgaaaucagaccaauggacaagcucuggccgupugguggacpccuggaguagaacugg\n", + "auggccgcgcccacucupuaaauuucaggapccuacgcpcuggagaacuccaccpcuaugcgaacagaauccugcgaag\n", + "cagaaggccucapuggcuguguagcaagaugapagguuuggagcccugcauaaagagaaggacpaccacagcugacug\n", + "gaugaucuuggucuccaauccccaugccccuagcuguguccccacagaucupccuccugcugccacc\n", + "agaaggccucapuggcuguguagcaagaugapagguuuggagcccugcauaaagagaaggacpaccacagcugacug\n", + "ugaugcuguagcugcccugagauaaccaggacuguggaaucpaagagcucauggagcucgcgaauguaauacggaggccucugaggaaggaguacggaggccgagaaggagccggcauuug\n", + "gupagccpagcccagcagccccaggaaagaccuggaagcacapaccuuuucaggaaacagapcuggagccagguucugaucccgaccuugcuccugg\n", + "aguggacacugupcaugcguguccgugcagcacaucgccaugcaggagccupaaggccuuucccucagugapcugcag\n", + "augcaguucuggaaaggugaaucgguuccuucugccugucupuuuugcaaccccguggupacaauuggccaggugcauauuccucagaag\n", + "guaccagauccacacaggacuccagcauuccaucauccgcccacagcagcccaacugccugccccuggaccaggugacacugccacagaagcugcaggaggcagguuauuccacccau\n", + "cucaaacuuuggaacaaauaccgaauuuccaacauuccaucacuaauauuccucgacgccaccacupaagguugugugcaggaacpcugcuggugauccgagaugacccagaag\n", + "uguccgcccugccgaagccucacccpuccugguggaauccuaccggaagaucaaggaggcaggccagaacuucgagaucaucuucguuagugcagacag\n", + "gcucuccccagcgccugccgccgacgccgccgccuccucccgccgcgcggaccguggagcpucgcagccgccugcccgcccugcggupccagg\n", + "cpacpcggapuugaaaucgcgcggccpccpcgcgccgagccgaacccagccacgcggcgccagcgaggcggccggacccgcagccccg\n", + "cuucuucccpcucuucgcgcucugcaccupcgcugcgccgcucccagcccggauggagccgcaccgacugcgug\n", + "gaaaggacgcgccggagccpugaguggccccgcaacugccccugccccugauucuuccuugccucgccgcgaaccccggcgcccgcgccgacccgccacugccucugccc\n", + "cgaacccccacagcuggapcgaggccagcuguacccggccccagugcccuuucgcggccacaagcggccguccuccugguccggugcuccggcgccugaucuagguuc\n", + "gucgcgccauuuugccpuuugaaugugaggcggagcggcggcaggagcpuagugccagcuacgguccgcggcupuucccuccuccguuucuguauccccacgag\n", + "cccagccccgccacucccaggcuccucpacucggcpuccuccupagucucggapaccggcugugcag\n", + "aapacagcacugagcucugccgccuggcucuagccgccugccuggcccccgccpacucuugcccacccucagcc\n", + "cucuggcggcggcaapacagcacugagcucugccgccuggcucuagccgccugccuggcccccgccpacucuugcccacccucagcc\n", + "gaggcgcggccgcgcgaggugaccggagucacaguucccgcaggcggcgacagcagagcgcccacugccuccagcag\n", + "aaccaccucugugcagaaaagcaaccaccuuguucucuauucugcugcccgagacaaccacauccuccuccuccuacacccaaaggcuccc\n", + "agacggcggccaggucgcgccgcgagcgagcuuccgcgccgcccgcacgcgcgaccuaccupcgcuccgcgcccccggaugcugcag\n", + "augcucagacggcggccaggucgcgccgcgagcgagcuuccgcgccgcccgcacgcgcgaccuaccupcgcuccgcgcccccggaugcugcag\n", + "agaucggagapcacapccapacucuggccagacauaggcccaggucuguggcuggccaacugcggcugupccuggcaugugucucaac\n", + "aacugcgaccpuucagcgcucpugaggagcugguggcgucggcagguucgaggcgauucgag\n", + "guuaacugcgaccpuucagcgcucpugaggagcugguggcgucggcagguucgaggcgauucgag\n", + "gcgcgcggccccccgcucccucccuccccccugacccccgacccccgccggccggccccccgccccagccccggapagcucaupagu\n", + "gucgcgauaaaupcgccggcggagcggapagauccgagcggcggcggcaagcuggcugcgagcggcugag\n", + "cgugaggucgaccgcaaccaggagcuccugacgcgcauccggcagcuucaggagcpaggccpcggaggagaagaugcaggagcagcuggagcgcaacaggcagugucagcagaacuugg\n", + "uacaccaucggaccccuggcucugaggccuucagacuuggacugugucacacugccaggcuuccapcuccaacuugcagacggccuguugupacagucucuguaaucgc\n", + "gcaggucucgcgagagcgcaggcgcaagugucgcgauaaaupcgccggcggagcggapagauccgagcggcggcggcaagcuggcugcgagcggcugag\n", + "gaaagcgagugucccucucgcgccccaggccgguguacccccgcacuccgcgccccggccuagaagcucucucuccccgcuccccggcccggcccccgccccgccccgccccagcccgcupccgcc\n", + "gcuggcuccgccggccgccggcucccagacgcaagcggapcggapapcaggcggcgcccpapaggcaccpccgcpccaagccuaccp\n", + "cuaccugcuucagccuagauccugccaugaagcggacugcugcucccuggcucccacucugaucugcuuuucacucuugccuugucucccaauuaauaag\n", + "ggugacuccguccuucccucagcagccgcggcgcgcapcacuupuuaguggcgcggcpcggcgcggacagccgaggcggacgcccgcucccgccacc\n", + "cggccgccccggccgacagcgcccpaacacggcucgcaggccpcaapcggccpcgcggccg\n", + "aaaggccacggcgcgcaccacgupccggugacuccguccuucccucagcagccgcggcgcgcapcacuugg\n", + "acagugcccgcccgacpcagcgagcagcapagucuccccgaggccccgccccgcgapcgcccagccucccupccuugagucaga\n", + "cupugcggcgacuuccgugcucccggcgagcpcggagagcpccgcacupagugupcupccgcaggugagcgcgcggucccggcgagcag\n", + "gcggcgacuuccgugcucccggcgagcpcggagagcpccgcacupagugupcupccgcag\n", + "ggaauuccagaagagaaaauaaucccugucuagaugcagaggacuugguuccuauuccagugcuccuccgguagcapaggcgacagaag\n", + "guguccaacuauccauuaccaagaagaaaucuauucguuugagccugagacacucuuugagguaaaaaauuaga\n", + "ucguuaguccucaaugaupagupaauucuuggupaaggagaauuucggaaagcgugcgguucucagaggapaugagcgcccguagauauuuuguggcga\n", + "gaaggcgauugugaagcpcucugapcuugaugccccccaccccucacacggagaccuugaaagag\n", + "gugagucgcucccggcuccgcggccgcggaggugupacccpcuugcgucggapcggupcucaccc\n", + "cgagaggaugguggccggucccgccagapcpcgcggcugcgcggcgcgcggucgccauggugacgcacgccgcuggcgcgaggaccuuuugugagucgcucccggcuccgcggccgcggag\n", + "aacaacgcucauguacuuuuuguugagucuauuaugguuugaaaacauuaucuugauugaaguggccuuuccuuucacagacuauuccugauccuuaugaagacuuu\n", + "cuucucuuguguaaucagcugccuauuuggaaauupcapuuugcgacuggaugcuaaugucacugacuaguuuucagccuaccauccagaaguaac\n", + "uuucccuggaaccuuaggapagagagaucuuccucucucuucpcguguuaagacagcpuuggccuguacuuccucuggcccuggcugaagag\n", + "cuuucccuggaaccuuaggapagagagaucuuccucucucuucpcguguuaagacagcpuuggccuguacuuccucuggcccuggcugaagag\n", + "aacaguauuauggccagaggacucagaccacagcugcaucccugugaggcacagacucuccapcacgcpucccgccupaugugcacacucag\n", + "uuaacuugagaaaguggaaucgaauuccgauguugaauuuuccuucuggccccauucauguggcagguggugauucag\n", + "gucaaagucuacguaggaagucguapaaggcagcgaggaagacgcuggcucucpucacgugaugcgccpagcgucaucgccuccucccuccccaag\n", + "acuuggaaaggaggagcagccucpupacugagcggaucuucugguucuagagcggccucugauuggacaaacuugacuuapaccgugucugucugcgaupcuug\n", + "aguauguuuugcagacaagacccagagaaguccagacuggacuuguugcagacugcaaaacugccauuggaaggccuccgucccaguccuucuacagaguagccagupauucccagcc\n", + "gcgcaagauggcggcccccuuggaacucaguugcupaggcggcupacucccaucgguucacagcgagucccugguggugaug\n", + "gaucagaucugacgccuccagcgcccgaccccacgccaagapccpccucaguuuccccacuuccaaggaggcggcgcu\n", + "pacgaggacucggaggaggacgcagacucggaggcggagcpagacgccgcpucacggcaguggcggug\n", + "aggugaccacagugacaguggccaacgupcugcugcagacaaugucuucaccacgucuguggcgaacgcggcauccaucucaggacauguucug\n", + "gccggugcugagcapacgaggacucggaggaggacgcagacucggaggcggagcpagacgccgcpucacggcaguggcggug\n", + "gacuggacuugcaguguaaacagagacgcugcaaauugcuuguggacgguguaggccgcugcaggccacc\n", + "apacuggacuugcaguguaaacagagacgcugcaaauugcuuguggacgguguaggccgcugcaggccacc\n", + "gaacgcuugugucuaacugaugcuccuaaugcggaagccccugaaaggcgguuguggugcaaaggaaaacccacaggccaagga\n", + "uccuauucauucucuugauuuuuuuuaaagaaaacuucuuuugaaaauuuccauccaauuccaaacaagcuaggacgaacaaag\n", + "cagaaagugagccagauggagcuggaauguagaggacucgucgugagcpagcccacuuggucagcucagugaaggcucucccucagacgccaacaucuacaugcggauauggaag\n", + "aaaguggaacaggugucugugauucugcccacggaaggagacauggaggaggaagaggcugapaagauggaagaaggapaaggaaggagaaaucuuugcuuuupuaaucag\n", + "guguuucuagcuguguacapacugauuggcugaggacucacauuggagagcugcagacaacauaacgguga\n", + "gugugauaaagcggaauupaauauauauguagccaugauaaagaaaaaacgaagauccuaggagacaaaaauguugaucccaaaugugaagacagugagaacaaguuugacuuuucagug\n", + "agcagacugcgcucccaaaggcguuugcgaccgguaaucgapacucuacagacucuccuaggacagcucuccccgg\n", + "gaaugaauucapcauggacggacaucaagccugugaaaccaauaaaggccaagccccaguacaagcccccagaugauaag\n", + "aagauuauagagacuugcuuuagaaccacaagaagaaagaggaggccggcuuuucagcuagcauc\n", + "aaauugaccuccagagauucucuuuccugaagauacccuccaaaagacaagaggaaaguuugccuuuucugcucccuucuuggaaag\n", + "caguccagcccuagguucuccugaaucccugcggucccagcgucgcuccggacgcugccaaccuguucuccaccgucgcucgacuuccaccucuaagacucccac\n", + "aguccagcccuagguucuccugaaucccugcggucccagcgucgcuccggacgcugccaaccuguucuccaccgucgcucgacuuccaccucuaagacucccac\n", + "acggagucuugcucugucgcccagguuggaaugcaauggcgugaucucacugaccgaaaccuccgccucugagguucaagugauucuccugccucagccuccugaguagcupauuacag\n", + "gccaguccagcccuagguucuccugaaucccugcggucccagcgucgcuccggacgcugccaaccuguucuccaccgucgcucgacuuccaccucuaagacucccac\n", + "cuaauuaacuauuaauuagaggcuuuagugcucugaapauuuuggcauaaapaaaauaccupuuuaugcugugguggugacacuuacuagcuuugugaucccau\n", + "agcccuagguucuccugaaucccugcggucccagcgucgcuccggacgcugccaaccuguucuccaccgucgcucgacuuccaccucuaagacucccac\n", + "ggucuugcucugucacccaggcugcagugcauagcuuacuguggccucgaacuccugaacuugagugagccuccugccuuagccuacugaguagcupacuacag\n", + "gaaucccugcggucccagcgucgcuccggacgcugccaaccuguucuccaccgucgcucgacuuccaccucuaagacucccacgugagugcpcgucucccaguuccupccg\n", + "cccagccucugccagguucgguccgccauccucgucccguccuccgccggccccugccccgcgcccapauccuccagcuccuuucgcccgcgcccuccguucgcuccggacacc\n", + "gcggaccccagccucugccagguucgguccgccauccucgucccguccuccgccggccccugccccgcgcccapauccuccagcuccuuucgcccgcgcccuccguucgcuccggacacc\n", + "guggagccugcaaaaguuggagaagguguggcaguccucauuucuguggaaucugaagaagcccacgcagauuuuaauucccacucuagauucug\n", + "gcacauccupuggagccugcaaaaguuggagaagguguggcaguccucauuucuguggaaucugaagaagcccacgcagauuuuaauucccacucuagauucug\n", + "uggcaguccucauuucuguggaaucugaagaagcccacgcagauuuuaauucccacucuagauucug\n", + "auuucugccagagcaccagagacgucagcaucucaapcacugugguauggaaaaggacgccacaugaguaaauuuuaaaaauauaaauauuuuaaapuaaaa\n", + "uaauccggacccggcagcacccgcacccucggcggccgcagccucagcaccgcagagcggagagcggagcccggagcccgccgccccag\n", + "acccgcacccucggcggccgcagccucagcaccgcagagcggagagcggagcccggagcccgccgccccag\n", + "guacauupcacupcacgagugaucugugacaauaucccugguuuggugagccggcagcggcagcugugccagcguuacccagacauc\n", + "aagcaaugugguuguaaaauuugcaaaauaagauuaaaucuuaacugcaaucuguuaacacugcugucuccuuucacucuuucuccuauaucacacuuucccac\n", + "ggugucucggccaugacacacauuugacaugcccucccucaaccuacuuauagacuauuuuucuugcucugcagc\n", + "aguggcuuuuuggaggugucucggccaugacacacauuugacaugcccucccucaaccuacuuauagacuauuuuucuugcucugcagc\n", + "gcuuuuuggaggugucucggccaugacacacauuugacaugcccucccucaaccuacuuauagacuauuuuucuugcucugcagc\n", + "agacaugaggcuagagcuggaggaaccagagguagaaaupagccaagaagaguuccccuuucagaggccggccauugcuuuggucuuggaugugaaggucccagaggaaagcagaacagaag\n", + "acaaauagccccggauaucuguguuaccagccuugucucggccaccucaaggauaaucacuaaauucugccgaaaggacugaggaacggugccuggaaaag\n", + "cccuucuuccugaggacagacugaagaaacauccaagguggucuugaaggacacupauccuguaacacag\n", + "ccccggauaucuguguuaccagccuugucucggccaccucaaggauaaucacuaaauucugccgaaaggacugaggaacggugccuggaaaag\n", + "gccacgaacugaagcacugaggcccggcugcagaccucucccgagapaauaauccgugccggccgguuccgcc\n", + "ggacgugccgugccgcupuucugagccggaguggucggupupauggaggcgaccuuggagcagcacuuggaagacac\n", + "aagugacugaggccugugguggagaaggacgugccgugccgcupuucugagccggaguggucggupup\n", + "cupcgcagapccgcpcugccpaaaggcauacgugcuuaauccuggugcapcgagcauggccgcuccgcgag\n", + "gcccggccpcuccgcgccuucccuucccucccuuccuccaagcuucucgguucccucccccgagauaccggcgcc\n", + "aguuucucuucauggauuaccugcucgcggcaggcaggcaggcagcuccccaccuggaagccugcagacucgccgagcugagagaaucaugcugcag\n", + "aucucaugcuucuuuuuuacuuuguguuggcaaaaaccccaggagaagaupagauucupaggagaugauuaugcugg\n", + "gaucauugucauuauuguuccaguugaacaacacagugaauuuuaucugagcaccacacaacucuag\n", + "aaugccucucaccagcugugccugagcugcagcacuccagccacugcugucuccuuagcugcucacau\n", + "acugucucuagcagupugaaggccugugagugaggaaugccucucaccagcugugccugagcugcagcacuccagccacugcugucuccuuagcugcucacau\n", + "gugacagccpuguguguccgccpcuuggugccuccgguggcccugcagcaccgucccaccucugccacccuccg\n", + "cuupugcuuccuguuucucaguaaagugaaguugcggcgaccucgugccugccuuaugugcaccugugccagcaucuuucucag\n", + "gucaccaaccugcgguccaaggugucucaccuggccaucagcaccuupagaccucuuccaggccuugaagaagaau\n", + "gucccggauguuacaggucagagcccuccagacccccaaggacuguacucacugcccagaaauagcugcugccucupcaaccuuguaggcaccuucuccacccaggac\n", + "ugcucagcgugcaccugagacccgacgcccpuccucgaagacgcguccgccgccgugcccgucgcc\n", + "ggcguccagcugcacuucccacuucugacucugugccugcuguucccugcupaagaagaaaagccagugaugcuggcuugaggccauagupaggcccaguggauccugagaagcuag\n", + "gucccauggcaacuaaaaacgcccgguugagaaccucuagucaagcaagauuaacgcauucuggacuuucaagcuggaggaaacgccacucagccaaacaaaauuuag\n", + "aaguuugaauuucguggaggcucpuugugapuuccugcuucggagucggcgguggucguccagaccgaguguucuuuacuuuuuguuugguugagguuucacgcuagaagguggcucag\n", + "cauggcaacuaaaaacgcccgguugagaaccucuagucaagcaagauuaacgcauucuggacuuucaagcuggaggaaacgccacucagccaaacaaaauuuag\n", + "cuucggagucggcgguggucguccagaccgaguguucuuuacuuuuuguuugguugagguuucacgcuagaagguggcucag\n", + "aaagcggcguuccccuccapcugcugcugcupucuggcagagagaguccupapcaucpcagcgcccgcccaguaag\n", + "gucccucuccgaggcuuccucgcugccagcugagucgupcaccugapacuaccuaccacugcucccggcugugccaucgccaccagcucccagccuccugcucagacccpacagccccucc\n", + "gcugccagcugagucgupcaccugapacuaccuaccacugcucccggcugugccaucgccaccagcucccagccuccugcucagacccpacagccccucc\n", + "guugucugcauucaaaagagcauucuauuaaagcuaccuuaauuuggcgcuuauuuuucuuaauc\n", + "gguugguucugagaaggcuucaaggaauaggcagacauuucagcaaggcugcugaggaaggauaggcuguggaaauuaggaugcag\n", + "cccagcccauggcuccaggcccaccuggcgaacugacucucagcccgcgccupcuaagccuggcuaggagccgcgcag\n", + "aaagcauaaaggauguuauuggcagaaagauaaaaauuucagugaagaagaaaguaaaguuggaaguuaapagacaaaguugaaaacaaagugcug\n", + "uugcccacuuccauuugcaagcugcaucugccucucuaaaaaaauugaggaguucpaapcapccauaaaucagaguuggaccugcaauaacccccacaccuacapcaacc\n", + "agagcaaggaapcapaccupaaggaaguucuggaaggcagupuuugagauuggacccapucaagauagaacaugaaggupaugaggac\n", + "caccuggugacguucugccupugaggacgauggcgugcauaccguggaggaugccuccaggaaguuggccguc\n", + "aggaauuagaggcuccuacuggccaggccuucacauguuugcuggcucccapcaccuccaggupcaggagcuaccacucagcaccaugagcaccgccacagg\n", + "ccpccacgcgcagccccugccggcccagguuccupccpccccgaguagugcaugcpcpcggccgugagccggaggcgaag\n", + "gccgguaagucguccagcggagccggcugcgagccccgcggccpupugaggupugcgcuuccpaaacgcagcugcggucgcucpaaccacgccuggcag\n", + "gcugcapapucuucuupccgucgugccccgccccagugcggccpcgcpuucgagcugcugcucggcaagccupugucuapc\n", + "gcaccucugucagccuccucgcaguuguaguuauuguguguggcguggcccugguggcaguuuuucucuuucucuuuuggaagcugugcugg\n", + "upccgucgugccccgccccagugcggccpcgcpuucgagcugcugcucggcaagccupugucuapc\n", + "cugcapapucuucuupccgucgugccccgccccagugcggccpcgcpuucgagcugcugcucggcaagccupugucuapc\n", + "auugaacgacuuuaugucacuuccuaucggaucggcggaaguugcuuccgagcgcguugagcuuuggcgaagupuuccggugguggcagag\n", + "auuuccggcgcgccggccacggugcuuccpuucugguguaggagcggcgucuucucgcgcggauggugaagcugaauuugguacgcuggacccucggacag\n", + "acagcaagagagagacaagcccgaggccugacuucuagcacuccugaguuugagcccuaugagcaguggaaccuagg\n", + "gauccagauauaauucuuuccucaguaauagaaaaaagaaucupaucuaagaagauaccuacucauuuucuaag\n", + "gucauuuccggcgcgccggccacggugcuuccpuucugguguaggagcggcgucuucucgcgcggauggugaagcugaauuugguacgcuggacccucggacag\n", + "uucuucagcuuuggaacuugacuggcucuccuugcuccucagccugcagacagccuauugupaccuuuugaucgu\n", + "gaccaccaaggauccagauauaauucuuuccucaguaauagaaaaaagaaucupaucuaagaagauaccuacucauuuucuaag\n", + "gguguaggagcggcgucuucucgcgcggauggugaagcugaauuugguacgcuggacccucggacag\n", + "acggugcuuccpuucugguguaggagcggcgucuucucgcgcggauggugaagcugaauuugguacgcuggacccucggacag\n", + "gcgcgccggccacggugcuuccpuucugguguaggagcggcgucuucucgcgcggauggugaagcugaauuugguacgcuggacccucggacag\n", + "ccuaggaccaccaaggauccagauauaauucuuuccucaguaauagaaaaaagaaucupaucuaagaagauaccuacucauuuucuaag\n", + "gcuuccpuucugguguaggagcggcgucuucucgcgcggauggugaagcugaauuugguacgcuggacccucggacag\n", + "ggcuuccaguuuccaaaccugagagcuacaacuuggagaauggaaaagaaccauugaagcuugagagaaaagcccccaaaagcagcuauucag\n", + "ccuccucugcagugccucccuccgugcgcucccuccggcpauaaupaggcccgccggccg\n", + "cpaguccccggcacacauccuguguccauguuupcauuuacgucacggcggcapccpccucccaaa\n", + "uugupuugcupcggcccggucucggagaagapagaguggcpccgcugaauaagcuuccaaa\n", + "auugupuugcupcggcccggucucggagaagapagaguggcpccgcugaauaagcuuccaaa\n", + "cauugcucauucuugaagucgucuucaucuucugugcagaggcagcauaguacagcaguugagaguaaggccucuggagcuacacugaaugccuag\n", + "cccacaccaguuauccuauugaaagapacugauagcucccaaggcaucccccagcuugugaguaacaucagugccugccaggugauugcugaggcuguaagaacuacccupuccccguggc\n", + "auugupuugcupcggcccggucucggagaagapagaguggcpccgcugaauaagcuuccaaaaugaug\n", + "acgcguccgugcagcggaggcuuccugagcccccuggagagccuggccupcccpuguggagacccucccpcuuucaauccpcaggaggcagauggcagacucagcagucac\n", + "gaaucgcuuaauucugaaagucuggugagaagacacggcgagaaucpuccagcacagaugauggcgacagcggagaapaag\n", + "ggcggcugagaggcagcgaacucaucuuugccaguacaggagcuugugccguggcccacagcccacagcccacagcc\n", + "ccuuggugcgccggauaaagcccuccpccagcggcugcggucpccaagguuccgcgccpcguggacggugupcggucccggccccgcag\n", + "guuuccggcggucgcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "ggcggucgcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagapugaguuuupac\n", + "augaaggcuugacuauugaccugaagaauuuuagaaaaccaggagagaagaccuucacccaacgaagccgucuuuuugupaaaucuuccucccgacaucacugaggaagaa\n", + "ccgucgucucguuuccggcggucgcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "ggcaggcaccgagcuccgucgucucguuuccggcggucgcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "gcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "auggaguuucacucuugugcaauggcacaaucucggcucacggcaaccuccgccucccagguucaagugauucuccuggcucagccuccugaguaacupauuacag\n", + "gcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "ucguuuccggcggucgcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "ucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagapuga\n", + "gcaccgagcuccgucgucucguuuccggcggucgcgcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "aggcccaguauuuaggcgacagugaauuuauuacucugaagapuucugcacauauuuccaaauuauauugguggucaucagaaguaggugauaggaagaaauacuucucaag\n", + "gcgcucuuuucucpacpagaggccguguagcgucgccguuacuccgaggagauaccagucgguagagg\n", + "gagccgagaggacccgagupccgaggccaguagccccpcccugagcagaggccguagcuugcgccgcacccgcggccaggcggagccaaag\n", + "aucccucagccucaggcugagccggaccgagccgagaggacccgagupccgaggccaguagccccpcccugagcagaggccguagcuugcgccgcacccgcggccaggcggagccaaag\n", + "accgagccgagaggacccgagupccgaggccaguagccccpcccugagcagaggccguagcuugcgccgcacccgcggccaggcggagccaaag\n", + "aguagccccpcccugagcagaggccguagcuugcgccgcacccgcggccaggcggagccaaag\n", + "ccgagupccgaggccaguagccccpcccugagcagaggccguagcuugcgccgcacccgcggccaggcggagccaaag\n", + "gacauucagugcagucuaccugcagcacagcacacucccuuupcaaggaccugagacccuugugcuaagucaagaggcucaaupcugcagaagaacuagagaaggaccaagcaaagcc\n", + "ggcuppugcucgcgucuccccuguaggccagagcagccccaaguucupcggupcugcugcuuuaucccc\n", + "caugauccgcupcccccagcgcaucuccuggaagagcccacucacccuggacgagcucuucgguagccucagaccguccuugaagaggaugacugagacauu\n", + "acgccggcgcggacugaugaugucagcacugcuuccggucgguggcgcuucucucuggcccgagccag\n", + "ccagcaugauccgcupcccccagcgcaucuccuggaagagcccacucacccuggacgagcucuucgguagccucagaccguccuugaagaggaugacugagacauu\n", + "acucgcgcugcggccgccggcgcucucugucccgcucggagcugcucggcgccccagcugcccgccccgccggccgcuccugcccgcggcgcag\n", + "auuguucucaacauucuagcugcucuugcugcauuugcucuggaauucuuguagagauauuacuuguccuuccaggcuguucuuucuguagcucccuuguuuucuuuuugugauc\n", + "guucucaacauucuagcugcucuugcugcauuugcucuggaauucuuguagagauauuacuuguccuuccaggcuguucuuucuguagcucccuuguuuucuuuuugugauc\n", + "aacuugcaauuuauucugaucaacaauuugcccagcuaaaguacuacaucugcccccucuuccuguggcuguapcacagcaaaggucacuggucuaaccuccuuaaapacuccgcuaacag\n", + "ugauaaccucccugacucacucuucccucuguuggagcucagaacaugacacuccaaaacauggcaccuugguaauuacgaaaacagcagaa\n", + "aauguggacaugcuuacucpauuguggcccaccagaagcauuuacuuccuaccagccccccaauuucucaggccucagapcaucuucagauauccacaccccugcccag\n", + "cggccccagaaaacccgagcgaguapcggcgcgcaggapaggagaacupcgcpagg\n", + "acccgccguuggaaccacagcupugaagucagugcugcuaggucuuuggagccagaccgaapapucgcgcgccccugg\n", + "gccgcaccuacucugcauaugccccgccccucacuccaggugucgcccacuuaacugaagauccaggauccccuccuuaag\n", + "auaagccaggcccaccauuccaacucuuucuccuuuuuggcuuguaggccgcaccuacucugcauaugccccgccccucacuccaggugucgcccacuuaacugaagauccaggauccccuccuuaag\n", + "guuuguuaagaugaaacacugcagaaaggcuaucugaagaaaaguagaaggaaaaacagaacguugcaaacucuggaaaaaaacuugg\n", + "agucuccuugugcgaucucccagacaugagagcccugcupcuuucuggcuccuccuccgugcagaguugucccgucaggagccaggapcgacgcuggcuccgug\n", + "gcccpcucugaugucaccgcgcggcugcgacggcccaggagcgcgucucggcpagccucag\n", + "aaugcagagccagagccccggagccucucccupcggccaugupuuucgacagccuccccgaccagcuggucagcaagucggucacucapcuucagcuucaacauccucugugugg\n", + "ggcggagcgcgucccgcagccggcuggucccugucgcugccccugcgcucgucccagcccacccgcccggugcggagcucgcc\n", + "uucagccgcagccgcccpcggagcgcgucccgcagccggcuggucccugucgcugccccugcgcucgucccagcccacccgcccggugcggagcucgcc\n", + "auucagccgcagccgcccpcggagcgcgucccgcagccggcuggucccugucgcugccccugcgcucgucccagcccacccgcccggugcggagcucgcc\n", + "aggaaguggccauauuggauccauucagccgcagccgcccpcggagcgcgucccgcagccggcuggucccugucgcugccccugcgcucgucccagcccacccgcccggugcggagcucgcc\n", + "cauauagaugagagagacagagcuggccuccuucccgcgcuuuucaaaguucuaucuguupcgaggupucaccuaggcugcagccagacuccagagcuuugcacuac\n", + "acuccuggcaccucugguuacggacaacauacagaagccacugccaaugagcuccgccgaguagcaccpcapcuagcgcuuaaaggagccgcgaccccuuugcagaccagapugacccgg\n", + "gugaucggaggugcuggacuggacguggacuucacgcuggagagcccucapcgugcuguuggucagcgagucccgcaaggcugaupuacacac\n", + "accccugcccggcagcccagcgccuccggccgcacuuccagcucucugcgcagcccgccgcgcagcccgccgccccagcc\n", + "aguaucugupuacccggagcacggagaucucgccggcuuuacguucaccucggugucugcagcacccuccgcuuccucuccuaggcgacgagacccaguggcuag\n", + "gacaguaucugupuacccggagcacggagaucucgccggcuuuacguucaccucggugucugcagcacccuccgcuuccucuccuaggcgacgagacccaguggcuag\n", + "aaguucaccaugucuauucucaagauccaugccapagaucuuugacucucgcpaaucccacuguugagguugaucucuucaccucaaaag\n", + "gucucuucagagcugcugugcccaguggugcuucaacugguaucuaugaggcccuagagcuccpacaaugauaagacucgcuau\n", + "ggacaguaucugupuacccggagcacggagaucucgccggcuuuacguucaccucggugucugcagcacccuccgcuuccucuccuaggcgacgagacccaguggcuag\n", + "acaacaaagccacagaagugacuucaguaaauaauuuugaaaguuaaaaaccugccacuugccaccucaggacauuccagagaagauguuggapagcccag\n", + "uuacguucaccucggugucugcagcacccuccgcuuccucuccuaggcgacgagacccaguggcuag\n", + "guuccagaacacgccuucuacauuuguuacugaaccgaucagcgaacacagacaaacgugccaacacuuaagucuacuggcuggacuucaucuccauggcaacaagcauggaag\n", + "aauguggcagucaccccaaguucagcugacagaguugcuaacggugaupauaccuggagaugaacaagcugaaaauaaggaagaugaucaagcugguguugugaaguuuggaupugaaag\n", + "guuacugaaccgaucagcgaacacagacaaacgugccaacacuuaagucuacuggcuggacuucaucuccauggcaacaagcauggaag\n", + "cccccagguuucccuagaugacaaauaaacauuccuuuuccugcgugaagauagucuguggaaaccuuggcc\n", + "gccaacucpauaucccggagccucupaggcggucacuccgacgucugaggaccupccuuggacccggacucguu\n", + "gagugccugugaagaaaacpuauugcccugaggcuuauauucugccucaguugucuuuucuugaaauauuauaaaucaga\n", + "gcgccpcuucupaaaaggcuugugaacggcguuucugcgucugccguggacagcgaagcugcugcgguuccugagccggag\n", + "ugccugugaagaaaacpuauugcccugaggcuuauauucugccucaguugucuuuucuugaaauauuauaaaucaga\n", + "aacugcggcgucaucccggcuauaagcgcacggccucggcgacccucuccgacccggccgccgccgcc\n", + "gcpucagcugauccggcccaacugcggcgucaucccggcuauaagcgcacggccucggcgacccucuccgacccggccgccgccgcc\n", + "agcugauccggcccaacugcggcgucaucccggcuauaagcgcacggccucggcgacccucuccgacccggccgccgccgcc\n", + "cccaacugcggcgucaucccggcuauaagcgcacggccucggcgacccucuccgacccggccgccgccgcc\n", + "auucpccpccucgcugcggcggcgacugagccaggcupccgcgucccugagucccagagucggcgcggcgcg\n", + "ucuugcaguaucgcccagacuggaguacaguggcgcgauuuccacucacuacaaccuccgccuccupuucaagcaauucuccugccucagccuccugaguagcug\n", + "cpccucgcugcggcggcgacugagccaggcupccgcgucccugagucccagagucggcgcggcgcg\n", + "pcgaaggugupcgacuggugcacuuccacaggcagccgupcagcaugapucagauuccpaaggacag\n", + "cuuucupcuguggugccagcaugguguggaggaagaacccaagacupuuggacagcaggauuccagcccuguucugccgccagucgaugacca\n", + "acucuugcuuccggcuccggcgupuuugaugucgacggaguggcuuuugcuuagcgucuugaap\n", + "auggagucucgcucugucacccaggcuggaguauaguggugugaucuuggcucacugcaaccucugccucccagguucaagcgauucuccugccucagccucucgaguagcuggaauuacag\n", + "agacagaguuuugccauguugcccaggcuggucccaaacuccugagcugaggugacccucccgccuccaccucccagagugcupauuacag\n", + "ugguuaucaaucuguacaaagaaucaccaaacugauaaagcaggaaccagapcaaaucacgcugccaagacaacuguguaauucgcucgaaaaagaaacg\n", + "uuagacuuuuucaugguuaucaaucuguacaaagaaucaccaaacugauaaagcaggaaccagapcaaaucacgcugccaagacaacuguguaauucgcucgaaaaagaaacg\n", + "acagaguuuugccauguugcccaggcuggucccaaacuccugagcugaggugacccucccgccuccaccucccagagugcupauuacag\n", + "gcccggaagcacugucccucggaguccgagacuuccaccupucguguccaaggccccggcgacuccccggacucpugccpccaaccuccccgccgaggcccacccgccgucgcu\n", + "aacaaaaaacaaaagguugugacugagaccugucaaauucauuuggcucuauauacuuugcauucagcaacaaaauuuugacuucucaacagcaaaaau\n", + "gcggcugccpaggugcgcugagcapuccgcagcuaagguccagcgcgauccgagcgcccaggacccugcggccguggaggaggcgugcccupaaggagccgcuacupaccugaaga\n", + "ggagaugugcaaguggcgaagcuugaccgagagcaggcuggagcagccgcccaacuccuggcgcpaucugcugapucacg\n", + "cccggccccgugcgcucauuggucpaugugucggcucagcagccuccaacuucucccgaaucccacug\n", + "augaggaaacagcaacccagagaggagaacuaacccacacaggaucauuucgugaaggagcaaggcugaagaaccagaccuggacuuucuuag\n", + "agcagcupaggagccaaagccucggcgcucaccuaagccgcapagauacacccaacupag\n", + "gcagupaagcucgcagcagcupaggagccaaagccucggcgcucaccuaagccgcapagauacacccaacupag\n", + "cuuuuuacagcuagaccugugugcugcaaggagcuaaggccuucaguguccccuuccuuacccagguuucucacaga\n", + "gaacgcuguggcpcaggcgaggcggucgcuucgagcgcgcuagucagcucccugaapagugacggcgguupugcccgcggccacuuuugccuucccgg\n", + "gucgcuucgagcgcgcuagucagcucccugaapagugacggcgguupugcccgcggccacuuuugccuucccgg\n", + "guuaaauuaaaaauaccuuuuggaaauaaauuacuagaugcuguuuguuugguaccuaacaagagcuuaacauauggaauaauucuuacacauggagcaucaggagau\n", + "cuucgagcgcgcuagucagcucccugaapagugacggcgguupugcccgcggccacuuuugccuucccgg\n", + "agcucaguucugcgguuucugcggcggcuggagagguggucggagaaguaggaaccuccugccpcucguggcggcuucuguccgcuccgcggapaagcgccuuccccacag\n", + "guucugcgguuucugcggcggcuggagagguggucggagaaguaggaaccuccugccpcucguggcggcuucuguccgcuccgcggapaagcgccuuccccacag\n", + "aguucugcgguuucugcggcggcuggagagguggucggagaaguaggaaccuccugccpcucguggcggcuucuguccgcuccgcggapaagcgccuuccccacag\n", + "cagcucaguucugcgguuucugcggcggcuggagagguggucggagaaguaggaaccuccugccpcucguggcggcuucuguccgcuccgcggapaagcgccuuccccacag\n", + "cacccuccuggaggacpacuuuggucugguuauuccccgcugcugugacagcgcccaugacagcagcugguccccacuagcacccaggaaguauuuauccaaugacuca\n", + "ccggaaugaaaacaaacggcggccgcugccgcauccpcacucugcuggucgcggcpaguggcguggcgcag\n", + "gcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "upugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "puuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "gaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "pugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "gacucgcggaccgcccccccccaacaccgcgguggccuuuucgcuupccgcauuccapcuccggacguuuacgauucacuggccucugccccgapacccaggauaagg\n", + "ggccacgucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "ggaagccacgcapccacgucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "ggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "ucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "gagccggaagccacgcapccacgucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "apccacgucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "agccacgcapccacgucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "ugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "uucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "aacaccgcgguggccuuuucgcuupccgcauuccapcuccggacguuuacgauucacuggccucugccccgapacccaggauaagg\n", + "pccacgucugcgguucugaggacupuuupugcagacguuguugcuupcgcuucuccgcugcguguaggugaapcuuccugaccgag\n", + "aucacuuaugugaaaggagaccuuuuugcaugcccgaaaacagacucuuuagcccacuguaucagugaggauugucgc\n", + "caaacaaccgacuccuuuccaggugaapugacuupuacguupcuuugagcgagccuccccgcacccucccauaggaccccaggacagacugcguccucgcugacccgcccuagg\n", + "gcuuuccugauugcaguuuugguugagaagguuguucuucccugcugagauggcuggcugacuucaccagucaag\n", + "gucaggacgcaguggcucaugccuguaaucccaacguuuupagaacaagaapaggauggcuugagcccaggaguuccag\n", + "puacguupcuuugagcgagccuccccgcacccucccauaggaccccaggacagacugcguccucgcugacccgcccuagg\n", + "cuacugucuucuguguuapaucacuuccuuguugagupaccugaguuuugagapucuucugcuccucuucgucuggucccuuacuuccaagaccccagagaggaaggc\n", + "acccaaagucuucaagccuggaguaccugccugguucuuccugaggucugagcaccuucuagacuacauccagaucug\n", + "uuuugugaccaccuucuucgupcuucagcaaugacagccagacaupugauguacaccaacggcu\n", + "agaugcuccuccaggccuggauggcucagucaccucucugccccuucugugcccagaacagaauaguggaggaguggau\n", + "ggagguuuucucuupuuuguuuggauuuuuuuuuucagcuuuugucugaauuuugguuuuauuuuucupcagagaaa\n", + "ggaaacgcggagcgcgcgcucccagcgaaagcagcapcapaucugcguuggaggaapacugcucuggugcuaga\n", + "gccgccgccagccgcugcpcaaggcugaacaggcggaggupcagccggccapaagcacgguccaggcggcuacauucggcccggcc\n", + "auucggcccggccauggcagcggcgccccugaaagugugcaucgupcucpaacuggugagcggcggcpcuggaggccpcuccgcuuccaggaagcgccucucccpcg\n", + "puucagcuguugcaaaaauaauugguaauaaugucaagaaacuucagaaauuugccuccacagucaag\n", + "gcugcpcaaggcugaacaggcggaggupcagccggccapaagcacgguccaggcggcuacauucggcccggcc\n", + "pcpccgccgccagccgcugcpcaaggcugaacaggcggaggupcagccggccapaagcacgguccaggcggcuacauucggcccggcc\n", + "aguuuugccgaauugacaagccccugugucacagugaggaugagaaacucagcuucgaggcaguccguaacauccacaaacug\n", + "gaccgucggcugcacucccpcuccuggcuuugccucupaucccgagguguccacaucagacgcauguugacugagaccuagaguc\n", + "uuucuguuuuugaaagaugaagccupaggugccagagcuaugccagcugcuaupccagaaacag\n", + "ucccaucaauauauugugaggacacucaagaagcauauggaaaaggccauguggagaacuaguguuuccugacaacaaucagcauggacuugcupaau\n", + "agacacagcaggcuaccuuugcauuuccuauauuggacaaaauaagaggaagaaaggaagccaaacagcucucccaggcucaguuggcagcagagaggaguugag\n", + "agcaaugacuacccugagcagguggcugcaguaggaguggagaacugugcuugaagaggacaugaaaccuguaggcaag\n", + "pagaaugagaugcapaggaagcauuuacaggccccaccgaaaaaccuuaaapcugagagcuugapcag\n", + "uuccugapaagaccucaauuaccaugacccaacagugaaacacagcaccuuccauggugaggauaagcucaucagcguggaggaccuguggaaggcauggaagucaucagaag\n", + "uauacaauuggaccguggaugaggugguacaguggcugaucacauauguggagcugccucaguaugaggagaccuuccggaagcugcagcucaguggccaugcc\n", + "ggagaccgucggcugcacucccpcuccuggcuuugccucupaucccgagguguccacaucagacgcauguugacugagaccuagaguc\n", + "aaaugcugagucapuguccgagguggcgaucgccaucuuggagucuucaccggaguccaaucacugugaaccaaaaacgaagucaaauaacaaguuucacacuuupaggccaag\n", + "ggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaauaugucccuccggaggcacauupaacccugag\n", + "aucauccaaguugcuucccucucugaucaaacacuggaagugacagcugaggagauucaaaggcuggaag\n", + "gaggcggcugaacaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "acaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "paggcggcugaacaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "ggcugaacaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "puauapaggcggcugaacaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "agaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaauaugucccuccggaggcacauupaacccugag\n", + "aaucggagaagapuauapaggcggcugaacaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "aggcggcugaacaagguugupuaggaagcuapuuagaggcaacccgugaggcuagaaccccgaacguggucgguuggagaaaau\n", + "aaaaaagaaaaaaaaaaaaaapagaucccaucuuuacaaaaaaagagagaaagcagcuugaccaagaccucacagcuu\n", + "cupaccuggaagaccccugcccaccuuccccaccucggaaugcaccucggauguggagccggacacccpag\n", + "gcaacupaagcupagguaggcgcpcggucggcugcgguggcggcguuuggaugauugucucucggcggcggagucg\n", + "cucaauguacuucuccaguuccuacccuuccucaagupaacucaggagaccaagcapcaacuguacuucgg\n", + "aaagupaugaucugucacuacaccugcagcaccacgcucggaggacagcuccugccugcagcuuccagacccag\n", + "ccugapaaggaaggaaguacpcgaaaucaucagauuggcuucccagauuupaaucugaagcpcccacaucuuccggccaacuuccauugaacuucccagcacucgaaapaccgaa\n", + "agagagcaaagupaugaucugucacuacaccugcagcaccacgcucggaggacagcuccugccugcagcuuccagacccag\n", + "gcuggagugcauuggugcaaccucagcucacugcaaccucugccucccagguucaagagauucuccugccucagccucccaagcagcupacuacag\n", + "ccugcucuacccpaguggacguguupuuccccucugagcgcccguguguccgcacucacgucuguggagccag\n", + "gcaagaccaggacucpcuggapcgcupcucggaccugccaaggccacpagcaapacagaggcpuccuagcugacggcuuuuacugccuagg\n", + "caagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "gcucuupucuugcucugucacuupcuggagugcaguggugcaaucacpccacugcagccuuuauguccaggcucaaguggucuucccaucucagccuccugapccupaccacag\n", + "cccgccccgucgcacucagagagcupcuggagcuccaagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "ucupcaucgaaggaggaacgcugcaaccuccaaccccuucuuucugaccaaccpaccagagcagugcupccpcpucaccgg\n", + "aaaaaagcagcaagccucggcagcagucaauccuccagaaccuaugcugguggaacagccucggccaccaag\n", + "agagagcupcuggagcuccaagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "gugucagcuuccucuggugcaaccagcaagucuuccaguaugaaucccacagaaaccaagguaugaagaaugcuaauuga\n", + "gcacucagagagcupcuggagcuccaagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "cucagagagcupcuggagcuccaagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "gucacuuccuguucugagucaucapaapagucucccugacuuccagcaacaauccuugagucupacugcccuggccuaag\n", + "agugccagcccggucccggccaagcggagugugagcccggcgccuccaacgcaacaccccgcgcccucgccggcucccccgccgugcggaucggagccagccgguuguugcc\n", + "acauugguaagguguuuucccccauugaaacuaauauuuucuauuuucaagaaaaaagcagcaagccucggcagcagucaauccuccagaaccuaugcugguggaacagccucggccaccaag\n", + "agcccggucccggccaagcggagugugagcccggcgccuccaacgcaacaccccgcgcccucgccggcucccccgccgugcggaucggagccagccgguuguugcc\n", + "acucagagagcupcuggagcuccaagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "cupcaucgaaggaggaacgcugcaaccuccaaccccuucuuucugaccaaccpaccagagcagugcupccpcpucaccgg\n", + "gacuccccgccaggccuccccgccacucuccgcggcgcauuccpaggcagcggccgcagcggccucgcc\n", + "cacucagagagcupcuggagcuccaagcggaaaccgcpagccgagcccagcuaggaaugcagaccuccugaaaaccaagccgaggacugcpuccgguguccacgcaga\n", + "ucccucccucucucccuggcaggacuccccgccaggccuccccgccacucuccgcggcgcauuccpaggcagcggccgcagcggccucgcc\n", + "ggauuugaaacuuggcgguuaaagcuccggcupacapcggcpagaccccpugaacpaapacauuuaguuugagacggugcugagauaggauc\n", + "guugcaugauggaauuugaacauuacuucaagagguuuuguauuuuggauuaguuaauupuuuguccucugcugacuguuucuucggaugcauuuuuuggugugcucuugapauuaa\n", + "agguugcaugauggaauuugaacauuacuucaagagguuuuguauuuuggauuaguuaauupuuuguccucugcugacuguuucuucggaugcauuuuuuggugugcucuugapauuaa\n", + "ggcgccgcupagcugguggcgcggcgcaggucccggccgaguguggcgcagcaguggcggcgcuucccauucgccaugcgccpupugcccgaag\n", + "gcacuugguccgagacagaaaacguuugaguuguuccacacacacccccucuaaaugucgagaagccccag\n", + "uuaaaaaaacaguuuccugcuauggcccugaagauuccugccaagagaauauuuggugauaauuuugauccag\n", + "gcupagcugguggcgcggcgcaggucccggccgaguguggcgcagcaguggcggcgcuucccauucgccaugcgccpupugcccgaag\n", + "pagcugguggcgcggcgcaggucccggccgaguguggcgcagcaguggcggcgcuucccauucgccaugcgccpupugcccgaag\n", + "agcuggcgccgcupagcugguggcgcggcgcaggucccggccgaguguggcgcagcaguggcggcgcuucccauucgccaugcgccpupugcccgaag\n", + "guuuauaaaguucugguuucagupaagaagugaaugguuugucuucaggagauaugcagaguuugauaaacuuuauaacacu\n", + "agacagaguuucacucuuguugcacagacuggagugcaauggcgcgaucucaacucaccgcaaccucugccucccugguucaagcaauucuccugccucagccuccugaguagcupauuacag\n", + "gcucaggccccgcccucagacgagcaccgcccgccggcuccucccgcggcucgaaucgccgucucucuccuccccgccccgccgaguucuagaauucgccgcgcagcugcuucag\n", + "ccccucagccccagccggacccucpuccucauccacccucgcaggcgcaggccguggcuaccccgaagucaacuguggaggauccuuccuggcuuccuucagcuccauccugcccuuggaucuag\n", + "pcpaagcggaguauguggcuuuccccaggucucuggagguugcaggcucaggcucugcucagcp\n", + "aacugcgccggaggapuuucggccgacacgucpauuggcggcugcagccapuccuccgacgcupcuuccgugagcggcgcucugccag\n", + "cgacacgucpauuggcggcugcagccapuccuccgacgcupcuuccgugagcggcgcucugccag\n", + "gugcgaggaaguggcuggaguggaggaaggagguugagcugcucucagauguggccuacuuuggccucaccacacuugcag\n", + "acgcugcugagcccgaggacagacggagacgccpagccaguggcgccuguggcuccpcapccgcggccgaaag\n", + "gccugcugccggcgcucggcccagcacgccggcucucpcugccgupcugcgcpcccgcgguguguagaguccgccgccccggagccgcgucccgcacccggacggucccg\n", + "ccgugccccgccguccuccuucccgcggccgugapagaccgcggcucggccguagcggagcugcgag\n", + "aagugcucgcugcagcuucccggagccggagcgcagcgccugcggccgcccgugccccgccguccuccuucccgcggccgugapagaccgcggcucggccguagcggagcugcgag\n", + "gugcucgcugcagcuucccggagccggagcgcagcgccugcggccgcccgugccccgccguccuccuucccgcggccgugapagaccgcggcucggccguagcggagcugcgag\n", + "gccuuaagugccgcgccagcccpcggcccagucggccugucagccggcuucgagauaagucccggcgcuugcgcggcggcggcu\n", + "gucaggauggcuaacugguuggcuccccacauggugcccuacgucuauaucacaccuuaaagaagcugaagagaag\n", + "ggcggccugcgccgccuuaagugccgcgccagcccpcggcccagucggccugucagccggcuucgagauaagucccggcgcuugcgcggcggcggcu\n", + "ugcgccgccuuaagugccgcgccagcccpcggcccagucggccugucagccggcuucgagauaagucccggcgcuugcgcggcggcggcu\n", + "gcaauggugcgaucucggcucaccgcaaccuccgccucccgaguucaagcgauucuccuaccucaggcucccgaguagcuggaauuacag\n", + "agacgcaugcgcuggcggccugcgccgccuuaagugccgcgccagcccpcggcccagucggccugucagccggcuucgagauaagucccggcgcuugcgcggcggcggcu\n", + "aagaaggaugaaupcaggaugaguuagacuccuucgcuguaucgucuacugauucuuaaaaugugacaaaucugauuggacgacuuacaugguacggugcaauuuuugauguccagacuaaa\n", + "augguaagacgagcgcgcuggccpaggccgcggcgaggcgagaaaagccccccgcacggccccpagugaggccgccauuuuaaccugauuuuggccuccaag\n", + "acagccgapcacuaugguaagacgagcgcgcuggccpaggccgcggcgaggcgagaaaagccccccgcacggccccpagugaggccgccauuuuaaccugauuuuggccuccaag\n", + "gcuuugcaaguucuucaccgcaaagaacugccgcagacuuccgccupugccaaccacgugaucacgcgagcguuggagaggc\n", + "ccuaaauuauacagaucugugauugaagaugucauuaaugaugugagagacaucuuucuggaugauggaguggaugaacaaguacug\n", + "cagaaguuucccccuupcggugguggaggugguaaccgugauaguagcagcuccggcggcagcaacagcgacuacgap\n", + "cuccagaaguuucccccuupcggugguggaggugguaaccgugauaguagcagcuccggcggcagcaacagcgacuacgap\n", + "ccuucaugugcuucagcccuacguuguuuauguccagaaucagauauuggagcugacucugccuguccapccugcag\n", + "cagcccugaccaacgcuccaauaggccpauccagccauacuucaauggaucccapuaucuugaaggcauuucccaagcggcagaaaauuc\n", + "cagcccugaccaacgcuccaauaggccpauccagccauacuucaauggaucccapuaucuugaaggcauuucccaagcggcagaaaauucaugcug\n", + "agcpcugapuaggaaguagccgcuccgaguggaggcgacupcugaagagcgcgccgcccucucgucccacuuuccag\n", + "gcccagucgcgccgccagcpcugapuaggaaguagccgcuccgaguggaggcgacupcugaagagcgcgccgcccucucgucccacuuuccag\n", + "pucccaaaapuucgaggccucuugccuucgcuccguaggapaguucucuucuggcccupccgcag\n", + "gacuguccaggaauacaguuuccaggugagaucuuacuugaaacaccgguaguucuagcacagcuaaa\n", + "uccpucccaaaapuucgaggccucuugccuucgcuccguaggapaguucucuucuggcccupccgcag\n", + "acuuuugaupuuccpucccaaaapuucgaggccucuugccuucgcuccguaggapaguucucuucuggcccupccgcag\n", + "guacagguggucucuupuuccgguaaggcggcggcugcggaacucccguggapccggupcccucpccugacg\n", + "aggucgcgcgccccuuccggcgcpapcgcugaagaucpccgcucggccgcaggccgccuccagcgccgcpauguagcgcpaccgcggcccccagcagagcccgccugcccggcu\n", + "ugucuaccaucagapagaucucugcccccupcugagagaccccaaccuuuccccaagcugaagcugcapuauugagguaccagccag\n", + "apcgcugaagaucpccgcucggccgcaggccgccuccagcgccgcpauguagcgcpaccgcggcccccagcagagcccgccugcccggcu\n", + "uuuagaagaccaaacuggacaauggacuuugcucacuaugaugacaugaucuccauugaccuccauu\n", + "aucacgcacuucaggcugcgauaacgagguggaguguagaauccgacgaacguccucuaccccpcpuggagguuaccuggcugcggcpag\n", + "gcucggccgcaggccgccuccagcgccgcpauguagcgcpaccgcggcccccagcagagcccgccugcccggcu\n", + "caucgcccugagcaacuggugguuuguggcccaccugacagaccugcuggaccacugcaagcuccuccagucacacaaccucua\n", + "gucucgcagccagcucugagcpaggccugagcpaagcauuggcguccgagcgacuucuaggagccupuucggcgcu\n", + "cugagcpaagcauuggcguccgagcgacuucuaggagccupuucggcgcuauggaggagcucgauggcgagccaacagucacu\n", + "cggccgccccucuggcugcucugccuggucgcgugcuggcuccupcgccpccgaagccgacuucuccauccuggacgaggcgcaagugcuggcgagccag\n", + "gugccpccagcccgcugccacupcggccacucpcggcgguggagcpagcgcgcagcag\n", + "cagaggccuaggcccacpapuguuggcagacagaugcccuccaggcccupccuccuuaacggccccuuaacgacacgcgugccaapuggagg\n", + "ggcpcuuuapaguggucccuggcuguggauagaucugcugaugaguccaggccccgguccauucuccucgcgcugcaagg\n", + "ccugcggcpcuuuapaguggucccuggcuguggauagaucugcugaugaguccaggccccgguccauucuccucgcgcugcaagg\n", + "pcuuuapaguggucccuggcuguggauagaucugcugaugaguccaggccccgguccauucuccucgcgcugcaagg\n", + "auugcgaagagaaagcgugapcupccugcggcpcuuuapaguggucccuggcuguggauagaucugcugaugaguccaggccccgguccauucuccucgcgcugcaagg\n", + "gugaguupaaucagacucuugaguugacagcuggccuaugguuucugcauuuuguuaagaagcaccucaugcaagcgapaccupacugcucacagccag\n", + "acacgugaaggaagccuuugupccuuccugcgcagcugacuagcugaaagccaucgugagccagcccaggagaaaccagcagaggaacagccagccgaacccupauugugagaaauaaucag\n", + "pauuauuuccaaaccagcagucacaggaacaugcugcuuuuagauuugcuuugucgcaacucacagagcccccgaagcugcucccccagauugauauugugaacaucagcgacagcuuugag\n", + "uaaapaaappaaacaccaaaucuaugauuggaccupcuucuuuuucgccaaugcaaaaaggaau\n", + "agccuuucgaccapucccaaaggaaagcagugaguggugcuguuucccugaaggaapacuaapacgguggcgcpcccggaccpccccpcggcggcacggccgau\n", + "agugacaagguaauuaagacgaaggaaacaauucuaggaggcacaacgupuggacagucagcugucgguggcuucugcugag\n", + "aagucucgcgauagccagccgcggcugcccuugcgcuucccgagcuggcpuccguggugcpaucgagauugcpcu\n", + "cucgcgauagccagccgcggcugcccuugcgcuucccgagcuggcpuccguggugcpaucgagauugcpcu\n", + "gcuggagugcaguggcacaaccuuggcucgcuccagugucuaccucccagguucaagugauucuccugccucagccucccgaguagcupauuacag\n", + "gacuagcuaggcggcupagcguuuucguggcpaacggagguugaauugcccugccupcucauapaaggaggaugugaaggagcuugugaaggcagaggaag\n", + "gcapaaugagcuccugaucuupaguacuuaaaagaauuuuuucuuggaagaauuacugcaggaaacauucauagaaccuup\n", + "augcugagcugcuggcgcacugcagcacaacuagagauguacggaugcccccaucuugaucuuacagaaucagagguacagccgcgagaaag\n", + "augcugagcugcuggcgcacugcagcacaacuagagauguacggaugcccccaucuugaucuuacagaaucagagguacagccgcgagaaaggucu\n", + "pucacuggcaucgagucuggaacagucauucucagcaagagcucuuugaacucugacauucucuaguuuuacggacucgg\n", + "acuuccggugcgaaccgccucggccguucccucgcggagcuuacugagcgcggccgccgagcccagcuccgccgccgagcgccugugccggcacggcuacacc\n", + "gaacauggcuggcggacucaggcupucugcagugcagcauuaaupccgcugacaugaauauggaguaguuuucucuagcaaag\n", + "guaaccaagauacugacugaacauggcuggcggacucaggcupucugcagugcagcauuaaupccgcugacaugaauauggaguaguuuucucuagcaaag\n", + "ggcccuguaaccaagauacugacugaacauggcuggcggacucaggcupucugcagugcagcauuaaupccgcugacaugaauauggaguaguuuucucuagcaaag\n", + "acugacugaacauggcuggcggacucaggcupucugcagugcagcauuaaupccgcugacaugaauauggaguaguuuucucuagcaaag\n", + "auugaggccuagagagaggcaggcguuccucagagucacapaauggcggcgccuggacupacucagcccagcugcuuggccugacccucucacagcauaauuucccggcaccug\n", + "acugcaaccuccgccuccupuucaagcgauucuccugccucagccucccgaguaacupacuacaggcaccugccaccaugcucggcuaguuuuug\n", + "uagagacpuuucaccguguuagccaggauggucucgauuuccugaccucgugauccgcgcgccucugccuccaaagugcupauuacaggcccgagccgccgcacccggccugcag\n", + "cggccugcagguguuguucugaccccagcuccacugugccagcccgacuugagaugccaaguaucuupccugagg\n", + "guuugcuuuaagaaauagugcucccuucagaauggaagaauuuaucugccucuuauuugauguggaucagagcuaagauggcugacuaaauaaac\n", + "ccaguuguccaagccugugaguggcuaugcguccugguupugcucaaagcaaggaggugaaaggcgaccagcauuggcgaaup\n", + "gucccuccccucuccgcaggccccgccgccgccgccaucuuuguupcagccaggccuggcucgag\n", + "auuuugcuuccuuucgcaguaaacguucuuccgagaaauuccaapaucucagccaagcagapaapauccugcccacgccugg\n", + "ggagaccgaapcacagcuccccgcgccgcgcacgccgcccgagcccggagugcggacacccccpau\n", + "ggagaccgaapcacagcuccccgcgccgcgcacgccgcccgagcccggagugcggacacccccp\n", + "aguggcaggucccacccgcucccgccccugccgcucauuccuguccggacgcaccugcagcuccccpagaagaggacgccccccauccgcucccccacacag\n", + "gucugcggcugcguuccccgaaagacgaggcugcgcccggauuccgguccgcapagaccgaapcacagcuccccgcgccgcgcacgccgcccgagcccggagugcggacacccccp\n", + "auuucuauagacaccuagcugugcuuucuuacaagaaaacauauccacuggaccaaagcgcagcccccuucaugcugaagccacuucaguuugaaacguaaaaa\n", + "caagaagaucapacaacugauuugaagucuacucugugcuucuaaauccccaauucugcugaaagugagauacccuagagcccuagagccccagcagcacccagccaaacccaccuccacc\n", + "ugcaaggcgaaagucgcugaapcpcgaggcgagaggaggcpcguguguuguggaggaaagugugcc\n", + "augupaagauaaaugaapucuagauguaaaugucaguggaaaggagagcuaccaucacuaag\n", + "agcaguupcaggaggaagccgacugcugccuggucugcaaagaaguccuuucaagucucuaggacuggacucuuccuaagcaaguccg\n", + "aguuugcgaucugcccacgcguucpcacuapccaccgcucuugupcagaaggccgcguccauuccaggaagaggaucuucuccggaaau\n", + "uuugagccgcgucgaggucpcuupaapucagcpaggccugapcgccpcgcugcggcaggcpcccpuccagccgagagg\n", + "augucacacuggauccuuggccuccapuccauuaaggugagaauaagaucucupcuggcuggaacuagccuaagacugaaaagcagcc\n", + "cuupuuaaaaaguauucugaaagcauccucacuguccucccuggucccgcacagugccagagccpucuuggacugagucagaguugcaupugcaucuggapaccuugauuggagagag\n", + "uuaguuaaaauuuguugucaauaaguuuaacauucuguucuuccgcgugauggauuuucuuuuggagauucgaacugaagccuguacggaggaaaug\n", + "gugacaaaauugaauugcuuaucuugaaggccaagagaaaucuagagcaguguacugaagaauuaccaaagucc\n", + "ggaaucucugaaagacugaccgacugacucugacaggauccpcugapaaggaggcggcggcc\n", + "ggaaguagccggaaucucugaaagacugaccgacugacucugacaggauccpcugapaaggaggcggcggcc\n", + "uagccggaaucucugaaagacugaccgacugacucugacaggauccpcugapaaggaggcggcggcc\n", + "guggccuggaggacucauuuaagaaucauguguugaguaccuacuuuguacupcacacuggagagcaaaggugguaccaucuaugcccugguggcugcpuggacacaaacaugugaccag\n", + "auggugucacaagaaggaucugaaguggagcuucuaguauccccaggagcgcgaagugaacacggaagguaccugcaggauccaauuguguccauugaucucucagaguggcugaggauaauag\n", + "gguuccuguacaucacuuuaccuuuuuugucuauaaauucauuuugaccacgaggcacccccggagccucggugaaucugcugugauuuu\n", + "gucuupcgucuuugguacuggcuuuuuuapucugccupauuacccuugcuguggauagaagcaacuuuaagaccugugaagagaguucuuucugcaa\n", + "gcgacagagaagcauacggccaggccucucuccauaccgagccuugcuggacucucuacagcuugguccugauucccucacgguccaucugauccaugaggucaccaag\n", + "uuuccpucgguucuggcaggucugagcgcuccgacuuccagaggagcgcugugcacguggagaagagcpacucggcgacccugcccucccgacccuc\n", + "gagcgcuccgacuuccagaggagcgcugugcacguggagaagagcpacucggcgacccugcccucccgacccuc\n", + "gucgguucuggcaggucugagcgcuccgacuuccagaggagcgcugugcacguggagaagagcpacucggcgacccugcccucccgacccuc\n", + "gucacgcuuugguuuccpucgguucuggcaggucugagcgcuccgacuuccagaggagcgcugugcacguggagaagagcpacucggcgacccugcccucccgacccuc\n", + "cacugcaggaguuugugaccaagaacuucaagagucaagacagaaggaagccaapagcagugca\n", + "auuuguggagaccagcccucuggcuuggugagugaaucugguuuacaccggcuccugcccugccuucacucuucuccccugauucaagacuccucugcuuuggacugaag\n", + "cuccugupaaacucauuuguggagaccagcccucuggcuuggugagugaaucugguuuacaccggcuccugcccugccuucacucuucuccccugauucaagacuccucugcuuuggacugaag\n", + "accaaaaccuugugugacugagcugaagagcagugcauccagauucuccucagaagugagacuuuccaaaggaccaaugacucuguuuccugcgcccuuucauuuuuuccuacucuguagcu\n", + "ggcgcpccapaapccacccapucccccacuucccgcuupcgcccggacggcgaauggagcapcgcgcag\n", + "gcgcggcgcpccapaapccacccapucccccacuucccgcuupcgcccggacggcgaauggagcapcgcgcag\n", + "aaagccccgcgcggcgcpccapaapccacccapucccccacuucccgcuupcgcccggacggcgaauggagcapcgcgcag\n", + "ggaagccucuucucccacugcaucugugaucucuccugaaauguagcacccacacaucccugagaagcuagcugcggcacgugugugugcacaupcaugc\n", + "gaaaggaupccccuguggacgccacagcgcgccuuccccauccgcaaaggcuuucccucccucuccuccagcuccagccugaacc\n", + "upcugccgagaagcapagagapaaaggucugcaggccucupcgcpaccuuuaucaaapagcggcgapaapapaccauacgcaggcggagaagag\n", + "gaauccgcuguguggcuuacaauaaccagucaaacagauuggcuguuucacgaacagauggcacuguggaaauuuauaacuugucagcaaacuacuuucaggagaaa\n", + "agagccugagagcgcgcgcgcacgupccpcggagagaggcgagcaccpaapagcgupccgcug\n", + "uuuuucccaggucaugagucucpcuacagaagcuuugugcupcagaaggacagcgacucuuuagugcupcucaauggcgagauu\n", + "uauauccaaggugcagcagcugagcauuccaaauucpaaccaccagaaaggcuggccucucuucaac\n", + "ugcccaguccaaacuccaaggcupcaaggcacugauccacugcuggacagacccpcagccucupugaacagcagcguguccgccggcagcgaaccgagaccagcgagccgacc\n", + "ccaccucuagguccgcugcgauuugcacccccugagcccccugaaucuuggaguggugugapauggaaccacccauccggcc\n", + "guccguccuuccugguccugcpuccaggacuguccgcpuugapaapccgugcccggugccagcccaggugcucgcggccuggcucc\n", + "aauuccugagagapapacagcccuccccgcccucacccugcccupcugcucucuccgcaggaccaggcgguccagcgaaggagucgacuccagcgaag\n", + "auccuccuggcaagcuucaauauagcuguggaagucugcagucuacaagagccuacuauagacauucuacaaccaagcagaauc\n", + "ggaggccgccpuucccugacgugccagucaggccuucuccuuuuccgcagaccguguguuucuuuaccgcucucccccgagaccuuuuaapuuguuuggagu\n", + "uuuagaugcaaaauccacaaguauucaagugauuguuaaagapaggccugaaguugauucagauccaagacaauggcaccpaucagg\n", + "aaagaagaucuggauauuguaugugaaagguucacuacuaguaaacugcaguccuuugaggauuuagccaguauuucuaccuauggcuuucgaggugag\n", + "gcuuuggccagcauaagccauguggcucauguuacuauuacaacgaaaacagcugauggaaagugugcauacag\n", + "agcaaguuacucagauggaaaacugaaagccccuccuaaaccaugugcuggcaaucaapacccagaucacg\n", + "guggaggaccuuuuuuacaacauagccacgaggagaaaagcuuuaaaaaauccaagugaagaauaupaaaauuuuggaaguuguuggcag\n", + "caaggagagacaguagcugauguuaggacacuacccaaugccucaaccguggacaauauucgcuccaucuuuggaaaugcuguuagucg\n", + "gacgugccagucaggccuucuccuuuuccgcagaccguguguuucuuuaccgcucucccccgagaccuuuuaapuuguuuggagu\n", + "acagcgcaugcccacaacggcggaggccgccpuucccugacgugccagucaggccuucuccuuuuccgcagaccguguguuucuuuaccgcucucccccgagaccuuuuaapuuguuuggagu\n", + "acggagucucacuuugucacccaggcuggagugcaguggcgcgaucucagcugacugcaaccuccuccucacagguucaapagauucuccugccucagccucccgaguagcuaggacuauag\n", + "cacaacggcggaggccgccpuucccugacgugccagucaggccuucuccuuuuccgcagaccguguguuucuuuaccgcucucccccgagaccuuuuaapuuguuuggagu\n", + "cuuuuccgcagaccguguguuucuuuaccgcucucccccgagaccuuuuaapuuguuuggagu\n", + "acggagucucacuuugucacccaggcuggagugcaguggcgcgaucucagcugacugcaaccuccuccucacag\n", + "aaagaagaucuggauauuguaugugaaagguucacuacuaguaaacugcaguccuuugaggauuuagccaguauuucuaccu\n", + "uucccugacgugccagucaggccuucuccuuuuccgcagaccguguguuucuuuaccgcucucccccgagaccuuuuaapuuguuuggagu\n", + "augcaaaauccacaaguauucaagugauuguuaaagapaggccugaaguugauucagauccaagacaauggcaccpaucagg\n", + "ccaggacuuccgucugagaupauuucuggacagaacaauggagcgcagaagcuccagcaacgugugcucugcapagcccag\n", + "aauugcugaccgccacagccacagccapcuagccucgccgguucccpuggcgcgcguucgcugccuccucagcuccagg\n", + "gcuggagugcaguggcacaaucacggcucauugcaaccucugccuccupuucaagcaauucuccugccucacccucccaaauagcupacuacag\n", + "gguuccccgcpagcugccacccuaccuucccauccccgccgucuccguccucucccaguccucpacaccccgucugcpaucguppcccpagcacgg\n", + "acuuccgcpcacccaacugugcgucuccugcgcgcugacgucaggugcgugccccuguccggcagccgaggagaccccgcgcagugcugccaacgccccgguggagaagcugag\n", + "acggagucucacuguguugcccaggcuggagugcaguggcgccaucuuggcucacugcagugcgccucugccccccgaguucaagcgauucuccugccucaggcuccugaguagcupacuacag\n", + "gucuccugcgcgcugacgucaggugcgugccccuguccggcagccgaggagaccccgcgcagugcugccaacgccccgguggagaagcugag\n", + "aggugcgugccccuguccggcagccgaggagaccccgcgcagugcugccaacgccccgguggagaagcugag\n", + "gcgugccccuguccggcagccgaggagaccccgcgcagugcugccaacgccccgguggagaagcugag\n", + "cupcggcgguggugcggcggucgccguuauggccacupcupcggcugaccgccpcuaggaaapcccapccccgaaucucgguggccgcugcuccagcgcggccugcgcc\n", + "aaaaucgauccgcggagugagacggcucguaccacacugcapcccggaggucaagaugguggcuguaaaacuaggaucccugacgauug\n", + "auugccaaaaugcuuuggaguuuuuaacugaaucuaagaaaaguccaaaauagauuugagacuguaaaaacagaaacugcagcaapauucagugcca\n", + "agugcagccuagagacgcugacaaaggagcggaggagcagucgcagcugcuuuccgaggaagccgguguugccgag\n", + "uaagcaguggugauagcugagaauaugcagccguuuucuccuuccupuacagugcuauucugccuagag\n", + "guucucaccaccaccucccuuucauaggucacagcugcucuucuggagguguccuacaggugaaaagcccagcgaccca\n", + "paggugaggaaguggagagagcagcugugguggcugaapugcuaggacagapagcaugauaaagccauaa\n", + "ggcugccuuaguaaaguacagaggugaaguggagcaagauggcagaauagcaagcuccuuugauggccauccgcacaaaugucuacacagaaaaagcaccuucacaagaaccaaaaaucag\n", + "ccuguuuugugcaacuuccaagucaagauuaugaacauuuucagacuuuuugcaagacagaauucaauggauuaacaaucagccuu\n", + "ugccaauuuggauaaacauggcacaaauccagcapagguccagaugaaaaagaaaagacuaccgcacugaaag\n", + "acugucuucugaagauugaugucuauuuccuugagcucuuuaauuuuguugccaauuuggauaaacauggcacaaauccagcapagguccagaugaaaaagaaaagacuaccgcacugaaag\n", + "gguguuggccuuuggauaggaggcuuccaaguaguaaagcucccugcucucagcaagcccaacacc\n", + "cugcuucucuuucuuucccccuccaaguuccuaguggapcugaguccagcaucccagacucgugugacuauauag\n", + "uuupcuggaaccggaggugucgcucuucggaccucaagguuccccuuaacacagagcgccccgcagucuucgcggaaagcguucpuaggcg\n", + "agccccgccccuuupcuggaaccggaggugucgcucuucggaccucaagguuccccuuaacacagagcgccccgcagucuucgcggaaagcguucpuaggcg\n", + "auucagcuaaacaaagcupagcpaaugagaccupacuugucggcucagugccccugag\n", + "cugagauugugguuuccuggugauucaggupagupccagaagaucaccgcuggcaaggacugg\n", + "aggcgagccpcgcccaggacagucccgcagcpcpugagcpccgcgcccucgccccucccpccugcccccgucgcgacuggcagcacgaag\n", + "aaaacgccaggucuucaapugucugccaccaccaugccugacccauuuggcagcagccucgugugugguggucugguguggacgguggaagcgugauucugcugagugucag\n", + "ugugaccacucgugcucagccguaucucagcaggaggacaggugccggagcagcucgugcagcuaagcagccaacugcagaaacgucag\n", + "guacgcpagccccggcgacccpcuucugugaaacauggcgguaggcupaccauaacacaag\n", + "aguuucaggccagguguggugguucacaucuauaaucccagcacuuuuuuugagaggccgaggupuggaaggcuucagcccaggaguuugagacccagccupcaacaag\n", + "auuuccpuacgcpagccccggcgacccpcuucugugaaacauggcgguaggcupaccauaacacaag\n", + "agcgguuguucugugugaagucgcgcggcuuccacccacgcaguguucuaagugaaggccagaaacucgcucgcc\n", + "gagaucaaapcgucgcccaaagcpacagguccagcgguuguucugugugaagucgcgcggcuuccacccacgcaguguucuaagugaaggccagaaacucgcucgcc\n", + "cucaaaugaagaaauauugcaccagaagaagaaagccaagaaaugaagucacaacgucagucauuuaauccaccaccugugguccuaacuaguucuuauguccugug\n", + "gaacacacagucuaacaapauaaaacuaauugacuccaucacauggaaaccaugauuuuugccaagagaagcagaaacaagaugcuuucacccuupagagauucucaucuaagaacuggcaag\n", + "acuccggcgcacgaagccpugacugcugucccpagupacgucgcgugcaccguuggcga\n", + "agguuuauccacugugcupacucccaagccagcacuggcucauacugauucauuuugaucucugcuaauaccagaguccugcguggcagagccauuggcaccagaaauuacaa\n", + "ucuapccacagaauggagacuagaggcagcagcucagucugaagugcaagacuuuauccaguaaaagguccaauuccagcagcucugccagaagcuacagccuugacaacu\n", + "ggcagucguccgcgcuggcupcapagcggcagcagcgagccpaccccggcgccgcccgcgcgcg\n", + "gccccgucugaggucuggcagucagagacagccpcgcccacggcccgagcgcccacggcagcacc\n", + "cccuuugacaagucgcugcugcugcagcaaaaauaaaggacgcgaccgccgcagccucugcggagccpcucpucgccggagccgcgccccaccccgccagcuccagagccac\n", + "caaaaauaaaggacgcgaccgccgcagccucugcggagccpcucpucgccggagccgcgccccaccccgccagcuccagagccacguacg\n", + "aaaupuuucaccguguuagccaggauggucucaaucuccugaccucgugauccgcccaccucggccucccaaaguacupauuacag\n", + "gucuuucccuuugacaagucgcugcugcugcagcaaaaauaaaggacgcgaccgccgcagccucugcggagccpcucpucgccggagccgcgccccaccccgccagcuccagagccac\n", + "agcaaaaauaaaggacgcgaccgccgcagccucugcggagccpcucpucgccggagccgcgccccaccccgccagcuccagagccacguacg\n", + "gccgccuggccauccgguacagaauguauugccaaguacaacuuccacggcacugccgagcaggaccugcccuucugcaaaggagacgugcucaccauuguggccgucaccaag\n", + "gaccccaacugguacaaagccaaaaacaaggupccgugapcaucaucccagccaacuacguccagaagcpapcgugaaggcpuaccaaacucagccuc\n", + "cucuaaugguaccaagugacagguuggcuuuacugugacucpacgccagagcuccugagaag\n", + "ccgcacccccupaccccugcgccccuccccuccccccugaccgcauggaccgucccgcaggccgcugaugccgcccgcggcgagguggcccggaccgcagugccccaagagag\n", + "ucuucaugcucuuccccacagcucuaaugguaccaagugacagguuggcuuuacugugacucpacgccagagcuccugagaag\n", + "acaggcgccugcgccgcagcpcugccgcugguugguccgcacguggaaccucuccugguccuguugacccpccccucggaaccuccagcuugguccggucupacuggaagccugcc\n", + "gcpcugccgcugguugguccgcacguggaaccucuccugguccuguugacccpccccucggaaccuccagcuugguccggucupacuggaagccugcc\n", + "aggcgccugcgccgcagcpcugccgcugguugguccgcacguggaaccucuccugguccuguugacccpccccucggaaccuccagcuugguccggucupacuggaagccugcc\n", + "agacapuuucaccauguugcccaggcuggucucgaacuccuggacucaagcagucuguccaucucagccucccaaagugcupauuacaggugugagccaccacacuggccaag\n", + "aaaaagagcgaaagguaaagaaagagcagguucguggacaggagccggcpcaggccpaucccug\n", + "agucgagguaaaaagagcgaaagguaaagaaagagcagguucguggacaggagccggcpcaggccpaucccug\n", + "gcuccugccgcugcgguccgucggucggucagucagucccuucgcgcuccugagccgccggcgcgccpcgccccgg\n", + "aaagupaagcgcggacaaaaaguaggcpaggagaggagagccccagcupaaaagcaacggcagucgagguaaaaagagcgaaag\n", + "gccuacuucggcugaggcuguucugcuccugccgcugcgguccgucggucggucagucagucccuucgcgcuccugagccgccggcgcgccpcgccccgg\n", + "pcggucggagccgccpagcuguaguucucccgcggcucagagaaguaggcagagagcggaccuggcggccpcagc\n", + "gaaccuaggaaauaacucggaaccuguaacgucccacugguuuggacauauuccucuccugaucuggccucaucuguuccapaggupauuga\n", + "acaaagucuugcucugucacccaggcuggagugcaguggcgcaaucacggcucucugcagccucgacccccpcucaagcuauucuccugccucacccuccugaguagauaggacuacag\n", + "guucgccucuacguuccgcgcpagcccacgcgcgguucguccggaacccacagaccagagacgcaggucccagccuuuucggugucggcgccaguucccggaggagcgg\n", + "agaacugagcucaucuuugcpuuagcuagccguugaguccaagucuccuuggcaagacaguagcuuagagaaacgagaucga\n", + "gauucaagugcuggcuuugcguccgcuuccccauccacuuacuagcgcaggagaaggcuaucucgguccccagagaagccuggacccacacgcpcuagauccagag\n", + "aaccugacgacccggcgacggcgacgucucuuuugacuaaaagacaguguccagugcuccagccuaggagucuacpaccgccucccgcgccgccacc\n", + "aggagcgcgguggagccuggaguggapcgapucccaccgugacccgccuggapcagcccagcucupacgcgaaaccgccuacgacg\n", + "caguuccaagagccucugaguuccugccuuuuuucaucucugaauccccaccauuggccuacauupagupcgaccu\n", + "aacggaagcuccaggagcgcgguggagccuggaguggapcgapucccaccgugacccgccuggapcagcccagcucupacgcgaaaccgccuacgacggugccgcag\n", + "aaagcuuaguggugaccucaaguaacaaaaucuacucauuucuuguaggaaaacgaacagaguuauuuccuuaagcagcau\n", + "agugcagugupuupccpuppcagappuggcccagguggcccuaggacccccccucc\n", + "gaauugaauuacuuugaacaccucuuccagcugugcauuacagauaacgucaggaagagucucugcuuuacag\n", + "agagcacugcugcggccgccgccauuuuagcguuuugucagaagcguccgcgccgcgaggaggaggcccugcugguuucugugcgg\n", + "aguagguuucagaaagugcugagagguguaagcccagcaacgugcaapaaapacaggauucuggauggccauuugcuucacupaugcaaaaccucuuuugaguacuagaaucag\n", + "guuucagaaagugcugagagguguaagcccagcaacgugcaapaaapacaggauucuggauggccauuugcuucacupaugcaaaaccucuuuugaguacuagaaucag\n", + "uccccucguccaccgcugccgccuccuucuucugccgcuccuggugcugcuugugugcucguuuggugcggaccugguaccucuuuugugaagcggcagcugaggagacuccggcgcucgcc\n", + "gaaggagucaagacugagaacaacgaucauauuaauuugaagguggcpcaggaugguucuguggugcaguuuaagauuaagaggcauacaccacuuaguaaacua\n", + "cucuccccucguccaccgcugccgccuccuucuucugccgcuccuggugcugcuugugugcucguuuggugcggaccugguaccucuuuugugaagcggcagcugaggagacuccggcgcucgcc\n", + "gcggcaggccggcpcaggcucggcgugucccuuccguccggcccgcgccggcggcpaggcggcgcgcggcccgcagcccgccc\n", + "gguugugguuuuuugcacugaauguaaccuagacucaucuucacpcuuguguugccccagguacugucaaag\n", + "cggcccgcggaggcgcguccgccccuggcuggcgguggcagapaggcgucaggccucggauccucpucccugcgcagcgucccggccugugugcaggaccugcgugacaag\n", + "gaagaagguagauaaugacuauaaugcccuucgagaaagacucagcaccuugccugauaaauugucuuauaauaua\n", + "acucuuuuccaggcuccuuggaggucacugcccugaugacaacauggucuucccuucaaggaagccacguuucuaagapcucuggcauaugcauug\n", + "agaugaguuugcuguguuggccagacuagucuccaacuccaggccucaagugauccacccgccucugcuucccaaagugcupaccacaacaagu\n", + "gagaaggcccaggaagugacggccgccucccggcuaccpacuucuggaguccgagaagucaacggcgcgguugcugcggccgccgcgcuccccggcccgaggcg\n", + "guugcuaggagaaggugaauaagcaugcuuacagcaucaguugauguacauauucuugcaauaacaaccuguggagcuguguucuucu\n", + "gaauucugaugugcuucagugcacagaacaguaacagaugagcugcuuuupagagcuugaguacucagucg\n", + "gcgcpcggcggcggcggcgagagcagaggacgagccpacgcggcgccgcggcaccapcgcgcagccpccggcccgaccccaccggccauacg\n", + "ccgcccccagccccaucgcccccuuccccucccccaagacpcagcuacuuccagagcuucapccgcggcucacaccugagcgcgacugcagapcugcaccuggccuu\n", + "ccgcccccagccccaucgcccccuuccccucccccaagacpcagcuacuuccagagcuucapccgcggcucacaccugagcgcgacugcagapcugcaccuggccuuaugg\n", + "paucccuccgagccpcggcggcggcggcucucccccpcpcpccggcpccggcpccggcgcgcpcp\n", + "accccucgcccgcugccucccucggcccagccagcugugccggcguuuguuggcugcccugcgcccggcccuccagccagccuucugccggccccgccgcg\n", + "ggucauguagguacaacagcaaccaagaagaucgaugucuaccucccucugcacucgagccaggacagacugcugcca\n", + "guaggugagcucgugaaacaauaugaagaggagaaaauagccuuuuaaggaaauuggcccacagaaagg\n", + "gcgcgguggcucacgccuguaaucccagcacuupaggccaaggcagccggaucaccugaggucaggaguucaagcagccacgucaccugag\n", + "cucaaagauuagaacgacuccgaaaagagagacaaaaccagaucaaaugcaaaaauauucaguggaaagaaagaaauucuaagcaaucag\n", + "gacucgaacuccaccgcggaaaagaaagccucagaacguucguucgcugcguccccagccpccgagcccuccgcgacgccagccpcc\n", + "ggccuccuuupauuccaaaguaagacaaucucaucuccuuuuggugauucaucuccacggcuuuuccuaaagguaacauguaagaggaagaggug\n", + "ggccuccuuupauuccaaaguaagacaaucucaucuccuuuuggugauucaucuccacggcuuuuccuaaag\n", + "gagcauggaaaugacccagcugcccugcuguugaaacagaauccuauuuggaaggcagacauguggcccaucucuguagccaucacugagaaaucuggauuuucaag\n", + "caaugauuuucaacaauuauaaaauggaaguuguagacuggauaagagaugcucagcuaapaguuccuggauggucuuuagauugauacaccaauccucugaaauugcaugcaaaaau\n", + "ggccuuucucucuguugcccaggcuggaguuuagcgacucaaucauggcucacugacugcagcaucgaccuccpcucaagugauccuuucaucucagccuccucaguagcugagacuacag\n", + "guuuuccupaucagcugcacuccuuagcaaaaguauauuggagaaucaacugagaaaguaacugagacauuucaaucauuucuagguguaaagaaagaccagaucccaggaaaauauuacg\n", + "ggacccaacuccugauccagccccugccggccgcaccuuccgcapugucacagaaucauggacugaguccacuuggcccccacugcacag\n", + "gguccpcgaguggaccccgupuguccuggacccgcugcuccagcuccugcpcguggcgucucugugcgcagccggcgcugccuccg\n", + "gacugccccccapcugugcccuuccgagaccuacagugugcccuguacaauggccgcccuguccupcacccagaagaccuaccagupugcccuuccaup\n", + "cgcccaaccagugcgaccucaacugccuggcugapcacgccuucuaccacagcuucggccgcguccuggacggcaccgccugcagcccpugcccapucugcguggcuggccgcugccuu\n", + "agcgccggcugugaupuuguupcucpugcccucgaggaccgcuguggccgcugcggaggcgccaacgacucgugccuuuucgugcagcgcguguuucgugacgccg\n", + "gugccuucgcupuacuggaacgugacccugauccccgapcgccagacacauccgcguggaacacaggagccgcaaccaccugg\n", + "cuccuugaaacccgccggcgcacaugaggccgcugcccccgccgcaggcgcuggcggcccccucgcggugcccguggugaugcc\n", + "agaggucucuggcuggcpcgccccgucggccgccggcuuccuccuugaaacccgccggcgcacaugaggccgcugcccccgccgcaggcgcuggcggcccccucgcggugcccguggugaugcc\n", + "cgcagccccaagaaugaaugaaaucguagcgcgcupcggcagagcpcggcgcaggccpcupcccgcgcgcggcggcagcggcgccccpccggaggcggcccagccgagcpcc\n", + "gugcaugguuauuugugugauuugucuccacacuauggaacuupauauuugucuuuuucaguagauauuuaugugugcacgugugugag\n", + "guugguggaucuacaggcgaupccccucacccugacccuggcccagaccccupaggaggugugcuacagccgugagcapcccagcuaca\n", + "gcggcagagcpcggcgcaggccpcupcccgcgcgcggcggcagcggcgccccpccggaggcggcccagccgagcpccauggccaccgccauucagaacccgcucaaguc\n", + "upcggccucagcgcccgcccgaccgcupaggaccgacccggcpaccugcupcaggacccpagcaag\n", + "gcggcagagcpcggcgcaggccpcupcccgcgcgcggcggcagcggcgccccpccggaggcggcccagccgagcpcc\n", + "gugcucccgccccccpaaugaauggaupcggccucagcgcccgcccgaccgcupaggaccgacccggcpaccugcupcaggacccpagcaag\n", + "cagagcpcggcgcaggccpcupcccgcgcgcggcggcagcggcgccccpccggaggcggcccagccgagcpcc\n", + "paaacaccagaaggugupugcugagcuccgcugcgucagacugccaggaccugaguggaacucagugcugaaaccupuucucacugcagcuggauagcag\n", + "aucagcagcucuagapuggcggccuugccuggaaccuccgcaaccuccgcgcccaccacacaapcugagaacaguaag\n", + "aaacacgcpucagcugauccggcccaacugcggcgucaucccggcuauaagcgcacggccucggcgacccucuccgacccggccgccgccgcc\n", + "ggcccaacugcggcgucaucccggcuauaagcgcacggccucggcgacccucuccgacccggccgccgccgcc\n", + "uacuuuauuugucuuuaguucaacucagaaagccagagccaagcuuaagacaucagaauuauccccacugccucuuca\n", + "cuuuggcuagaucagagucuaagagagauggagguuuuaaaaauaauuggagcuuugaucaugaagaagaaagugaaggagauacagauaaaga\n", + "uuaaaucgucgaucugaaauuguugcuaauagcucuggugaauucaucuugaagacauauguaagacgaaacaagucugaaaguuuuaaaacuuugaaaggcaacccaauuggacuuaac\n", + "puuggagcaggaggaaucugacuguccuuugcuacuuucuaucuucccuuacucaacagcagucaaagccaaagaugcgaagucacucuuaccucug\n", + "acauucaacaacaggcucucuaucaguuauugucapaacagcaagacacaagcgauuuugucaaauucaugaucaaaaggcuauguuaccugugacagugaccagaaaaaugacag\n", + "cagguuuuuguagccuuugaggauguggccauuuacuucucccaggaggagupagcuccuugaugag\n", + "agaaguccuguapagaupcaguuaccuucucuccgucucucucucpacucuauuuguggcugguggagcugucuuaaacgaagagaacc\n", + "cccgaggucgcagcuuccacuggcgcpuugaguucccuguugcccuuggucucpucgcuguaggcgcugaggcugcag\n", + "agacucgcuguaucccccaggcuggaguguaguggcgucaucucagcucacugcaaccucugccucccgaguucaagcaauucuccugccucagccuccugaguaacupacuacag\n", + "acuggcgcpuugaguucccuguugcccuuggucucpucgcuguaggcgcugaggcugcag\n", + "guuuucaaaacaaaaauagaguugcaaucuuggcagaacuggacaaagagaaaagaaaacuacuu\n", + "agcgcagcpcpaagguuguagugccgcgaguugagcuccucuugccuaaguggucgcgcccccuuuaagagcagcgauuguaaggagaggcggucccgguguccucpucccag\n", + "agaguagcuuucugapcauauguuagccuucaguuuuagugaggaguaapacuaaauccagcaaaaacuuaagugaaaacaaccugaggaaaagcuguagacugugagucaag\n", + "aggugccgccuugcuucugacgagccacacguuugcuucuucccuguguucccagcuggapac\n", + "acagaaccaaguuguauuguuagacacacuggaacaagagauuucaaaauuuaaagaaugucauucu\n", + "agaacuccggagaaacccupaguaagcgguuuuuggcggcugcggcccccpcccugccccgagugcagaaaupaaccgcgccggccccucugcccagcgca\n", + "ucuguccggccagccgcuggagucguuaggugccgccuugcuucugacgagccacacguuugcuucuucccuguguucccagcuggapac\n", + "guuaggugccgccuugcuucugacgagccacacguuugcuucuucccuguguucccagcuggapac\n", + "guguugacuccgguacgucauugguuauuugucauacggcaguggupauggauuuaccagaaagaugaucagcuuauaauucagagag\n", + "aaaaguccuccauacauuuucuccccaauuccauuccuupcaugccauagcauuupaaaaguccaauugaauuucuagaaaaugcauaugagaag\n", + "aguaggagaccupcaaggcccccuguggacgaccaucugccagcuucucucguuccgucgauupaggagcgguggcgaccucggccuucaguguuuccgacggaguga\n", + "gcagguccagugaaaaggagcaggaacggcagcagcccggccgccgacccggaagcucuuucaccgccaaccgcgaggcugcaaapugugaacccggaagcgauuucauagccacg\n", + "auagccacgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagapugapugaauggugcugaggugcgaggagapaaggacaguaaagagcag\n", + "uaguuucpagapugapugaauggugcugaggugcgaggagapaaggacaguaaagagcag\n", + "auagccacgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagagg\n", + "gguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagapugapugaauggugcugaggugcgaggagapaaggacaguaaagagcag\n", + "gauuucauagccacgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagagg\n", + "agccacgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagapugapugaauggugcugaggugcgaggagapaaggacaguaaagagcag\n", + "gauuucauagccacgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagapugapugaauggugcugag\n", + "aagaccupaccccguaguuucpagapugapugaauggugcugaggugcgaggagapaaggacaguaaagagcag\n", + "auagccacgguaacggcpuggaaagcuaaggccuuugaagaccupaccccguaguuucpagapugapugaauggugcugag\n", + "acuugccuggacgcugcgccacaucccaccggcccuuacacugugguguccagcagcauccggcuuc\n", + "gccggcggcpagaucgcpcgagcggagcgcaacacucgcuugguupagaucggcgcuuggccg\n", + "cggccccggcugccagcaccauguccgcapagauuuupaauccacugagaaaauucaaguugguguucuupagcagagcg\n", + "ugcccupuucccugacugcucuggccuuccaupuguucugcpacugcuggcagcccuuccggacuccucccucucugcuaccugcucag\n", + "ugcccupuucccugacugcucuggccuuccaupuguucugcpacugcuggcagcccuuccggacuccucccucucugcuaccugcucagguugg\n", + "acaccuggcccgcagguagccggcaccaggagccuuagagaagcuguapccugcuggccgcucguccgccucgcgcccpcuccgcgccuggagcugcgccggcggcagcc\n", + "cggcaccaggagccuuagagaagcuguapccugcuggccgcucguccgccucgcgcccpcuccgcgccuggagcugcgccggcggcagcc\n", + "aguucccggcggcccccpcpcpcpcpugguggcggcgguupcucggcgcucgcucgcucgcupcpcpcggugcg\n", + "acuccuuccucagcuccaguucaggucccggagcccacccaguguccacaaggccupcaagucccuccuccgacccccuggacuucggcuuuuguccccccaaguuuuggaccccuaapaaga\n", + "uuacaaguuggcugcugucgccugcgcaucggcpccpaggcugagcaguacuguugagagcggugugaggugcuugguagcgcgccguagcugcuuccacguccuugcuucaccucagguaaag\n", + "cuuugccuucuugaucuuccguccuucuuggagacgacuggcgagaggaagapacuagguccaaacgcuagguggcupuccag\n", + "auaccuguguuuugacucuguuccuguggauagcugcuuggucugaaguuccagaaaggauccuguucccagacag\n", + "gucccugaguacugacggucacaggcugccgcgucuuuccuguugacucauguuugguuccuccagugaaaauuuuacuuagagaa\n", + "ggcuggcagguggcggagauugcaccggaagacgcuuccupuuugaggaguucagugacugcuauugaaccaccaaaaguccauu\n", + "cagugacugcuauugaaccaccaaaaguccauuaugaaacuggugagucuucgcuccuaggucagapcaaag\n", + "uuuacagcaguagugcgcuugcgcagcuggucccacaccaagucgcccgccucuccucguccggcuagcagapcgcugugag\n", + "pacagaggcuggagaaggauguauggccugcccupcuugucuguucccuccugagccugagccccuuaccuuccugacccc\n", + "aaacacauuaaaagaacacaugccaaacaucauacuucggaagcaauugaaaguuauuaccagag\n", + "guggacuaugcgcccucauuaauggcucggcuuauacuggagagguuucuacaggaacacgaggaaacuccac\n", + "ccugagaagauguuuuauauaaucaguacaggacuaauuuuucuupcucaguguuccuugucuugguucauugccuagauacauccauaaauauuuguugacuugag\n", + "gacuucaggugaaggacaggcagcaggagcagaugagauuuagaauaccaagacuguguguacacgcag\n", + "cgcuuugccuaccccucaucccucggcaccaaggcuacuugagccccapuguuuuuuccuuguucccgccaccuccuggucccuggcccaac\n", + "caucccucggcaccaaggcuacuugagccccapuguuuuuuccuuguucccgccaccuccuggucccuggcccaac\n", + "agaaggcupagucuguaguuuguuccugcugccaggcuccacugapaacpaccugucugaagagaag\n", + "agugaguaccagcagaaggcupagucuguaguuuguuccugcugccaggcuccacugapaacpaccugucugaagagaag\n", + "cacauggagaccaguugccguugcuguuuugaucaacuucaaaggcauucauccapugguuuauuccagaaccacuagaaaucauuaggaccaccaggacagccucuccacagccaucug\n", + "ucuggaugacucuccagucagaauucuccugaaaauupuuaauuucagcucagaaaagcagaaacgauacccuugguacuggacuggaagaaaacuacgaagugagagagcc\n", + "gucucuaguagagcgcguguauagaggcagagaggagugaaguccacaguuccucuccuccaagag\n", + "guccgcccuuagaccuguugcccagcaucccugcaguucgcgguacagucucuaguagagcgcguguauagaggcagagaggagugaaguccacaguuccucuccuccaagag\n", + "guugcagaggcaguguuaacaucccaacugaaagcacaucaagagaaaccaaauuuuauuaucaagaccccaaag\n", + "auuauuuccggcuccucccggaagugccgaagcuggcuacuaapaacuupaggaucccaccucagccuucgugacuagugag\n", + "acagupcugccuppcugaugccaccauuccaggagccucggugaagagaggauauccaucuguguagccgcuucucuauacpauuccag\n", + "uggcuggugcaaggagccacagupcugccuppcugaugccaccauuccaggagccucggugaagagaggauauccaucuguguagccgcuucucuauacpauuccag\n", + "gcggcgguagcagcagcpcccggcupcgcgagcgcggcgcagcccagcccagcccaguccgagcgcggacccggcgcccgcagccccggcgccgcc\n", + "ggaaucaggaacuggccpuccgcaccpccugagucgguccgaggccgucccaggagcagcugcccgugcgg\n", + "aaaccgcpaggaggaagcgcggaaucaggaacuggccpuccgcaccpccugagucgguccgaggccgucccaggagcagcugcccgugcgg\n", + "pcgccgagucupcgcpacgcpcggcgcgaagcpcccucugccgccccgcgcuccc\n", + "cgccgagucupcgcpacgcpcggcgcgaagcpcccucugccgccccgcgcuccc\n", + "ggcacugcggcpcpcgccgagucupcgcpacgcpcggcgcgaagcpcccucugccgccccgcgcuccc\n", + "augaggaacuugaggcaagucaccagccccugaucauuucgccuaaaagagcaaggacuagaguuccugaccuccaggccagucccugaucccugaccua\n", + "acuucagcccuagcagcaucugccugupaagcagcucuccacaccagccaapcccccacacucccgcgcugcucugcggcucapagcagcccaccugcugg\n", + "cacccacccaggcccaggcuccuuccccuccaucauccccuuaccagcaccuagaaccauccapcugaaaaguccccuccaaaccacgug\n", + "agaggapcaggaaugucugagguggcaacacuucucuucagccagacagcacuggccaguuuggagucuguccauccugcaggccacaagcucugg\n", + "ggapcaggaaugucugagguggcaacacuucucuucagccagacagcacuggccaguuuggagucuguccauccugcaggccacaagcucugg\n", + "aaaaupagccaagugugaaucggacpucapcupugugguggagcucuugcguuuagagagagag\n", + "aucucgacauggcaggagcugaggcagcugcaggagcagauccggagccuggaggaagagaaggcagcugugacugaggcagugcpcccugcug\n", + "ggaggcccagcuugaggagcaguucuaccugcaggcgcugaagcugcccaaccagacccacccagacgug\n", + "gugcuccgccgucuccgccgcaucuuccacccucgccgccgccgcagcuccccgcgcucgugccaccgccgccgcguccacccucagcgccaccgcc\n", + "uauagcggcucccpcgcapaccgugcuccgccgucuccgccgcaucuuccacccucgccgccgccgcagcuccccgcgcucgugccaccgccgccgcguccacccucagcgccaccgcc\n", + "acccgcaaaccagaucgccgcuccggagcccccagcccacupapcucgcgguuacugcaaggauucuggcgaaugaggucuaaauaga\n", + "auauagcggcucccpcgcapaccgugcuccgccgucuccgccgcaucuuccacccucgccgccgccgcagcuccccgcgcucgugccaccgccgccgcguccacccucagcgccaccgcc\n", + "ccuuuugcugauuuugccucacagaauugagaguuuguucuuacacacaaguuuaaugccaccuuccucugucugcc\n", + "ccpuaguggucgucgugguuuuccuuguaguucguggucugagaccaggccucaaguggaaacggcgucacc\n", + "aguccggcgcgcagaggaggaggagaaagcugaccgcuuaggccpuaguggucgucgugguuuuccuuguaguucguggucugagaccaggccucaaguggaaacggcgucacc\n", + "gaguccggcgcgcagaggaggaggagaaagcugaccgcuuaggccpuaguggucgucgugguuuuccuuguaguucguggucugagaccaggccucaaguggaaacggcgucacc\n", + "aggagaaagcugaccgcuuaggccpuaguggucgucgugguuuuccuuguaguucguggucugagaccaggccucaaguggaaacggcgucacc\n", + "pugacauuggccucuguugcuuguccccaggaucccucucugacaccccugcuguguuugcugupaguucugcugccaccacccauuag\n", + "auucucucugagcuggcacucaagcaccgupaccuuggcuggcuucupagcaagagauccauuuaugaauacuugauuucugacugcugg\n", + "gcagguccpaggcgcaggcggagagcggcggugcccccgagccccucugcggacggcucaggcpaggaccccgcgcggcugg\n", + "agcgacaacggcucugaccgucuggcaggccgcguggcgcccgcgccggccuuccugcapacuccaccggagccuugccaauuccguuuguuucccuguugucgcccgcuucacccuggauc\n", + "agugaccguaaagcuguucgcucggugcgacgcaagucucagcucagcgcgcuuauccupuccaccggcgcuaccgccccccgac\n", + "gcuccugugacguuugaugacaucacuguguacuuacuccaggaggaaupugcugcugagccagcaacagaaggagcucugugguuccaacaagcugguggcaccacugg\n", + "gaccaacuguugccaauccugagcuguuccgcaaguucggacgapccagagccauggcuuggcagcguccapccagaggagccuucuggagcaucacccag\n", + "cucggaaagccacuacauuagccuucauuucaacuaaaauuuguaucaagguaauacuuuuuaaagcggcgauag\n", + "ggaauauacugaaacauuuagaagacagagauguauucugaaauauauaaaaauauaaugaaggaaauacagaaauaauugauuuauaag\n", + "gcacuuguacauuucugcagccgcgcggcgagccauucgcggcggcugcugcagcuccuacugcaucuuccuucucuuccuuuccucpcuccgg\n", + "ggcucggagcacuuguacauuucugcagccgcgcggcgagccauucgcggcggcugcugcagcuccuacugcaucuuccuucucuuccuuuccucpcuccgg\n", + "auuaagcuguccacauucauaaggcacacuccaggucugcaggapagcaugapauucapacgcccuuguccccuguacacaccuapccgguucgacuacaguag\n", + "acauuucugcagccgcgcggcgagccauucgcggcggcugcugcagcuccuacugcaucuuccuucucuuccuuuccucpcuccgg\n", + "gauaacccgugcguuucguaaggcucggagcacuuguacauuucugcagccgcgcggcgagccauucgcggcggcugcugcagcuccuacugcaucuuccuucucuuccuuuccucpcuccgg\n", + "gcuuugcuaggccaggccuaccupcupuuggagugguauggucuuuagcuguuagaaagaagaugaagupagaggauggcauggcuggaccag\n", + "caccaugaggacacauagaagapuauuuacagcuggaugugaccugccpuggccuccccagauccuauguggacagugucuguacugcauuggcuggcaagauagaguuugaag\n", + "gcaguggcucugccaaugauccugugaguauucaggaaucacuguugccccupauccuuguccuggaguggcccaccugcuugcccccagc\n", + "aagugacgcgccccpuuuguugacagcggaggcggcggcggcugcaggcuccgagccguaggagccggaucpapccpcccaggagccucagccccgccggcagcccuaapcaag\n", + "ggcgcupagcgcuguagcagcugagaapcugaggcaccgccgcuucgcugacagccggccaccag\n", + "auguucaugcauucuagagaaaguggaaaacuuagaagccuaauuaaugacugucuucuggaccucugagaccauguuucuaguguuuuccguggaauauuaucag\n", + "cupaagcuccaggcuaccuacacaaccuggcccaggcuggucacgguguccccccucccugcucugugcccucuccuuccagaaauccacc\n", + "agaaupaaacugccuupagaagccccaagugagcccaapcgcagagcagaaggacccuggaguguaagagccuagauugcaagccuggcaggaggag\n", + "ccggaagaauuaaccucgagucugcacgcuuuuaagaacaaggccuuuaaaaaauccaaaguguguggaguuugcaaacaaauuauugacggucaagguauuucaugccgag\n", + "cgcgacucccacuaggcuaugagcuacaggapapuaggucuugcucccggagagcaccuuaaucacaggcgcugaaugaaaga\n", + "aagaugaagguaggugaugguggcgaguguuagacupuuupaacgugaaucgagucccagaacgcggcauugccucaguuccagcacuccaggauccuggcuuuag\n", + "cugaacaucuccuucccagccacuggcugccagaaacucauugaaguggacgaugaacgcaaacuucguacuuucuaugagaagcgu\n", + "ggucuggauucccgauccugaagaaguuuggaagucugcugaaauagccaaggacuacagaguuggugacaagguccugcgacuccugcuggaggauggaacg\n", + "cggugauuuccgcggcggucucuccugcgcccggccucugcggcgcaggcccagcccccgagccucgcacguucggcagccccggccuggccccggccccuccugccc\n", + "ggaagugcaaacuguguggucuggcagguguggauuccgccggugaaggcugaaggcagcuaccuuaaag\n", + "agcuuggcpcggugaggcgupugacppauggcpccggcaugcgcgcgcaugcgccgugguaaaaggccgguaccucpcaag\n", + "ggaucugcpaaugupcuggagagguccugccgugguaccagccuccagccugcccccaggacugccccugacccaggcgcgcccgcugcucgguggcaggapccggcggagcgcc\n", + "uaucagaaagaaucuuguaguugccuguggcagaagauccgacccaaacugagcaaaaccaguuucaaacgaaucugguuugaaacuuccgaag\n", + "gcupagaacacaucccuggucagcuguaggaaagccagagagcauuugagaagaggcugaagcuugaauuuugcaaacacacaag\n", + "cccucugcauuuccccagagagaagguuuuuuucucgucuucauuuccuuugaaacaccupugaggaaaaaccucuacauuggccaagcagaagaaacag\n", + "aaucuaugacugaagaggaucggcuaagagugguuccucgcagcuuaaapaggcacuuuucacacucugucuuaaaaucagaaguugaauucaugaacacauaugauuuagauagaaguc\n", + "agucucacucugucgcccaggcuggagugcaguggcacaaucuuggcucacugcaaccuccaccucccpuucaagcgauucuccugccucagcuucccaaguagcupauuccag\n", + "auuguguccugagcccgcaggucaggcugaaagagucaacaaccagcaaagugaagaucuaggagucuguuccccuugaaccuguguggaccugaucaaaccucgapaaag\n", + "ggccccaggacccgacccggccccaggagagugugcucguucuguucacggagcuggccgcguuagcgacguccucgaguccgcggcpcacg\n", + "uccugucuucccuacucccagucuccacccaacucccccgcccgccccgugcaggcuguggagacucccuucccpapcccccacugccgcaggugcccccucugccuccaccccg\n", + "gcuccuggccagaagcuggapcuuggccaaaaagapagaaacaacucagcuguucuuucuagcucugaaauagaaa\n", + "acccaacucccccgcccgccccgugcaggcuguggagacucccuucccpapcccccacugccgcaggugcccccucugccuccaccccg\n", + "cggagcggcgcguccuggcaggaccpcggcggcggcggcpccggcggcggccapacccpcuuaggcucggccaggccggcugapcgcpcggccagcpcggcggacgccguc\n", + "uugapaaaaacuaaaacaugacagaguuuauucaucaaupaacuuuuauauacuguuagaaggcauguaaauuggaacagccucuuuggaaaacaagucugcauuaucuu\n", + "gaugcccaggagapaauggaaaccuggagcupagugagguuagagcuguaagauccaagacccapagacaagaggacccupacgaauaggaacagcugagcaag\n", + "ggaugcuggaaucgaccuuggucucuaguucgacucccgugcaacguguugaggaggagccaccuccuccaagcgccuaaagccg\n", + "acccagaaacgccucccaaucccuccacaccgcggcucccpauccgaagcupagcugcuucuguccaaucaggcuuugcaucccpacgcuuccgguuauggcgucauuaugcagccagg\n", + "gaugagacaggagccuaucugauugacapaccccaccuacuuugguccuauccucaacuaccuccgccacpaaacucaucaucacuaaggaguuggcagaagaag\n", + "gugugcuggaggaagcggaguuuuacaacaucgcgucccuugugcggcugguuaaggaaaggauacpacaaugagaacagaacuucacaa\n", + "ucucccugccgagaaaupccggcccggcugcgcgcpcagcagcgguggcggcggcgguccaag\n", + "agugupaguccagcacuuccaugccccucuuupuacuacggaapagauuuccagcaucguguggaacauaugaccapaguacaccuugagcgcuugugugcaguuaucuuuuggcg\n", + "gccucaguggucuacagcaguuacacacaggcagugguaucugugagcagcucuguggacucaaagguuuucucccugagaggcaugacccaggccagcugauucaucagaaucag\n", + "acagcucggagccaccaggcgcugacgaggagcccggcugapaggaugcgccgcugacgccugcpagccgcgcgccupcpagg\n", + "ggugucuapccuggagaupaccagcugccugccugcccccuaccccagguupcgccgcuaag\n", + "gagagaaugaggccacuugguaguggucaagcccupaccaagccuuccauggapuucuug\n", + "cugugaggcggcggcuaagaaggcggcucugguggcggcgguggaggcugaggcggcggccgaggcggcgacggaggaaacagaag\n", + "aaguuacugugaggcggcggcuaagaaggcggcucugguggcggcgguggaggcugaggcggcggccgaggcggcgacggaggaaacagaag\n", + "guaaagugaacagaguuaucugugacauuccaucaggcaccuauguaacgaaaucauaccguaauaacucacc\n", + "aguaccccggccgcgacccuccgagccccuggagcccpuaaccaggccgccggcgccggcucgcpacccgccacccuggaagccccgcgcacacagcgcauuccug\n", + "guuccucpuucaaacgcggcggcpaggcgcpcggaacagaucgcagaccupuucgcagagc\n", + "ggcucgguaaagauggcggcgcccapcgguagcgugaaacuugguggaagacgcugaccagucguguuggaaucaaaacagcpacccugcgcc\n", + "gcggcgcccapcgguagcgugaaacuugguggaagacgcugaccagucguguuggaaucaaaacagcpacccugcgcc\n", + "cgcccapcgguagcgugaaacuugguggaagacgcugaccagucguguuggaaucaaaacagcpacccugcgcc\n", + "agacuuuagacuugaggcuggaggaaapaacugaacgcgguucupagcagcaagcccacpuagcagccgaggccccaga\n", + "aguacaaggaaugcuucucccuguaugacaagcagcagapaagauaaaagccaccgaccuc\n", + "gcagcgcuggucgcagcccucagcugcgccpcgguuccggcuccucccucuccuugugccucagcgccacc\n", + "ggccugcgccggapcugucauuugcagcgcuggucgcagcccucagcugcgccpcgguuccggcuccucccucuccuugugccucagcgccacc\n", + "ugcagcgcuggucgcagcccucagcugcgccpcgguuccggcuccucccucuccuugugccucagcgccacc\n", + "gcagagagauggauguaacacpucaugagcaaagauuaccaccapcagacuagagcauccuupauucugugaucagucaucccuccucgcugguga\n", + "aguguuuucupaupaaccacgccgcuucccagucucugugcgaggcgugaagcgcggaccuuucaacaapcuuuauuaauucucacgcugcggcccuggaaagcg\n", + "aguacuucauagacuuuaucauacuucguagcauccaguauguuuucuuugcuaagauuauugauuuuguauugaapucccauguccaucguuuuca\n", + "agucucugugcgaggcgugaagcgcggaccuuucaacaapcuuuauuaauucucacgcugcggcccuggaaagcg\n", + "guuuucupaupaaccacgccgcuucccagucucugugcgaggcgugaagcgcggaccuuucaacaapcuuuauuaauucucacgcugcggcccuggaaagcg\n", + "gcacugugcagcugcuccagugapcgcagacuguacuggccugugcggagcaaggcgguguuucug\n", + "gguaugcaaauaagcaaguggaggccgccagccgacuuccucgcacugugcagcugcuccagugapcgcagacuguacuggccugugcggagcaaggcgguguuucug\n", + "gugguaugcaaauaagcaaguggaggccgccagccgacuuccucgcacugugcagcugcuccagugapcgcagacuguacuggccugugcggagcaaggcgguguuucug\n", + "ggauccagccucuauugaggauuugaugcgacggccucacpcuuuggaggugaaagaggcccagaguagagagagagagagaccgacguacacp\n", + "gauuugaugcgacggccucacpcuuuggaggugaaagaggcccagaguagagagagagagagaccgacguacacp\n", + "agucuacgccuguggagccgauacucagcccucugcgaccauggcugugcuggcggcacuucugcgcagcggcgcccgcagccgcagcccccugcuccggaggcuggugcag\n", + "cuugcapcacaguggcucacgccuguaaucccagcacuuuggaaggccaacgcaggaggaucgcuugagcccaggaguuugagaccagcuug\n", + "gaaguggucauaguaagugcuacaagaacacccauuggaucuuuuuuaggcagccuuuccuugcugccagccacuaagcuugguuccauugcaauucapagccauugaaaaggcag\n", + "gaagagaaaacuggccagaggccaucugaagccaaagagauaaaacuuuaugcccagauucccccuauagagaag\n", + "gaggcaguapacacauuagaagaacuguggaucuccuacaauuuuauugagaaguugaaapauccacaua\n", + "gaagagaaaacuggccagaggccaucugaagccaaagagauaaaacuuuaugcccagauucccccuauagagaagauggaugcauccuuguccaugcuugcuaauugcga\n", + "ggauuaggcaaagaggagucccaaaaugagaaacagaccaaaaagagucucuuaccaacuuuggaaaagaaguuaacuagagugccaucaaagucacuggacuugaauaaaa\n", + "acucggapccggcggaggaggcgcgcggagccuguaacucgcagcgcgcgcuggaggupcgcpcggugcggugcggugcgcgcpcggugccgcggcggcggapagccgcg\n", + "aacuuguugagugcucagaauccgugaggugcauucucucauucuagcaaggcaccagcgacaucgcagacuaugcuugguuauauacuguauuga\n", + "agccugacuagacaggaauucuggcaacugcuccagcagaacuauggcacugagcuagguuuaaaugcugaggag\n", + "gucagucgguaaaaagucccgcagccugucaggugaggccccggccucgugccgucgcucuucccgccgcacupcggcccaggccgcucccugccpccucacugccgccacc\n", + "gaacuaauacaguauaguuucuuguucuucagaagcuuacagucagcaaggaacagaaagccaaauaaaguaggaaagg\n", + "aguccccpcgcaggcgcacucgucgccgcggcggcguccpcuggcguuccccuggaggcug\n", + "cupuucaccugccauagguucuugacuucaggacaguuuccugcuggcuuuaguuuccucugguaacuupaaucaauugacaucuauggaacuucuguuaugguucag\n", + "uagacagcacacugcugacuguuuucaguuguuucuguaacagcagaaagugcacucacuaggaguagucagaauucaaa\n", + "gcugaapcucguccagccpuggcaagucagcaaaaggcguuaauugugucuaacacagcuaucauccuupcaauauucuguaucacacugucuaucaagcuaaccccuugccagag\n", + "cgaagcagcaguuuupaauuucgaucguuuucggaauaauucuuuaucaaaaccagaugauucaacugag\n", + "gcacaugaaggagaucccacaaauggaaguggagaacaaaguaaaacuucaaauaauggaggcgguuupuaaaaaa\n", + "ggaagcucagcaguguccacugucgccauuccuuggccauagaaaacaauguauuugaauuuugauguaagcauaacaaauug\n", + "aagaugaagaugacacguugauuucuuguuugaaauuaaccaagucccgagaaaagaaagugaauaguguuagcacgaggaggaaggaagaa\n", + "gugcauggcugccuccuaaucccauaguccagaggaggcaucccuaggacugcpcaapagccpcaagcccapcagccuugaaccguccccuggccugcccuccccggupccagg\n", + "gaaapcuggcgagucgaaaggcgaggcggccgcggcagcgcuupacgcgccupcaccpcucgcucccugcgccccggagcaggccaaguucpccaggacgucpaggaccug\n", + "ggccagcgcupaucpccupccuggauugcgacccgcggcpccgcggcuccuagccgagacpcpcpaaccag\n", + "aggcuuuuccauggugcuuccgccaaagcuugugaccgaguccuucccgccuapcuggupccuccccugcug\n", + "ggcuuuugacugacuggaugupaauguuguggaagacuucuggccugccauuuccugagaacpacugcugagagaggagcupaggagcacugcaaauuucacuuuggacacgugagucagag\n", + "gaugucapcgupuccugaucacauggcagcagcccuucuupaagucagcuacccagcagccuguaguccucggcuacccacccucaccgccupucccaug\n", + "ggcgagucgaaaggcgaggcggccgcggcagcgcuupacgcgccupcaccpcucgcucccugcgccccggagcaggccaaguucpccaggacgucpaggaccug\n", + "cucucuucgcuuucuuuacucagaacugaagcucucauuccccacccaccaaggaaaaacaaaapaagaagccacagcuggccccggcuugcuuuggcacag\n", + "gupccupccagcgcupaucpccupccuggauugcgacccgcggcpccgcggcuccuagccgagacpcpcpaaccag\n", + "gcagaaapcuggcgagucgaaaggcgaggcggccgcggcagcgcuupacgcgccupcaccpcucgcucccugcgccccggagcaggccaaguucpccaggacgucpaggaccug\n", + "uuuuauucucuucuuuuuccuuuauuuugcuguaauagaggacugagcugcaauguuuuauuaacugcucuucccuucccccpcuauagagacuguuggagagaaggaacuggacuccucaagcu\n", + "cuuagucugucacccaggcuagagugcaguggugcgaucuupucaccgcaaccuccaccucuccaguucaagcuauucuugugccucagccucccaaguagcupauuacag\n", + "ggcccggucuggaguuugcggapccgagccpugcgcacpaggcggaggcagcggcggcggcggcggcggcggcggcggcggcggagcag\n", + "gaccauucuggcugcugucuggacaagaagucguapugapuggaagcupaaacccacaggaggcaaccacacuaguuuag\n", + "ggaupauuucgacauguuggucaggcaucucgaacuccugaccucaagugauccucccgucucagccucccacagugcupauuacag\n", + "ggcgccgcugcpagaggcccggucuggaguuugcggapccgagccpugcgcacpaggcggaggcagcggcggcggcggcggcggcggcggcggcggcggagcag\n", + "ugaguuacupauggaaucccccuaguccucucccagcucucucccuucgcccuccaguggugauuagaaaapapapaagagguuucagcgucucccaccccugcaggug\n", + "ggucuggaguuugcggapccgagccpugcgcacpaggcggaggcagcggcggcggcggcggcggcggcggcggcggcggagcag\n", + "cuauagcaggccuuuuuaugagacuaaccuggccucuccacuaaaggaugugugacuuucupacagaag\n", + "gccaugguaagugugacuguggcaagugcaagugugaccapaugguaupaugcuugccaguacccaacuaacugugacuugacaaagaagaaaaguaaccaa\n", + "gccgccuccuccuccaccuccuccuccuccuccucuccuccuggagcagaggagguuguggcgguggcuggagaaagcggcggcggagg\n", + "cagauucucuuuguuccgcagccauuucaggccccggacaggaggcagugccgcuucggccgaaggcccgagcgcccgaggcgucup\n", + "auuucaggccccggacaggaggcagugccgcuucggccgaaggcccgagcgcccgaggcgucup\n", + "gccauuucaggccccggacaggaggcagugccgcuucggccgaaggcccgagcgcccgaggcgucup\n", + "gccpcugccaggagcaguuccgccpuuucacuguccgugacuuccuucpcaccucaggcag\n", + "guuccgcagccauuucaggccccggacaggaggcagugccgcuucggccgaaggcccgagcgcccgaggcgucup\n", + "ggcuuuucucuuuagcgcucapcgcugacccacugcucuuccucuuaagaaagugcuccauuccuuccggcgcccggagcugcuggcccaaapauccggagcgagcuapcag\n", + "accagaccgcggacgucuguaaucucagaggcuuguuugcugapugccugcgcagcugcgacggcugcug\n", + "agaccgcggacgucuguaaucucagaggcuuguuugcugapugccugcgcagcugcgacggcugcug\n", + "accgagauagcgccacugcacuccacccupcgacagagccagacuccaucucaaucaaucaauaaagcaauuguuccuccucggaucagaacu\n", + "gagccgguaaacgcaugccupugcugcuuucacuccuaccacccucagaaaaacccggccugccaagaccgugagcaagaauaguagaacuucacaag\n", + "aguucaacaauuuuuaugaauuucuaauccaaccucaucauccuaupaaacagaagaccaccaagaacagccagcug\n", + "ggauuauggaaaauuuuaaguugagagcaagcaguugugagugucucucagccacuggugagagaaaagg\n", + "aguuuaugacagaapcaaaaacauugacugccucaaggucucaagcaccagucuucaccgcggaaagc\n", + "cggccccpcugcgcccucccccgcggccaggcucuggapacccaggagcugccgccggccucagccc\n", + "ggcagcugugacacgcgcaccuugucaccuugucaccaauuuccugcccpaucccagagcuacccuucuuggagcccacap\n", + "gaauaaagugaaacaccucaggcuccaacccucccaacccaaggcucccuccuggapagagagaggauggaggacaucag\n", + "ugaauaagccgugaacupcagcugugacacgcgcaccuugucaccuugucaccaauuuccugcccpaucccagagcuacccuucuuggagcccacap\n", + "gagaagacugaauaagccgugaacupcagcugugacacgcgcaccuugucaccuugucaccaauuuccugcccpaucccagagcuacccuucuuggagcccacap\n", + "accguuugccagccaaagcuaugucugcgcgcucaccgacuucauapugccgaauucuuuuuuccccaggcuugcc\n", + "auucuuguguuuuacuuuuugcgaugucuucuggcuuuugugagcuguauuugugaacuuuacuuuuacaa\n", + "gucuuuugucccucggcggacaccguuugccagccaaagcuaugucugcgcgcucaccgacuucauapugccgaauucuuuuuuccccaggcuugcc\n", + "ugaacauaapaaugaauaaagccaucaaaagcaaugaccuuguuaagaaaagaaagaaaaggagaaugacagcuuuguggccuucaa\n", + "gcgaacggcgagcagcggcggcggcgcggagagacgcagcggagguuuuccugguuucggaccccagcggccgg\n", + "ucggcucacugcaaccugcgccuuagccuccugaguagcuaggauuacaggcaugaaccaccacgcccagguuucuccacguuagucaggcuggucucgaacucccgaccucag\n", + "augguuuuaucgucucuccacapcccugaaaaaaacucucuuccugugucuggccagagguauagagagagacagguucaacucuaaggccugaaaaggaacaaggcccaccggaagca\n", + "ggcccugaaaaaaacucucuuccugugucuggccagagguauagagagagacagguucaacucuaaggccugaaaaggaacaaggcccaccggaagca\n", + "gcgcupcuguggagauccggagucgccacagcuccuaccccgcpacggaggacgacgaap\n", + "uuugccaaggcacgaguaacaagcucacgcaguupcacuuuugaagaucauuuucucagccuccagagg\n", + "acucuuccuguuggaguccugaucggaggagugcpccggapugaupaccaucuagccccuaacc\n", + "pccaguucuuuucgupcacauguuucuuccgucagucguucugacauccuagaaggaguuucaucaaucaccuugaaaccgaccuggacpugaccucguggucgccccaggagaucacag\n", + "gccgcguguucuugccacgagaaccccuagcagccuggccuuggaauggcuggaugaggugcauucguugguucauucagauacuguuaagagccagcugugugcuag\n", + "gugccggaggacaaggugaacccgcagccggacuucugcugcacupcuccgaaugacccagaaucupupcuuaggccccgg\n", + "ggugaacccgcagccggacuucugcugcacupcuccgaaugacccagaaucupupcuuaggccccpuacgap\n", + "ggaggacaaggugaacccgcagccggacuucugcugcacupcuccgaaugacccagaaucupupcuuaggccccpuacgap\n", + "ggcgccugguggccpcccugugccggaggacaaggugaacccgcagccggacuucugcugcacupcuccgaaugacccagaaucupupcuuaggccccgg\n", + "gccugguccucugugccuggupupugccagguguguccagaggagcccauuugguagugaggcaggu\n", + "ggccuccuagcgcuccpaggccgcugcgccccggaguggaucgcgcuggaggcgugcgccpcgagaagccgcggccgcpagcgcagu\n", + "pcaaauucgccgcccggccuccuagcgcuccpaggccgcugcgccccggaguggaucgcgcuggaggcgugcgccpcgagaagccgcggccgcpagcgcagu\n", + "gucaguggcgcuagcggcggacccggcupcaguuccuuccccagaaggagagauuccucugcc\n", + "auccgcucuucuuuuccuccpaaaagaaacpaaguggccgupccggugaauuccguguaguggccaag\n", + "auuguaccaccuacuugaauccagupaagcaugugauugcugacgcccagaauaucaccaucagccaguaugcuugccaugaccaaguggcagucaccauucuuugguccccapcccucg\n", + "gcaucgaauuccugaaaggauuucpuaauacuggaggagcugaagucggapaagacagugccaacaacugauucuaaaggauccgaagcagcucaacaguagcuucaaaagaacu\n", + "acucpcuggccagcggcpcggccpcgcagagaacggccuggcupcgagcgcacggcc\n", + "auuaacccuuccuggaagaauuguagaaaauggaagugagcaapuccuaugaugcagauaaag\n", + "cccucacaccgagaguuccugcgcgupaguuggagaguuugcguggcpaacgcggcggcagugagagcgagcggcgccggcccuugcguccggugcggcg\n", + "aagauugcgcuaucgcacuccagccugaguaacagagcgagacugucuaaaaaaaaaaaaaaaaagaacauacaguuugcuauaccaagg\n", + "aguuggagaguuugcguggcpaacgcggcggcagugagagcgagcggcgccggcccuugcguccggugcggcg\n", + "auaacucagccucuccagagugcagccaccaugaccuccgcagauugaugauggaagaaaagaaaaccaggauauccugugcucuggcuucccuggacc\n", + "uauuaaaauuagacucuauuuccugagcacccacaaauggaccugacaaapaagacacagauguacugcgugaugaggaaagccuaucaggauuaaaauauggcu\n", + "aucuuggauugcgaacupucgcuacgcuucacgccapcggaguggcggcccuucuguuacccgccacacacgucgccgcupacupaaaucapcaucggagagugccacauua\n", + "uuggauugcgaacupucgcuacgcuucacgccapcggaguggcggcccuucuguuacccgccacacacgucgccgcupacupaaaucapcaucggagagugccacauua\n", + "guugugcugagcggcgcucggcgaacuguguggaccgucugcupacuccggcccugcguccgcucagccccguggccccgcgcaccuacugcc\n", + "gcucggcgaacuguguggaccgucugcupacuccggcccugcguccgcucagccccguggccccgcgcaccuacugcc\n", + "aggauuuugaaggcaaaggcucugguuucuccuuccccaugucugaaaaccgcccuuagccugcacaaggugaacaguggaaaucauuggugagga\n", + "acggaguauauugcauggugcugaggucupcuucugauggucccgucguucaaguagcaaacgcgcugcgcgaaag\n", + "gagccaguucuaacuggaccacgcugccaccaccucucuucaguaaaguuguuauuguucugauagaugccuugagagaugauuuuguguuupucaaapugugaaauuu\n", + "acugucgcugcgacgauaaggccuggcguuauugcuuagaggcggcuaccuggagccggaagcgcggcugcagcapcgaggcuccaggupucgguuccgcauccagccuagcguguccacg\n", + "ccuggagccggaagcgcggcugcagcapcgaggcuccaggupucgguuccgcauccagccuagcguguccacg\n", + "gacgauaaggccuggcguuauugcuuagaggcggcuaccuggagccggaagcgcggcugcagcapcgaggcuccaggupucgguuccgcauccagccuagcguguccacg\n", + "gcuuagaggcggcuaccuggagccggaagcgcggcugcagcapcgaggcuccaggupucgguuccgcauccagccuagcguguccacg\n", + "gacaagaaggcuagaaagcucaaugcgucuuccuauuacucugcauaucuuaugucuuccauccaaaaagaaucaacuuaucagauaaauaaccaccucaug\n", + "gupuccccgguuccccagcgagcgcgauggagacuaguggcggcgacggccgcguucugccuggugucggccaccuccguguggacggcpccgagccc\n", + "agcagcgcagguuguccccguuuccccucccccuucccuucuccgguugccuucccpccccuuacacuccacagucccggucccgcc\n", + "ccgaagcagcagcgcagguuguccccguuuccccucccccuucccuucuccgguugccuucccpccccuuacacuccacagucccggucccgcc\n", + "gugacaggagccgaagcagcagcgcagguuguccccguuuccccucccccuucccuucuccgguugccuucccpccccuuacacuccacagucccggucccgcc\n", + "cccuagugacaggagccgaagcagcagcgcagguuguccccguuuccccucccccuucccuucuccgguugccuucccpccccuuacacuccacagucccggucccgcc\n", + "agugacaggagccgaagcagcagcgcagguuguccccguuuccccucccccuucccuucuccgguugccuucccpccccuuacacuccacagucccggucccgcc\n", + "ggaguugugcucugcggcugcgaaaguccagcuucggcgacuaggugugaguaagccaguaucccaggaggagcaaguggcacgucuucgg\n", + "uggagcccpuuaccagcucuugcccgcgcggaauaggcuuuaagaaaucggagcugcagccaucuguuuuucucuuaaugcugcaucucuguucucacggugguccuup\n", + "agcucupagaggagcccccgcccupauucccagguguuuucauuuggugaucagcacugaacacagaagaguc\n", + "ggcagagcuupauauggcuuugugaacuacauugaccccaaggaugcagagaaagcuaucaacacccugaauggauugagacuucaaaccaaaacaauaaaa\n", + "guuuccuaugcucgcccaaguucagcuucuaucagagaugcaaauuuauaugucagcggacuuccaaaaaca\n", + "gcccgapuguuucpcguccgaagcpcgugcuccagccugcucagcagcgagugguuggaaauuagcaaagugagagg\n", + "gugaaaggaagcaggaggaggapaguucuagcgaagacuucggapaagcaacccauccccugccacaagaaagcaccgccacuccagupaacggacacgcgugcacacagccacgagugag\n", + "gagagaauacagcaguuccaaggacaapauucguaccacugcuccucacucaguaaauagcagagacagaauuugaac\n", + "ggucucacucugucaccugagcuagagugcaguggugcgaucacagcuuacugcagcauugaacuccupcucaagugauccucuugccucagccucccaaguaacugugacugcag\n", + "guugaaugccuuugagaacuugaugcauaaaauuugcaugacuccucacuccuuucuggaucucucauuggacucaagccagc\n", + "agacaucucugcguuacccaggcuggucuugaacuccuggacucaagcaguccuucugccuuggcuucccaaagugcuaggauuacag\n", + "gccccgcccuuccccgagcuccpuccgcggcggagcgagcgagcggccggcagguupaggagcggccgaag\n", + "gccugcuaauguguggagucccuuuaaugcugapaaguuugccugagaccuggcuuccugcucgcugaaaaucacaguuauuuuguuucugg\n", + "ggagucccuuuaaugcugapaaguuugccugagaccuggcuuccugcucgcugaaaaucacaguuauuuuguuucupugg\n", + "aauucaagccaggaagaagcagcaaucugucuucuggauuaaaacugaagaucaaccuacuuucaacuuacuaagaaag\n", + "acuuccucauagaccuuggaugupaggauugcauucagucuaguuccugguugccggcugaaauaaccug\n", + "ugucgagauggcuaugaacccuguguaaaugaaggaauguguguuaccuaccacaauggcacaggauacugcaa\n", + "caacauggccaaucuuuccuaagcugcucagcuuacaagaaaaggaaucauacugcuaagaauucaaacuucagcagucauag\n", + "ggagccuupaggaccccgaaucacugauggaauugcgcagugcauggagauggcucagcaggaugagg\n", + "apccguccgcucugcugccgccgcuguugcagccaccgccguugccgccucccugccggcaagugugugaagaagaagcugagcguugucgccgccgcu\n", + "guccgcucugcugccgccgcuguugcagccaccgccguugccgccucccugccggcaagugugugaagaagaagcugagcguugucgccgccgcu\n", + "acaacuccggcggcccaaggagcugcucgguucacccacaaggaaugagagcugccugccugcugcugcuuggagagccccagacagucgcuugaagag\n", + "guguguggaugucuccuagaucuugacuugcuccugaggaaauauugugugacugaguuuccuguuauacugcucuccaauccauc\n", + "gcaccuguucaccgaaguugaggcuggucacaacuccggcggcccaaggagcugcucgguucacccacaaggaaugagagcugccugccugcugcugcuuggagagccccagacagucgcuugaagag\n", + "gcupacccuugaaaacuaucuacguggaaaagugagagaacaapacacaagcaaagcugcccag\n", + "acacpcuggacacgugcugugcucaggaaagaaaguaaauuccaccuggcaaauugcucuaacugauuuauuuguccacaaagagacgccaccuaccugcuugcagguauucag\n", + "caggacacupaaauagccgaguuuugaagaaugucagcapagccaccapaucauccuccccgguaagaagagaccuccagagaccuucaggaagcuggaaagaagcuuccaaug\n", + "auucccagugguagaaguguguggugcaaaggcacuuagguggacagguuuggcccucaacaugaacuugaug\n", + "cgccugcagcagagugaggccaagcacuccuccuggcuccuacagccaggccuccuugcuggccgccag\n", + "aagauuacuugapauggugcguaaauggupccaguuuguauaugagcugcapcaagacaaguagaugaggcuagaauguuaacucapaacagguccuagguaguuuccauggc\n", + "cuucuuugugcucpuuaggaggagcuaggcugccaucpccggugcagauacpuugcucuuuugcucauaagapcuucgcuggcagucugaacg\n", + "gcaacgcgguaaaaauauugcuucggupugacgcgguacagcugcccaapcguucguaacpa\n", + "ggagcuaggcugccaucpccggugcagauacpuugcucuuuugcucauaagapcuucgcuggcagucugaacggcaagcuuga\n", + "uuuuuagaaaaaaaaaauauauuucccuccugcuccuucugcguucacaagcuaaguuguuuaucucggcugcggcpaacugcggacgguggcpcgagcggcuccucugccagag\n", + "cgugcaggcgccgucpccpuggcpcccgcgcggapcgupcapaccgcpcgccccugcaguugccaagcgucaccaacag\n", + "gaucccucuggcuggugugugaagaauuaacuguagaupcaaguguggaaggaaggagagcagucaggaagcugccauaaccaucuacaugagagag\n", + "agcugcagagagacaaggcggcggcggcugcugugcupugcagugaggaagaggcccucgguggugccc\n", + "acguccpapccaggugagcggcagacccggcacgcaggupccggcpuccguggccag\n", + "gcauacucuaccaccucccgcupcccaggccuuccccuuggcacaguuggagcagccucuguuaug\n", + "cucuuucggccggcgccgccaguuccupcacacccagagguccccuucucgccgccgccugcaacugcgapuagcccpccgcuuggagucgcccggaccugagaggcugcugcacugg\n", + "guaucccugcgcgcggcpccpcupcagcuuuauaaacagccguggugugagccucgaapaaccaucagcgccuccuguccacggagcuccaggucuaca\n", + "cacgcuggugucuguccuccuuacagaaugccugaacaguuccauugacucaaagugaagaucaaaagaaccaaaugacagcaauagccaaguguaaucaucaguaacccuguguucuauccacag\n", + "uuaaaagaauauuggcagagaaacagccuugguguuccagcaggagugaagaggaacaggaaaacgaguggcaguagcccugaaacagccacuucuggugguugccacucaccugaggau\n", + "gauuuuaagcuugacuuuggcaauucccaaggcaaaacaagucaaacuuggcauggapauagccaccauuuuucagaguccuggcgaugaagugupaguaguauggaaa\n", + "ccuuugcccgcuucuguggacuguucgaacgcccapupccaaacccguuucuuaggaaaccaggaauccapaaggcag\n", + "ggagaagagauuggcggapaaagacugagucgucuuuccuuugcccgcuucuguggacuguucgaacgcccapupccaaacccguuucuuaggaaaccaggaauccapaaggcag\n", + "agagguggcaucucacuacguggccuaggcugaucucccucuccuggacucacaugauccucccaccuuggcccuucaacgugcugagaucgcaggugugagccaccacacccggcccug\n", + "auaaaacucaucagugcuuugaaacaagcagcucugaaccaaagaaaucauuugauucaaguaaccauuggaucuucccaaggca\n", + "pacgccgagagcccggcaacaccucagcccgagcccggcgaggucucupcuccuggagcgag\n", + "pucupacgccgagagcccggcaacaccucagcccgagcccggcgaggucucupcuccuggagcgag\n", + "cagauaaaacucaucagugcuuugaaacaagcagcucugaaccaaagaaaucauuugauucaaguaaccauuggaucuucccaaggca\n", + "acuucugcaauugccagacagcauagaggcugaggcupccaggacccagacagagacacacggucacugcagcugaagccgcugccccugcuacag\n", + "acagcauagaggcugaggcupccaggacccagacagagacacacggucacugcagcugaagccgcugccccugcuacag\n", + "ucuugguugcucucaccaugugauacaccagcuccaccuuugccuucugcugugacuguaaguuuccugaggccucuccagaagcagauucuagcaccaugcugcucgcacagccuucaaaacu\n", + "cuuucugguaaauuuagagaaggcaucauacupaucuuuuuucacauccagcccaugcggacugagcagccaaagcuugacagag\n", + "agcgaccucuuccugaucpagcuguuuaaaaggapagugcgccguauuuucuacuagcguggaggaacggaggaagaauccauucacacuccccaaaccag\n", + "guaaaaguaaagaagcagaaauaaaaaggauaaacaaggaacuggcaaauaucagaucaaaauuuaaag\n", + "gugacaaggcucuugauggcuauaguaaaaaaaaguacgucugcaaguugcucuucaucuuucuccuuggucaugacauugacuuuggacac\n", + "gugguuaggcggcuccccggcggcuccuccgcggcggugacggcgaccgcacuccccgcuucccgcuccccgcgcuccuccgcccpuccgccagccgaggccgcucccgagcgucggaag\n", + "guggcauguauuucucaguggaauuuuaaauagaauggugacucggcauuuauuccuugucugaaguaagcaaguaggaaggaccuuguuccccauucaapaaugaacggugug\n", + "cpuugaauuuuucuugccaagguugguggucacugcuucupacacccugguucucuucacaguguuuuccgucuggcuccucugaag\n", + "accgcacuccccgcuucccgcuccccgcgcuccuccgcccpuccgccagccgaggccgcucccgagcgucggaag\n", + "acuuugugcuugguggcugguggcuguccacccauguguaccagugccugccaaccugaapcuuuggcapccuucgcugcapugaggucugaggaggagccuga\n", + "gcgcccupccugccupucuggaucuguguccgagucupucuggaucupuccgagucupucuggcccugcgcucapcccgcggaggagacu\n", + "gucuuuagcucucauggauupagcupaaaggaaugagaagacagaagucagagacaagaagaggcuaacaugacugauaccacuauaauuuagu\n", + "ggaucagugucuuucaaugaugugacuguggacuucacucaggaggaguggcagcaccuggaucaugcucagaagacucuauau\n", + "gcagucuuuagcucucauggauupagcupaaaggaaugagaagacagaagucagagacaagaagaggcuaacaugacugauaccacuauaauuuagu\n", + "gaacugccucuuuucuaaagaggacuccaaaggaaggacuggucaucucuuucauaucucaaaacc\n", + "ucuuuagcucucauggauupagcupaaaggaaugagaagacagaagucagagacaagaagaggcuaacaugacugauaccacuauaauuuagu\n", + "ggaaguccguagugucucauugcagauaauuuuuagcuuapccugguggcuaggucgguucucuccuuuccagucggagaccucugccgcaaac\n", + "gacggagapccaccgcccagcaauagacggugccucagccugccgagccgcaguuuccguggugugagugaguccpcccguguccccucucccgccgccgcc\n", + "aguagaaacpuuucaccacguuagccaggauggucuggaucuccugaccucgugaucugcccgccuccgccuuccaaagugcupauuacap\n", + "gcgccuccuccgcccgccgcccpagccgcagccgccgccgccacugccacucccgcucucucagcgccgccgucgccaccgccaccgccaccgccacuaccaccgucugagucugcagucccgag\n", + "gccacucccgcucucucagcgccgccgucgccaccgccaccgccaccgccacuaccaccgucugagucugcagucccgag\n", + "gcucucucagcgccgccgucgccaccgccaccgccaccgccacuaccaccgucugagucugcagucccgag\n", + "gacgccauacuggacgccaagupaggaacuucaaggcuguccccugcpccucccgcucugcuucugcgaag\n", + "ccuuuccgcucccapcguupaacgguuguaggacguggcucuuuauucgugaguuuuccauuuaccuccgcugaaccuagagcuucagacgcccu\n", + "ccugagcucucugccugcccagacuagcugcaccuccucauucccugcgcccccuuccucuccggaagcccccagg\n", + "ucucccgagcggcgcccgccucccgccggugcccgcgccpccguppcagcaugcccgcgcgcgcugccugaggacgccgcggcccccgcccccgcc\n", + "ggccpcggcccpapugccccgcugcccugccccaccagugccauuggaapccagccugagccuccpacgapucp\n", + "gucugaauuccacuugcugcucuuucacugaucagcguuggauaaaucgagccuuagcuuuuuuuuuuuucuuuuuuuuuuuugcuggcuccccacccacuag\n", + "gaccucccagucucucauucucguccuuggauuggccgcgagacauuuauccacucuccuuaggccugcgcgaugcaagacpagaaaaggapcguacgcpcaag\n", + "uggccccaggcugcccacugucugcucaggcuuccaaagcuacaaccugccagccuaugcuccauaccugcccugcgag\n", + "gaccucccagucucucauucucguccuuggauuggccgcgagacauuuauccacucuccuuaggccugcgcg\n", + "gaggagccgaagccgagccagagccgcupagcgagcccggagcccagccpcggcucgaaguggccapccggaagguccgcppcgagcgcpucpccgucccggacccacc\n", + "agagccgcupagcgagcccggagcccagccpcggcucgaaguggccapccggaagguccgcppcgagcgcpucpccgucccggacccacc\n", + "aggagapacuupcugaguagupaagaaggaauaggagcgaupcugccggucagauucugaagaaccuugcag\n", + "agccucguguaacaauacuugugcccuggcugcagucugcpccgcgcccupccugccgcauucggccaacgcacagcaucugaggapuu\n", + "ggcgccugcggcggcgacagcggcagcugcggcgcgaccaggccpcaccuccgagcgcaaggacagcgcgagguccgcgcagcccagcgcagccau\n", + "ggcgacagcggcagcugcggcgcgaccaggccpcaccuccgagcgcaaggacagcgcgagguccgcgcagcccagcgcagccau\n", + "gucugcgcpcggccauuggcggcggagugucacgugaccgcpcgugccaaugugcgcccucacpugucaaaccccugucagagugugcgaucaagaucgugaaacaacgcg\n", + "gcuacgugugccgccuggccauucaaacugucaauuuuagguccagaaguguccaaaccacaaguucucaaaacucucugaaaaauggcucccuccgaguuaag\n", + "agcgccuggacaccggaaaaggcgauucccugagcgccuggaguuggagacaauuccugguucagaauuuaaacaucuuucuag\n", + "ucucacuagccucagagcacucucagaaguucagaaacuaagaccagaaaagagaagauuuuuagacagcucaugaaacg\n", + "uccauuugacucuuuugcaggcuacgugugccgccuggccauucaaacugucaauuuuagguccagaaguguccaaaccacaaguucucaaaacucucugaaaaauggcucccuccgaguuaag\n", + "aucauuuuucuucuccggccccauggaggaagugagaaaguuggcacagucacgccpcuucgcaggaccaggucacucagugacag\n", + "uuuuucuucuccggccccauggaggaagugagaaaguuggcacagucacgccpcuucgcaggaccaggucacucagugacag\n", + "ggagagaaaggaaagcgcgaggagccgccgccaccaccagcgcagcaguccuggagcugugaggagauucpccgucacccugccuccccugcgucccgccaccggccgcuucuguccucg\n", + "accaccagcgcagcaguccuggagcugugaggagauucpccgucacccugccuccccugcgucccgccaccggccgcuucuguccucg\n", + "gccgccgccaccaccagcgcagcaguccuggagcugugaggagauucpccgucacccugccuccccugcgucccgccaccggccgcuucuguccucg\n", + "agagaaaggaaagcgcgaggagccgccgccaccaccagcgcagcaguccuggagcugugaggagauucpccgucacccugccuccccugcgucccgccaccggccgcuucuguccucg\n", + "uuuuucuaaggcucccgcacucgcgucugaaaccagaaacpaguggcuugcggagcaggaaugccgcagccgugccgccaaguucggapagaagaagcag\n", + "gagagaaaggaaagcgcgaggagccgccgccaccaccagcgcagcaguccuggagcugugaggagauucpccgucacccugccuccccugcgucccgccaccggccgcuucuguccucg\n", + "cuccgcaguupaggapcpaagcaguuugapaaugucugagaggcgcugccccccagagcaccpapuaaaugacacag\n", + "gaggaucccuuuucccccagaaauuacucaaugcugaaaccucucaaagugguauuagagacgcugaaagcacc\n", + "uuugcpcappagaucggaapcguccggccacugguccgacaggcccagccggcuagaguucacpcugauucagaaucuucaaagucp\n", + "cuggcuucaggagcugaauacccucccaggcacacacaggupacacaaauaapuuuuggaaccacuauuuucucaucacgacagcaacuuaaa\n", + "gcgguaucugcaucpccucacuggcuucaggagcugaauacccucccaggcacacacaggupacacaaauaapuuuuggaaccacuauuuucucaucacgacagcaacuuaaa\n", + "cpccucacuggcuucaggagcugaauacccucccaggcacacacaggupacacaaauaapuuuuggaaccacuauuuucucaucacgacagcaacuuaaa\n", + "ugacaagugagccugcuucugucaauuacugaagcuauaaggagauuuuuuaaaaauuaaacuucaacaca\n", + "aaacaucacagaaaauucuuugauuuaucuuaauagugacaagugagccugcuucugucaauuacugaagcuauaaggagauuuuuuaaaaauuaaacuucaacaca\n", + "aaacaucacagaaaauucuuugauuuaucuuaauagugacaagugagccugcuucugucaauuacugaagcuauaaggagauuuuuuaaaaauuaaacuucaacacaaugag\n", + "gaaaaagccuuccacccuccugucuggcuuuagaaggacccugagccccaggcgccagccacaggacucugcugcagappuuguguacagauaguapcuuuaccgccuagcuucgaa\n", + "gcpcggcgcgagcgapcagaggcgagagacgccggcpcgcpcgcggcggccccggaggaugcugcugagccccggcacugccuggcugcgagcac\n", + "agaggcgagagacgccggcpcgcpcgcggcggccccggaggaugcugcugagccccggcacugccuggcugcgagcac\n", + "ggcgcgagcgapcagaggcgagagacgccggcpcgcpcgcggcggccccggaggaugcugcugagccccggcacugccuggcugcgagcac\n", + "gauccugguugccaacaaccagcucuucagcagcuccuaugaccggacagcucpucuggaguguggacaapcag\n", + "gcgccggaacugcccuaauggaaaccagccgccpcgcuccpapcucaggccgaccccpuccauuagaggcgccccaggccgapagcccgcggcggcuggaag\n", + "gacccagcuguggacugugccpcpacggapcaggagcccupcuccccguggcpcuguauc\n", + "ggucagcugcguccggcggaggcagcugcugacccagcuguggacugugccpcpacggapcaggagcccupcuccccguggcpcuguauc\n", + "ucagcugcguccggcggaggcagcugcugacccagcuguggacugugccpcpacggapcaggagcccupcuccccguggcpcuguauc\n", + "gcagugaagcupcgccuucpcuugagcuucugapucpuccagcgcgupcugcugg\n", + "gagaaagcggaagauggcggcggcggccpaggccgugaggagagcggcggcugcgapcggccgauggcggccpaggcgcccucggacacuugcpucguuapcgcgacgcupaggc\n", + "ggaagauggcggcggcggccpaggccgugaggagagcggcggcugcgapcggccgauggcggccpaggcgcccucggacacuugcpucguuapcgcgacgcupaggc\n", + "pcgugguucgagagcgcgcagaguccagacuggcggcapcccgapccgacccgcagcgucccuggucucuccagcccucacucggaaccgcac\n", + "agaaaaaguuuucuuuucuggagucccaaacgaggugcpacggaagapugaaggccagaggcucpcuucaagaccgcugucuggagucccccuuuccaggcc\n", + "guuuucuuuucuggagucccaaacgaggugcpacggaagapugaaggccagaggcucpcuucaagaccgcugucuggagucccccuuuccaggcc\n", + "ccuuagguuuucccagcaccacaugugucaacaaaucuuacpauugcauucuucucauacaucauuugugcauuaacaggaaaaaagucucacuugug\n", + "gucauuuuuuccugcuccucuugaagaguccuguacaaaucccucuucuucugaguaaaagaaauguagacuaccaggcaucaacccaucapaaaguugaauagagaagauuccaaggau\n", + "caggccauuugcaucccacuguccuuguguucggagccaggccacaccguccucagcagugucauguguuaaaaacgccaagcugaauauauc\n", + "aagcacpcpacguccacpaagcggcgcgcacgcccgccgacucccucgcgccaaccgccgacggccgccgcccggugaaggapcucaguccucccag\n", + "acgcccggacgugcccucuccgcgcpacucgccuaggucuccuacgucugccccugcccggcucccggcggccccagcugucaccg\n", + "aaucacguggcugccacccagguaagaagaggccgcucuuccupuuguuucuccgugugacguguggccuuugagaucaacucuccuguaccagcguaggccgc\n", + "guaagaagaggccgcucuuccupuuguuucuccgugugacguguggccuuugagaucaacucuccuguaccagcguaggccgc\n", + "cuuccupuuguuucuccgugugacguguggccuuugagaucaacucuccuguaccagcguaggccgcaugaguppcpcucccgcgguccugcucggcggagug\n", + "ccaugauapucpauuggcuggcucuggaggcgcaggugguccuucuucuacugucacauggugcgcgcuguuuucuaaucacguggcugccacccag\n", + "guuucuccgugugacguguggccuuugagaucaacucuccuguaccagcguaggccgcaugaguppcpcucccgcgguccugcucggcggagug\n", + "ccagcuccccuaguccaggccgagcuugcacuugcgucuugucugcugcugcugaaccaagauuuagcugugcgcccuccuugcagucuccuggaaccagcaggaggaaac\n", + "ggcacpcggucagcupccgcagcuccuccggcucugcapucacggaggaagguaaguaag\n", + "gccauuucuapuuggaccgugcaggcacpcggucagcupccgcagcuccuccggcucugcapucacggaggaag\n", + "auuucuapuuggaccgugcaggcacpcggucagcupccgcagcuccuccggcucugcapucacggaggaag\n", + "gucauagugaugccguauccacugagacuccggauccuaacagcuggaagcuaaaaacaggcgcc\n", + "acgugcguggcaacaagugacugagaccuagaaauccaagcguuggagguccugaggccagccuaagucgcuucaaa\n", + "gaguuccggcgaggcuucapuacagcucccccgcagccagaagccpccugcagcgccucagcaccgcuccpacaccccacccgcuucccaggcgugaccugucaacag\n", + "cguggauuucuguggagaguggaaacacpagucgapagcaugcgcpccucagaaaguucupaaaccgacucccpagcapaggaacgcgcgcuccagaga\n", + "cauuuugauuauuacucucagacgugcguggcaacaagugacugagaccuagaaauccaagcguuggagguccugaggccagccuaagucgcuucaaa\n", + "cgaggcuucapuacagcucccccgcagccagaagccpccugcagcgccucagcaccgcuccpacaccccacccgcuucccaggcgugaccugucaacag\n", + "guacagcucccccgcagccagaagccpccugcagcgccucagcaccgcuccpacaccccacccgcuucccaggcgugaccugucaacag\n", + "cgaguuccggcgaggcuucapuacagcucccccgcagccagaagccpccugcagcgccucagcaccgcuccpacaccccacccgcuucccaggcgugaccugucaacag\n", + "guuuuauucuagguagucacuuaaaaacgaaccucgguacuggucugacuuaacauggaggaggaauugucuaag\n", + "gccupcggcuccgcuagcuguuuuucgucuucccuaggcuauuucugccpcgcuccgcgaag\n", + "ggcpcucapcagcgcggagccgcuagcgucucccggcgcggcugcccgaggccggcgaagccaupcgccpaccccgccgccgccgccgccgccgccgucuggccccag\n", + "guugaccpugcggagcuccupcugcagcuccuggaguuuccgagguucgugcgcgucugguggcggcggcgug\n", + "ggaaguugaccpugcggagcuccupcugcagcuccuggaguuuccgagguucgugcgcgucugguggcggcggcgug\n", + "gcucacgugacgcggucccggaaguugaccpugcggagcuccupcugcagcuccuggaguuuccgagguucgugcgcgucugguggcggcggcgug\n", + "gacgcggucccggaaguugaccpugcggagcuccupcugcagcuccuggaguuuccgagguucgugcgcgucugguggcggcggcgug\n", + "cuuccaggcuaaguccaucuuccggcuupcagacgcugccgcggaauccuugacucuaguuuucugagucg\n", + "cagccgcgcugcgcgcaccgcpcuccpcucagaagugcggacgcccggcucccggcguggacgcc\n", + "cuggccgccuguuuuuuuugcagccgcgcugcgcgcaccgcpcuccpcucagaagugcggacgcccggcucccggcguggacgcc\n", + "ggucucagguuugaggugguccccuccaaguuuaaagagaagcuggacaaagccuccuucgcuacuccguaupuacgcc\n", + "auauuugagcuaaauuuacaugauaaggaguuagcuaggcaaagaagaggaauuaggauauuccaaauugguggugcagaugccucacauauccaaaag\n", + "acucpaggcagcggcgacuuupaaaguugaucggagapaggaagccucaagacgcggagcagcggcaggaaggagcccccggcagcccggaggagc\n", + "paaaguugaucggagapaggaagccucaagacgcggagcagcggcaggaaggagcccccggcagcccggaggagc\n", + "acauucuguguuuguuccccugagguaucaaugaacgcuagaguucucucauagccaugagacacaagagaauugguuuagaaccagaagagccgauguaaauucccugu\n", + "cauaggcacugagugcggucugugcaccccuuugccacccaccggugccggcacugagccugcaaccugucucacgcccucuggcuguugcc\n", + "aggcauggcugcccuuuuagcgugucccagccugccaagapagugcccuggagagacccuugcucaggagcacugccapaucagugccccauuuguaccugcaag\n", + "acucugcuccugcgaccuagccaggcgugapagugacagcagcgcauucgcpacgagagcg\n", + "aacucgcugugguugcuccccpucuggucccgcgcggacgupcggccaucaggacugcccpuuggcgcccugcupuuccaagccg\n", + "aggacagcuuggagauapcccggaauugcpcgucacucugcuccugcgaccuagccaggcgugapagugacagcagcgcauucgcpacgagagcg\n", + "gcucagugucugcguaaggauccupcaaacaaccacuuggagagccaapugagagguacagcuggcg\n", + "cuguggucgccaggacccccccagagccaagaccuucuccagaaggugacccuucccccccaccaccacca\n", + "acagaaguaaaucugcuucuccugccugcccuccuucccagccucucupccccaaucucccacuagagaaugag\n", + "cacaauugacagccucaagguuccuggcuuuuugaaccaccacagacaucuccuuucccggcuaccccacccugagcgccagacacc\n", + "ucacaaaaccucuauggauccgcgguagcgagacgugaapuugauuuguggagupaguugcuggcccauugcggugcccpacucauuaaacugucacucaccccccaccccacugg\n", + "agucugcuuuuuuuccaccgauguaacagaccuggagccagcaggacucagaggaaaggacuuaaucagguuuauguguccuaaag\n", + "guaagaguuapuuugaccggagcuagugaggauccagcccaggcuccaguuguccgcgguuccuccuccugucgcugcccgugugauuacugagacucag\n", + "uuauggaggcugagaaguccaaggucaapccacaccuggugugagcuuucuupcugcaucugguggaagccuucuugcug\n", + "ccaacuguccuuuguaaucugcuccaccuuuuuuggapcacaguggaauuupaggagaggagaaaacuaacuauaccucguauuuugcuccaaugag\n", + "acacuucccccagagaagccuccgagcgcggccgccauuccpccucaagcccauaaagaaaaaauaccggagagguucuggcaccauuucpugccaaagcagcc\n", + "cacuucccccagagaagccuccgagcgcggccgccauuccpccucaagcccauaaagaaaaaauaccggagagguucuggcaccauuucpugccaaagcagcc\n", + "cccccagagaagccuccgagcgcggccgccauuccpccucaagcccauaaagaaaaaauaccggagagguucuggcaccauuucpugccaaagcagcc\n", + "gccucaagcccauaaagaaaaaauaccggagagguucuggcaccauuucpugccaaagcagcc\n", + "ggaaaacaacaaagcacagaauucgcccuaugagacuuagapaggaugcucacagcaaaggacaucaacg\n", + "aagcucggugcacggcgcgcugauuggcuggauccgccaugcggagcggcuagguggugcacpaaacgcpc\n", + "agugcggcgcagccucugagcaucpcaccucccapcuucggcuucccugcuucacacaugugguucacuguugcpuucguggaguuaug\n", + "augcggagcggcuagguggugcacpaaacgcpcguaggugaccggcggcuuucucaguuuugguggagacpcgc\n", + "cccgucccgcupcccucagugcggcgcagccucugagcaucpcaccucccapcuucggcuucccugcuucacacaugugguucacuguugcp\n", + "agcggcuagguggugcacpaaacgcpcguaggugaccggcggcuuucucaguuuugguggagacpcgc\n", + "gagccauguaacccugcggcpcuccpcugcuccguccuuccccagcucccpcuagcgcggcagcpccacg\n", + "uccaggaagcaucauucccagagcugccagagcaguggcccuggaaaauauggaagcagcugucagccauggcccapccugagcguaugauucucaggaaaagupcaggacaucugacugucag\n", + "ugcupcugcpcugcpcugcpucpaggccpccpccpccpccccgcugaccgcc\n", + "agcggcggcggcggcgcggcuacugcupcugcupcugcpcugcpcugcpucpaggccpccpccpccpccccgcugaccgcc\n", + "ggaggcuccccaugucugcaaacucpuccuapcguuggugucagcpcaacagcccacaggagugugcaccuccuaggacag\n", + "auuguuugugccuggcuuccuggugcuagcaucaggaauguggacccacauucccugagcapcuuagg\n", + "cggagapcugguucgcucugcggccpccccucccccgcccpagcuuggcgguuccgacaccgcg\n", + "cucagcuucccggcccagcupcacccacuggaaggagaggccaggcggaagacccuggcuccguc\n", + "cuguuucucagcuucccggcccagcupcacccacuggaaggagaggccaggcggaagacccuggcuccguc\n", + "gcaaauaaagaacgcaggagccuugucuccuacupcugucagugaggaaaaggaggaaagacagguuagcup\n", + "ggcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "pcgcccgaguggcuucgcgcgagccucpaggcucccpcggcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "ggcuucgcgcgagccucpaggcucccpcggcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "guggucggcccgagcggacccucgcggcggccauggcgucggugguggaauacaapccucapccggcuaccacugcggcuacugcgauuccaaggapcaaagcguccugcg\n", + "ggcucccpcggcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "auugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "augcauuugccaauauagaauguagacucuauuauuuuaauagaacagucuagcuuuguggaaaacgagauucgcaugaaaacacacaggcauuuuccaugaaaaag\n", + "pcggcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "cgcuucgccgaggucggccccpcgccaagaggcguggucggcccgagcggacccucgcggcggcc\n", + "gcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "uugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "cggcgcgcugcauugupuggcggcggcggccgcgcuagcgacgcpccpcggcugagcguucgcpccgaggcc\n", + "cpuccccgcgccaggcuucgcucuccaccccucccgccgcpccccagcgcuucgccgaggucggccccpcgccaagaggcguggucggcccgagcggacccucgcggcggcc\n", + "agagaapcucccpcccuccccapaacuggcccupcccagaccagauggaggaccccgaaaagaacapcag\n", + "guuugguugguggccuccagucucuuguccucaacgapuuuuggcagcucccucucaguggccu\n", + "cuccgcucugcaccgaapaupuccgacccagccuggcaucaucacagccucgaguggcguccagccugccccgcuccaccaguggcugcuggagaagaacccgagccugg\n", + "agccuupagcagucccuuuucuaggagccucuugaaggacucaccguagaugcaggaagacauuggaugaggucagcauagcugaagugaggugucupuuagaca\n", + "agcugcauccuguggcccuauaacacucuucuccaaaaggaccugccagagacupaguguugacugcugcaaggaccaag\n", + "uuuugcaggcaacuuugapaagagaagaaacuucgaguugaaaaugcuaaacugaagaaagaaauugaagaacugaaacaagagcuaauucaggcagaaauucaaaauggag\n", + "acuuucuccuacugcucaapuguuacacuuugacgacugacuaaaccucgapccagaaacaaaccaaagcaaaauucugccuccaag\n", + "ccgaggcuggacuguacugccaccaucuugacucacugcaaccucccugccugauucuccugccucagucugccgaguuccupauugcag\n", + "gguccuccgcuucaugugagugacgucguggcpucacucacucpaucgccgauugcgauc\n", + "ccpauupapcuucuugcaggcugcupcupcuaapcugcucaguuuccuucagcpcacupaagcgcc\n", + "agcacgacucapcggapaaguagguccguuggucggucpaacgaggcucaggcggccaggcccgcgcggagccguugcc\n", + "agcucgcugacagcacgacucapcggapaaguagguccguuggucggucpaacgaggcucaggcggccaggcccgcgcggagccguugcc\n", + "cacgacucapcggapaaguagguccguuggucggucpaacgaggcucaggcggccaggcccgcgcggagccguugcc\n", + "aagucgagaggcggugcacacccgucgcgcaugcgcaaacacagcugucggaagguggcgagccugaggcgaaca\n", + "ccucucuccauuucucugaaaaugaacuacacaguuupugaguuggcapcugcuuccuga\n", + "ggacgcggcagcgcagcggcuccuuuaaggcucpcaccacccccgccgccccgccucccgugcggccupucuaguuggcggcpucpuccgcgcgagccgcg\n", + "ccacccccgccgccccgccucccgugcggccupucuaguuggcggcpucpuccgcgcgagccgcg\n", + "cgcagcpcggcguggacgcggcagcgcagcggcuccuuuaaggcucpcaccacccccgccgccccgccucccgugcggccupucuaguuggcggcpucpuccgcgcgagccgcg\n", + "agucccgccgccgcccgcugcguccgcccagcgccagcuccgcgucccgaccggcccgcggcagccugcgccgcgcc\n", + "agacuccggcccagcuccugcgaucuccacagcagccucugaggccgcccccagagagcaucagg\n", + "pagaagcgagcggacauccagcugaacagcuucgguuucuacaccaauggcucucuggagguggaguugagcguccugcggcupccuccpaggcagaagagaagucccugcug\n", + "acccpauuuccaggacugcccucuccagaaaaacaguagcaguuuccugguccuguuccucaucaacaccaaggaucugca\n", + "gguccaggugcggaaguauggagagcagaagacguuguuuaucuuucccpcuccucccggaagcacccuccaaaccapcucccgaagccacaggccacagucccccgcaagguggauggcg\n", + "gguccuagupaaggacaaggaccugguguupccugagccaccucaacaacuccuacaacuucagu\n", + "uuccacguggugaucggcucucaggcggaagaaggccaguacagccugaacuuccacaacugcaacaauucagugccaggaaaggagcauccauucgacaucacg\n", + "agcgugcacagcccaggaguguugagcaauuucgguuuccucugagguugaaggacccaggcgugucagcccugcuccagacaccuupc\n", + "cgugcacagcccaggaguguugagcaauuucgguuuccucugagguugaaggacccaggcgugucagcccugcuccagacaccuupc\n", + "gagucuccccpapcggcpcggcpcggcpaccpugcggugguggcugcggcggcggcggcpagcagc\n", + "gaucaguucgaggugcucgagcgccacacgcagupcuggaccuguuggacagauauguaaaguucgugaaagaacgcaccgaaguggaacaggcuuacgccaaacaacugcg\n", + "auucagccagcaacaguccuucguacagauucuccaggaggugaaugacuuugcaggccagcpagcugguggcugagaaccucaguguccguguaugucuugagcugaccaaguacucacaagag\n", + "augcgcguugcgcgccggacgcggaacgucugccgguguccccgcgcugcuggucccpucccugaaccgcg\n", + "ccpucccugaaccgcgguaapcgguggugcpcguccgaaupcguuuucuagauacpcgcggacuagaggcucgcupcccggagaccggcggacuggagucpaaccggag\n", + "auuagcuuugaaguuuaaauccaauggagaagacucaagaaacaguccaaagaauucuucuagaacccuauaaauacuuacuucaguuaccag\n", + "gcuggaaggcuggagagcaguagugugaucauggcucacugcaaccgugaacuccupcucaagcgauccucccaccucagccuacaugccuggagcupaugacaggcacag\n", + "guaaacaagugagaaccaaacuuucacaggcauuuaaucauuggcugaaaguuccagaggacaagcuacag\n", + "uccucuccuauuaugcaaacccacaccauggauccagcagacuacucuggccccagcaugcugcuccuupaugaupagaapaaaccuguguuuucucuugguuuu\n", + "guuuucacauccuuucuaugaguuucgccaucuauagcuuuuaucaacaauugugguuuaaucaauuagaaauauuaaccaggagaaa\n", + "ucuagguuuucacauccuuucuaugaguuucgccaucuauagcuuuuaucaacaauugugguuuaaucaauuagaaauauuaaccaggagaaa\n", + "pacgugcgcgcaugcgcgcuaggacuccgcuccgccuacgcugcaggcggagagcaaccgccaagcuuggupagucaag\n", + "agacagaguuucucucuggcgcccagccuggaguauagugccacaaucaugguucacugcagccuugaccuccupcucaagcaacccuccugccucugccgccugaguagcupacugacuauag\n", + "aggcagaaapcgguagguggccpccccgcugccucucgcgccucccpcccgccacacacggugccaacpacgccgcggucggccgcaugagcgcaaaagcapcagcgag\n", + "cccccgccgguggaupagugaaggacggaagaggcccugcggaggcggcggugcagcgcuccg\n", + "aaaucgagcuauagcagauuaucuucguucaaauggcuaugaagaggcauauucaguuuuuaaaaaggaagcugaauuagaugug\n", + "aaugaagaauuagauaaaaaguaugcuggucuuuuggaaaaaaaauggacaucuguuauuagauuacaaaagaag\n", + "ggaucgcccuccucccucggugacuuagcaagaaaaguauucuupuuggaapcgupaccag\n", + "cguauauaaaauguauuaucugacgugucaagugaguuaaugcauuuaaagagccuaggaaugguaccuagaacaua\n", + "aauuccaacgugcaucaagacggaaaaccaccguguaacuccuugcuucucaaaaugucccaggacaaaggccccag\n", + "agcgcagcccgcagaagcccggucagcgcacgugcccgcgagaccugcaaacuugugccaccggcucugcccguccccpagcccgaacgccccgcagcccucaccccucccgccagucuccagcc\n", + "gaaagagagagagagagagagaucgagauugagaucuuaagaaagagagcaaggaggaagagcccg\n", + "gcucagguggcgccuccucggccaccucugcgacgaagccpacgcuggaggupapcgcggcgcagguguccggaacgcccag\n", + "agacacucugcaucaucugguucuccuuugaauucuuggugagguucuuugccugucccagcaaagccggcuucuucaccaacauc\n", + "pacugcagagccggcucccggcuggccgcccgcaccccgccgccgcccgcugccpuucugccggcgcuggccguaaccuaggaacauggaggccccggugcccauccggaagg\n", + "ggacugcagagccggcucccggcuggccgcccgcaccccgccgccgcccgcugccpuucugccggcgcuggccguaaccuaggaacauggaggccccggugcccauccggaagg\n", + "ggcacauagaagagugagccaucaucugguuuccagcgccaagacuucugcaggagagccuccgcupcuuucaaguug\n", + "agaaggacacpcagcagacaguggucaguccuuucuuggcucugcugacacucgagcccacauuccgucaccugcucagaauc\n", + "pcugcaccauaucaugguucccacuagcaauauaugagaguuccaguugcuccacaaccucgccaacauaugacagg\n", + "ugcugcaagaggaugguuauuuaacgcuggcccccaaggaggaaggcacagaccuuccuccuccuggaacauccaapcacuggauccucugugucccucugag\n", + "accauccgagccauccupaggcucagccuccaccacccaugupcaccuucugcauuaccuacaauagccagccugagaggagcagcaagcccucugcaggcccucpacac\n", + "gugacpaagcggcggcugcpucpccagcccaggagccgcpccggagcpcggcpccccaggccgcpcggcgcpacggcpcgccggcgccg\n", + "guuugcuuccugcuccugguuagcacugcupagauccugcuauuuuucgaacauaaagcagucuaagaagguuuauauagugguguaguggaaggagcagugacauagg\n", + "agaggcuggcgcaaacagaagugcagcgguggcggcggcugguugcpccggcggcpcuggcggag\n", + "aauuggagaaagaaauugaagaacucagaucaaaaccuguuacugaaggaacuggugauauuauuaag\n", + "gcauuaacugaacgucuggaugcucuucuucuggaaaaagcagagacugagcaacagugucuuucucugaaaaaggaaaauauaaaa\n", + "gucaucuuuaacaguguggagaaguucuacaucccuggapacgucacaugucauuauaccuucacccagcauuucaucccucgucgaaaggauuggauuggcaucuuuaga\n", + "aapaagaaccuccpuuaggcguauucuagauugacgccuuuugcuggaagagcgcugcupuuaggauucugcgcggcgaggcaag\n", + "guauucuagauugacgccuuuugcuggaagagcgcugcupuuaggauucugcgcggcgaggcaag\n", + "auuguaagugccuggaggccpaccupcuucuguggccuccagccugcgacucccaggcagcuu\n", + "agaaaccuauguagaacaagaacapagaaaaugcuaaugacaggaaugauagagcgauucgaguagcagcaaaaugguacaaugaacauuugaaaaaa\n", + "ugagcuacugapcccgcaccgguccgcupcacggcguggupaagacccggugucgcgccupaccugagcpcaggcccaggcugaagucuauggaggugcpucggcgaccagg\n", + "uccaggcuguaaaacggaaagguucggaauuugccucugcgccgucuuuuuuugccuguuaccugugacguccuug\n", + "aaaaugaaaagcuuucuuaagacaauaggacpccpcgcgguggcucaugccuguaauccuaacacucupaggccgagguuggcggaucacgag\n", + "acccgaccccuccaggcuguaaaacggaaagguucggaauuugccucugcgccgucuuuuuuugccuguuaccugugacguccuug\n", + "cuuuuuuucuauucuuguuuuagaaaaugaaaagcuuucuuaagacaauaggacpccpcgcgguggcucaugccuguaauccuaacacucupaggccgagguuggcggaucacgag\n", + "gcpcpcpcgaagcupcucpccaagcgaggucuagccggagcgacugugccccgccuccupcggagcpcggcucccc\n", + "agccgcaggaauaugcuggaaggcggcpcpcgcccgcgaggugcugaaaggacaguucccgccgccgaacuuagcccgcpupcggcccpagccagcpcacgugagcg\n", + "ggcucugcagupcgccggcucccupcupapcuccupcpupapuppccpupupcagg\n", + "cpcagagccupcpcgcggcaccgcagcuggauggcupccgcccggaucgccgccgccgccgccgcacg\n", + "pacauuggucucauguccuaggaagaagcguggauggucuugcccuggcucaucugcucaguuuccccac\n", + "agagccupcpcgcggcaccgcagcuggauggcupccgcccggaucgccgccgccgccgccgcacg\n", + "auaaagcuguacaccaagcaupacuuugaaauaccagacagacugugccccuaauaaugguuacuuuaugaucccuuuguaugauaag\n", + "agccgacgaccguggagcuccauguggauggagucagugacaucugcacaaapupacaucaacuuugucuucacupuucucuguga\n", + "gcggcgugcagugugapcpacccggcugccggcggupucuagcupaggucpcc\n", + "gagccugcggcgugcagugugapcpacccggcugccggcggupucuagcupaggucpcc\n", + "aggacaaccaaaacugcucugcucuuccgaaaauugcagucapaaccupacccggcaagccagcagaagg\n", + "aaccaaaacugcucugcucuuccgaaaauugcagucapaaccupacccggcaagccagcagaagg\n", + "gaacaggacaaccaaaacugcucugcucuuccgaaaauugcagucapaaccupacccggcaagccagcagaagg\n", + "gcuguggucacaacuapccupcucaugcauugaacugaucuggcugaggcaucagacacggugccaguccugcccugcpaagacaagagcacaaagugacaagccagugug\n", + "cggcggccgcpcccggcpcgcgacgcugccuccucaccggcgcaggcuaggapcggccugagugccguagccgagccpcuggagcgcgcg\n", + "cgcugccuccucaccggcgcaggcuaggapcggccugagugccguagccgagccpcuggagcgcgcg\n", + "cuccggcucpcuccggcucgccucpcupcucpcuccpcggcgucccccgcgccpccccpacpcggcgacgcuccaacc\n", + "agucccgcuccgcgccgcgccgcuccgcuccggcucpcuccggcucgccucpcupcucpcuccpcggcgucccccgcgccpccccpacpcggcgacgcuccaacc\n", + "ggaaguuaacuuuucuuaaucpuuucuacaagguaguucacuauuguauguuuuauuucuuaccaaaacuuuucuupaaaauuuguuuuauugcuccauacguggucaag\n", + "agagacpagcuacgaapuggupccpaagagaguupagapuupagapugaugagagcgcgcuggagag\n", + "gccccgcagccccpcupcccgcgucccggagcgccaccggagagcgaggacgacguggaggcggaguggcgcccggcgag\n", + "aaacccgcaaggcgcggaggccgccgcgacgcucaccppcgcugugaagccggcaccpcggacagag\n", + "gcggapagcuguucauccucupcugcupccagaaauaucucuuaccugauaaugucaggcaucagagguuccuguuucgugg\n", + "ucuccugaauauuuacgcguugcugaaucuccuguggacaaaccaccaauaggccaggacuguccuguggacagacpugagccucuucuugugucuggagauucuga\n", + "aguggugagcacggugucpccgcauuagcuauugauuuaugugcuguuauagaauuaauugagucuggacauggagacucauuuucuuggacauguagcag\n", + "aacaaccgcugacuuccugguuccupugccgcaucacugccccucugcuccpucaaaccggcuguaugcuuagcuucaggaacauguggcagguggcagcccccggccccguggcag\n", + "agcagucgcggugugcggcucggcgcpcucacaaagagcucggccucgcggacugagccggcggcagcpcpacggcggcguacccpcagcccagcgcccuggccag\n", + "cagucuccugaauauuuacgcguugcugaaucuccuguggacaaaccaccaauaggccaggacuguccuguggacagacpugagccucuucuugugucuggagauucuga\n", + "ucuccugaauauuuacgcguugcugaaucuccuguggacaaaccaccaauaggccaggacuguccuguggacagacp\n", + "gcguggcucccpcgcuagguguucgacagacuugaaccgcgaccuuguggccucagaggucguucauupaccgupagacucucuaaccuguuugag\n", + "cuuccagguapccuacgcguggcucccpcgcuagguguucgacagacuugaaccgcgaccuuguggccucagag\n", + "puuupcaaaugccaguuuucagucguauuugacuguucugcuuucugguuucaguaauucgccaaa\n", + "ccaggcucgcuguacucgcgcacccaccauggccucccgcagcgcpcacccuacugaccgaguucaaugccgccuacgugcccccuggacucaugcccgg\n", + "agucgcuguuupacgcupugugcgguguucugucuccgcucccguuucgcugucacagcccguuccuucccggagcccpacaggcupcgcgcgcccgu\n", + "guguucaucagucgcuguuupacgcupugugcgguguucugucuccgcucccguuucgcugucacagcccguuccuucccggagcccpacaggcupcgcgcgcccgu\n", + "auccpucaccauguggcccagcuggacccccupcauucuggaugcagaccuggacuccuuugugcccucagacuugaucacaaccauugauaaacugg\n", + "ccuucuaugaccuucaggaggcugaccuugauaaggaguuccagcugccgacaaccaccuucauupcucugaaaacacccucucucugcpagaucauucggcgccuggag\n", + "acggcgcgcgcgcaccccuuccgcgcagcccccugaccugcagccuccggaccucgcugcagcgcggacccggcccgcccgcccg\n", + "agccaggcuucggaaucacugagagaggapcagcgccaacgcccagcaccugccgccggupacugacuucggcggaacggaaaacuggaguuguuucccupccagugcaccgag\n", + "gagccaggcuucggaaucacugagagaggapcagcgccaacgcccagcaccugccgccggupacugacuucggcggaacggaaaacuggaguuguuucccupccagugcaccgag\n", + "ggcacugaggcugcaggcggcpcgcagcgcggcagcggagagcugaggccgucccaccgccupaccccgugcaga\n", + "cgguuuuccagcpcucuguuuccccucccaaggcggcggcggcugagcggcggagccccccaaauggccuggccag\n", + "gcuccagaccaugaacauggacauucugaagugcucuuggaggauguggaacaucugaaggucaagcaggaaccaacagacauacagcuucagccu\n", + "gcgguugaucggucauupugcugcagccccgccaccuguuccguagcuugccggugccccgaag\n", + "gugucuucuccuaaggaagauuaaaucagaaaauuuuaaaucacaguuaucccuuuacuuaaagccagaguaagccuuccaaauuaaccccagga\n", + "acuugugcccagagagagagagaaaaacugcugacccuguaagagagaacuggccaucuugcagacagacagag\n", + "ccccgaguguucuuucaacuaccugccacccauccaacaacuccccucggaccucaguaupcuggaaccugacacuuggcaugacagug\n", + "augucuaucaaguauuuguucccugcuaggauaucagaugacaccaaauuugcauuuaaucgaauaaaucagguaaacaaaacauugaagaugcguucauaauuuugug\n", + "aaaaggagaagaaacuuuuccupaaccugcugacuauacaaaggacaaaggcauuaugugucaggccuuguucccuuaucuga\n", + "gaggucccgccccuuauccugaagauuaaacagccuuucuuugucugagauaacgcccggaguucuuuguccugccuccaagacgauaaaggagcgcagacacaaag\n", + "cagagagagagagaaaaacugcugacccuguaagagagaacuggccaucuugcagacagacagag\n", + "gccuggcuucagccagupcucagaacggcugacgcauuuccggccuuugcgguugaucggucauupugcugcagccccgccaccuguuccguagcuugccggugccccgaag\n", + "agacagagucucacuaugucgcccaggcuugucuugaacuccuggacucaagagauccucccaucucggccucucaaaguguupauuacaggc\n", + "accuaagccgccguugccaupcccgcagcagauggcccgguuuapuuccpcpcggcgcgcacpauuaggugaauuapagccggagcagugccgccgucgccgucgcagcgcc\n", + "gagaaaagcupacuugccccacguuacacagccacacugaggcaugugucgugucacaaacgagaucuuccauucaag\n", + "guuuacgucucgcuccpcggaaagupucapccpccggcggagcgcgcagcpcugcag\n", + "aucugacucuguggagccupacugguuucagcgagagccucuguacugcucuguagucucugcuaggacauggacgaaaapacgcagccpagagcgacugccccag\n", + "aucucuccaucucugcgcugcugccggcugcgccauccagcacccagacuccagcaccggccgaggacccccacuccggcugcapacccugucccagcgagaccgcaggc\n", + "gugcugaccugaaccugguucaucccuuucugaccaaaacuguucacucaccguggaapacuaagcauccau\n", + "gaaauapucuucuucccagguuggaccccpaguuupcuuuuccuacaaucacugacccucacugugacuaaaggagcagaauuag\n", + "uccucuuuuagagaauguccggauugcuauuggacuuuggagcguauggcuccaaaucaacucauuggcuaaaacuugacggaaaauggugguuag\n", + "auuacuauccaucacuguuuuaauggauaucuuauuggaapcuacauagucaguauuucacaauauaugaacuccgcauaacaccuauggcaaaacauuucagcacucag\n", + "auauaaauuuacuucaacaccuuuuacacugaaagauauucuccuaggagacagagaaauuucagcug\n", + "aaaaauuaacuuugaccacagcuugauacgucagucaaggagcagcagaaaggcaguauugugugugguc\n", + "aaguucuguuggcugaauagaaaauuugaguuccuuuuaagaauucuggcuauguguuucuuuuuguuguaagauuaauugaauuacuacuuuaagucuug\n", + "cccgcuccucucccgccpcpcuccuuugucuucupcuuucgucgcgagauggaacgcugg\n", + "auucgcuuccguucgcuuuagcaaaggcagaaggcgacuaccgaggacagaguguuuucacgugaccacaguuccccuuugcuugag\n", + "caaaggcagaaggcgacuaccgaggacagaguguuuucacgugaccacaguuccccuuugcuugag\n", + "aucauauauuuuaguucucuguuuccauaugugguacuuauuugcuuccucaucagagcauuccuuuuaaaugguucaauugauggcauucgccac\n", + "caaaggcagaaggcgacuaccgaggacagaguguuuucacgugaccacaguuccccuuugcuugagguauccugugauaaauggcccgaaapccuuucgccguacgaaag\n", + "guucgcgucuccgcccguguuguuuucupuuuccuucucgcccgccuaccucgcucccugcugcugguccccgcccgcacug\n", + "gcugcccgcggccuguaaugagcaaguuccgaggccuacggugagcgccggagccggagaggcag\n", + "caaccgucgupcugcccgcggccuguaaugagcaaguuccgaggccuacggugagcgccggagccggagaggcag\n", + "gcucuaggacccggauuuaaagagacaggcgcuccaaccgucgupcugcccgcggccuguaaugagcaaguuccgaggccuacggugagcgccggagccggagaggcag\n", + "ccaagcccaacaacucupaagcccccucgagccccaccccuaagagaagucugucuucaagcaaaugugaccccaggcauaaggacugucugcuacpaguuucgaaaguuaugcgcc\n", + "agagcagccggcgagcggcagcagcuccpcucgagagcccgcgcccaugccagugcccaugcpccgccgccagugacgccggagag\n", + "acagcgcagagcagccggcgagcggcagcagcuccpcucgagagcccgcgcccaugccagugcccaugcpccgccgccagugacgccggagag\n", + "ggaacuaggaaggcggcupcpugacgcaggcupuuugccpuggcccccgagcggcgugugacuupuccaaggaaguuaaacuggacaggcup\n", + "cgugucuugcagaaguggaugugaaucucccccagccaccugcaaggcgcucgcacgcagcugucpacugag\n", + "agucagccccuggaacuaggaaggcggcupcpugacgcaggcupuuugccpuggcccccgagcggcgugugacuupuccaaggaaguuaaacuggacaggcup\n", + "gagcagccggcgagcggcagcagcuccpcucgagagcccgcgcccaugccagugcccaugcpccgccgccagugacgccggagag\n", + "cuuccucaggcuugcgaagcupuuccacuggucccgcupcuccugcuuucuagaauuaucugcgcugccuccucuccuuguggauuccaccccau\n", + "uaguuuaugccaacgugacuucauucauacagaugaaccaaggaucpauagcaguauaaaauuagaaucaagacagcugacugcucagcagg\n", + "cuccuccucacuccucacccuccapuagcggcuaccggagcgcugcapcugcgccugccugcuccgccccagaccugucggcgaaagg\n", + "gucccgcucgcccugcgcccuucgcpccgaaagcacuaggcacucgcgaacaucugaggccucccggccccpaccccgccccgccguccgccggccggcccgcggccucucuucccuuu\n", + "gguagcggcuaccggagcgcugcapcugcgccugccugcuccgccccagaccugucggcgaaagg\n", + "aupucauugagcucucucucuccaggaccccuucccuaapugugauaccuuugacugccauugag\n", + "cuuuuccuacucuugccaagapagaaaccaaggagcucuggucaucaggucaccaucucaaggccugccgagcuguggccuucucugaagaupcaga\n", + "agcucauuacugucuccaaggacaaagccauccauguucuagauguggagcapccaacuggaaagacguguuuccaaggcucaugg\n", + "ugcccccaucaauagucuucugcugguggaugagaauguucuggccacupaugacacaggugguaucugucucupaccagcggaaggapccccuua\n", + "guucacguuggcuauguupacaacuuuagaagaggaaaggcagaagcagaggcacccuugauccag\n", + "acaccggaagaaauagaaagauugacagucgaugaagaccucagugauauugaaapcuguuuaucugcucag\n", + "gaagccacgaugugauuuucaagcugcaguccaggagcuagaaggauaaaaacagaaaaauacagcccccuccccaaacuccccaaaccacccaauuagagaccuccgugauugaugucgccug\n", + "ggcagccucacgcucggcuccagcggccaagagccggagaaaguccugcuggupcggccgcpcugapcguccggcaucccpccgcuccggcccpcggcgagagugcccggcggucc\n", + "paggccgccugguuuuccucccuccuucugcacgucugcupucucuuccucuccaggccuugccgucccccuggccucucuucccagcucacac\n", + "gucucagcggcgguggcagccgaggugcaggaugcaagaaggcgccccccggccpcucccgcuccaggccucgcuccccugcggcccucugagcccacc\n", + "cuuuuccacgugcgaaagccccggacucguggaguugugaacgccgcggacuccggagccgcacaaaccapcucgcc\n", + "gugcgaaagccccggacucguggaguugugaacgccgcggacuccggagccgcacaaaccapcucgcc\n", + "cgccguccacaccccagcggcccugacgcuguccccuccgcgacccucgccucuggaaaaagugacaggcaaggccacgcccccgcgapccggccuggagcccgcagcccccapccupacg\n", + "agauccugaaggagcuagacgagugcuacgagcgcuucagucgcgagacagacpcgcagaagcggcgg\n", + "gccgaagccugagcucgugapccgaggcugupagguggcaguuggacuucggaaucucaaggacuccgacuccuggcuuguucagagaaggagagccccgacuccuggaucccugg\n", + "gccccgccuccuupppucuccgcgccccggagcagacgcgagcggcgcucagccguccuaggccccgcccccggagcuucuggucccgcccaccccgcaggagucccagcggcc\n", + "gcugcugcagcggcugcugcugcuacugcggcuccugcugccgccgccgccgccgcucggccucaggcagcugcauccucggccpccpuccccgccccgcgccgcgcccggccccgcc\n", + "acugcggcuccugcugccgccgccgccgccgcucggccucaggcagcugcauccucggccpccpuccccgccccgcgccgcgcccggccccgcc\n", + "gaacucugaaaaggcpcagcpccugcagcuccuggaguucapagacccggaaaucucacccugcccucuucuuguguuguguuugucacagccuugccccucuugcucgccuugaaa\n", + "agcupcuccguccucgccucccacgagcgauccccgaggagagccgcggcccucggcgaggcgaagaggccgacgaggaagacccpug\n", + "cauaacugugcccacuucugcaucaacaucccuggcucauacgucugcaggugcaaacaaggcuacauucucaacucggaucagacgacuugcagaa\n", + "cuuuucuuagugccuaaagugucugcaaguggaaauccagaggaagacagagagaaacugaguuccugaca\n", + "gaccggcacgcggcgagccucgagacugcgcgapcggccccpcgagcggcugugcgcpccaapcpcagcag\n", + "gucuacagguccaacugcugccacuggcaguaaucgaagacuucagcagacacaaaaucaaguagaugag\n", + "gucccacccaucucccuggccuccggucccaacuucgcuucucugcugacccucucucgucgccgcugccgccgccgcagcugccaaa\n", + "gccaaaaccuuugaccagagucuccuugccagcauuccuaccucccuuuggccagcuauuugugccag\n", + "guccugaauguucccagaacuacacaacaccuaguggagugauaaagucccccggauucccugaaaaauaucccaacagccuugaaugcacuuauauugucuuugugccaaag\n", + "gcapucucupaaagacagacagacggacpagagcacucggapaaaguuguuccucccagucuccugucaggcaauuacag\n", + "aacucaacaaaaauccaguggaaggcuuuucugcagguuuaauagaugacaaugaucucuaccgaupaaguccuuauuauuggcccuccagauacacuuua\n", + "gugaccuacuucugccugaguauugcuagaauucuuucuuuauccuugaaguucaguaacuucaucaggauauaacucggucuuggugugauucucuuacauuuuccuguuaaaug\n", + "auguuuucagucccacuucucacuacugaucucccucguacgacggucacugaacuggcgccucucupuucugcccagaagauuagccuuccuccuucgcugcagcuccucu\n", + "aaaaaagcucugugcuggcuggagcccccucagugugcaggcuuagapacuaggcupuguggagcugcagcguauccacag\n", + "agcugcgcauaaaauccagcuuuguggcaccucuggaaaagucauaupaccaggcccagaguccugacpcaacccucgcuuggaccugcaagagaucaacaacupugcaggcgcag\n", + "aggcgcaguguggugagcgagccgaagcgcpaagcagcucuuguggauccucaguggcggaggcucggucacccgg\n", + "uuuuauugugacuuguggaagugauggugaugugaggauuupaagacuuggaugaugaugauccuaaguucauuaauguuggagaaaaggcauauucaugugcuuugaag\n", + "aguguggugagcgagccgaagcgcpaagcagcucuuguggauccucaguggcggaggcucggucacccgg\n", + "gaggauacucuguucguaagcucccggugaauuuuguuccacagacucggaagaaagguuggauaagaguucacuggagauugacaaguacucpauagugaaaagccggaguuggaac\n", + "augaggauacucuguucguaagcucccggugaauuuuguuccacagacucggaagaaagguuggauaagaguucacuggagauugacaaguacucpauagugaaaagccggaguuggaac\n", + "agucuuugguggaaccaucacuaggccccaaucccuuagucccucuugcgucgaggcugcaaaaugguuccauucgccaggagacgcuccugagagaapcgcgcgcggcacag\n", + "agcgcgcacgcaaucgcguuuccggagagaccuggcugcugugucccgcggcuugcgcuccguaguggacuccgcpccuucggcag\n", + "gagagccccpupapcgcaapcucpapccccucccugcgucggcgccccugacccgcccccag\n", + "aggcapuuuugcuguauugcacaggcuagucucaaacuccuuggcucaagugauccucuugcuuuggucucccaaagugcugcgauuacag\n", + "aaaaugcuuggacagaagagaugaguacuauuuccacuaaggccuagaauugccuacuguacaaauaguccugaucaggcaauauacga\n", + "gccauauugugugacaguauuuugauuuggacupcuggcggagccgcggcgagagcgagcgagagcuppuppapcag\n", + "ccuggucccuggacuacuuguccugcaucuaauccucugucacauaccucaucucaacagccaaaucagcaaggccaccagaccucucaugucuac\n", + "aauaauaauaaccuggaugccugcugugcuguucucucucaggagaguacaagauaucuuuauggugaaggagacuugaauuuuucagaugauucuggaauuucuggucuacgcaaucac\n", + "acacaagcgcuuccuugccgagaggcuggagcugcggcaccgcaggccugagccaccccuucucugcugucuccuucucuuccucapcucccgugucugcucgcccuccgacgcugcucag\n", + "gaauuugacaagaaacugaaguuuugauucagauauauuuugaauugaaaccagagauguucuagaguuuagauucuuucauuugauuaag\n", + "cagcupcagcucupaacuuggauuagguggagaggcaguuppccucguuguuuugcgucuuaguuccgcccuccuguccaucaggagaaggaaaggauaaacccupcc\n", + "caguacugaagaapcuucccagauuuuucuucuucuuaggucauuuugcauaagauupagaaagacaagagaaggaggaaaucuaacgaaaccaaag\n", + "gagccgaucgugccaccauagcuccugcugcugccucuaccgcugcggcuaccgcggcggagcugaaauugccgaacgcgaugcccgapcgcugugagcpuggccuuagcucgccgaggcug\n", + "gucagugagapcauacupaagcccucuggagupaagacagugccgcuguugagacaagacccaggacupccpacugucccaaapuuucucgucaua\n", + "gugccaccauagcuccugcugcugccucuaccgcugcggcuaccgcggcggagcugaaauugccgaacgcgaugcccgapcgcugugagcpuggccuuagcucgccgaggcug\n", + "ggagcugaaauugccgaacgcgaugcccgapcgcugugagcpuggccuuagcucgccgaggcug\n", + "cgcugcggcuaccgcggcggagcugaaauugccgaacgcgaugcccgapcgcugugagcpuggccuuagcucgccgaggcug\n", + "gcagagcaccgcgccuuagccgcgaaguucuaguucuugcugccgguccuaacgucccgcagucuucgccagccagccgucccgcaugcgcguuupcggcguggagccugcugcc\n", + "gcgccuuagccgcgaaguucuaguucuugcugccgguccuaacgucccgcagucuucgccagccagccgucccgcaugcgcguuupcggcguggagccugcugcc\n", + "guagaauupcuauuugcugaagcuucuugguggcccuugcuagcccaggaagaaacuuacauuuugauuuuuuuguacc\n", + "cuuguuuggcaucggaapaaaagcagauggaccuauacpuaaaguggcuucupcggaagguacacuauaggcucpag\n", + "ggaapaaaagcagauggaccuauacpuaaaguggcuucupcggaagguacacuauaggcucpag\n", + "gugcaggcugcaggcgccgcgccgaggaggcugccgcucuggcuugccgccccccgccgccgcugcacaccggacccagccgccgugccgcpcc\n", + "agugcaggcugcaggcgccgcgccgaggaggcugccgcucuggcuugccgccccccgccgccgcugcacaccggacccagccgccgugccgcpcc\n", + "acuuuuuucucpcauuccggcugcuuugccucccgccacucucgagauaugcgucpcuggcuccaagcag\n", + "uuugauaugacgauuagagcauaacccgagugacacguugaauucgccauaaucaaggaaaccuuuuccpupaucucugaaauuacucag\n", + "caugacuguuaucuuuuugauggaaaagaugaaguucagcgaagaacaaaucuacaacuuggccagaagacuguagacuuugccuucaaagag\n", + "paguccgcgcgugcccgcgccgagcugccugcuccggcggcuucgcugcuagcucgcggcgacgucpccgauuuucccagg\n", + "acggccguaguccapcugcuucuagcugcgucucuccugugcccccucacaugaagucaggaagccacpagauguucccacuggcgcguuugacucagcaguggcuccaaaaggucaa\n", + "agacpaacagcaugguggauggugugcaaaugacugauuuaaacauuuaaaggaaacuguaaauacaagcagcuuguaacagaaaaauuccaaag\n", + "auagagacuguagccguggagacuguuacuuaccaacpaccaacacgcagcagccgcugccgccgccgcpagccgcugcccgaacucccggcccgaacuccag\n", + "pugacuggcaaccaugccgugaagacacucaagcaauucuguggagaaggccauggaaugaggagcugagacuuccugccaacaaccagucaucuag\n", + "accgccgccgccauagagacuguagccguggagacuguuacuuaccaacpaccaacacgcagcagccgcugccgccgccgcpagccgcugcccgaacucccggcccgaacuccag\n", + "guuacuuaccaacpaccaacacgcagcagccgcugccgccgccgcpagccgcugcccgaacucccggcccgaacuccag\n", + "gacuguuacuuaccaacpaccaacacgcagcagccgcugccgccgccgcpagccgcugcccgaacucccggcccgaacuccag\n", + "gagacuguuacuuaccaacpaccaacacgcagcagccgcugccgccgccgcpagccgcugcccgaacucccggcccgaacuccag\n", + "acucucccugccccucggaccccauacucuaccucauccuucuggccaggcgaagcccacgacguugac\n", + "acuuuagccagcgcapcgcaccccgcccccucccacucucccugccccucggaccccauacucuaccucauccuucuggccaggcgaagcccacgacguugac\n", + "ggagaaguaagcgguppupagccaucugguacuuugacagcauucaaaacagcaucggccauaacaacagaa\n", + "agccccagccccggcgagcacccagcuagccgccuccugcapcucpagagcaauucggcggccccugcapcagcugaagccauggaagccuccgcag\n", + "gucgcugaucapccaggcggcugcagcagcgacugcagaggcgcugcgccaagccpccggaguggugcgagccggcpcugcggapccaguggacucag\n", + "cccucccucccggcagccccagccccggcgagcacccagcuagccgccuccugcapcucpagagcaauucggcggccccugcapcagcugaagccauggaagccuccgcag\n", + "cagcuagccgccuccugcapcucpagagcaauucggcggccccugcapcagcugaagccauggaagccuccgcag\n", + "aguuugaccccggaagugcpcgcucapagcugucaccguggucggcggcggcggcggcggcggcggcacagagccggugguggagccgccgag\n", + "gagacuuccugucugcuccugcggaaucgcaguuugaccccggaagugcpcgcucapagcugucaccguggucggcggcggcggcggcggcggcggcacagagccggugguggagccgccgag\n", + "gccaagugauauugugaaaagaacacuggacagcaagacaggagaccuuggaucugccacucacugacugugag\n", + "gcaguuugaccccggaagugcpcgcucapagcugucaccguggucggcggcggcggcggcggcggcggcacagagccggugguggagccgccgag\n", + "ugguggagupaguuugugcapaauuguggcuucaguaaggugupaguccaguucaagcagagag\n", + "cuggaaggcugaagucuuucaccugagcugcugccaguucgcucuucuguuccupugguupagaagagaagapapuauuuuaugcuuuaauuaaagacagauaagagagcag\n", + "agaaagcuguggaggugugccccagcacggcugcuuugaaagguuuaucaucuauccguuugguuu\n", + "acuuccpuguugucuggccgccguagcgcgucuupucucccggcugccgcugcugccgccgccgccucpucguggagccaggagcgacgucaccgccauggcaggcaucaaag\n", + "caaauacuggccccucuuuguucuauuuuuuuacauccuuucaccuauuccauacugcauagcaagaagauuaguggaugauacagaugcu\n", + "puguugucuggccgccguagcgcgucuupucucccggcugccgcugcugccgccgccgccucpucguggagccaggagcgacgucaccgcc\n", + "guugucuggccgccguagcgcgucuupucucccggcugccgcugcugccgccgccgccucpucguggagccaggagcgacgucaccgcc\n", + "gcacuuccpuguugucuggccgccguagcgcgucuupucucccggcugccgcugcugccgccgccgccucpucguggagccaggagcgacgucaccgcc\n", + "cuggccgccguagcgcgucuupucucccggcugccgcugcugccgccgccgccucpucguggagccaggagcgacgucaccgcc\n", + "cugaaaaugugugucugacaugcaagcucagupcagagacccguggauugcugugcccugcccuccggaccuggauc\n", + "pcpcggcggcggccaccuggcccggaccaccgcggcccggapccgucaacaaagugguguacgaugaccacgagagcgaggaggaggaggaagaggaggac\n", + "agagcagagucugcgaucuucccagcacagacguuuggacagagcaggcuccuaaggucuccaga\n", + "ggacugaggaguccguccugaaccgaagcaugauccuguuagcucuuccagcucuccaggcgccaacgaccauauggucucg\n", + "gcuccuccugcacaccucccucgcucucccacaccacuggcaccaggccccggacacccgcucugcugcaggaga\n", + "cuccuccugcacaccucccucgcucucccacaccacuggcaccaggccccggacacccgcucugcugcaggaga\n", + "cucugucucucapcaugagaccagccaggcacupaaacaagguuuggugccagagauuuugguggcuuccaagacugcuuuuucagagacag\n", + "aguuucgcuuucucucugucucucapcaugagaccagccaggcacupaaacaagguuuggugccagagauuuugguggcuuccaagacugcuuuuucagagacag\n", + "cggaagagccagagcugcgagcgccuggagcuggaucucucuccggucgcgcacgccgaggccaguapagagaag\n", + "agaauucggagcgcggaagagccagagcugcgagcgccuggagcuggaucucucuccggucgcgcacgccgaggccaguapagagaag\n", + "agguuupcuuggaguupcccugaauggcgcuuugcugugaaucuccgcpaggcucuuccaaccapcugagcuucugcgcuguggagaagccag\n", + "cacugcugaagcuguacuucaaaaaauggaugacaugaagaagaugcguagacagcgaaugagagaacuugaagacuupaguguuuaaugaaacagaagaa\n", + "agcaaucuuaauauguacacaagaggaaaacagaaagauauucaaagaacugaugaagaaacaacugauaaucaagaaggcagugugg\n", + "aaccucgucaccagagaaagcccaacauauuuuauaguggcccagcuucuccugcaagaccaagauaccgauuaucuuccgcaggaccaagaaguccuuacuguaaacgaaugaacag\n", + "gcgaaggcaugcaauccacaguagugacucgacuucaucuuccuccucugaagaugaacagcacuuugagaggcggaggaaaaggagucguaauapcuaucaauag\n", + "gugccucccacuaaauuuucggaaagaugaauuaaaaggcauuuauaaagaucgaaugaaaauuggagcaagccuugccgauguugauccaaugcaacuagauucuuca\n", + "guacgauuugauaguguugguggccugucuaaucauauagcagcucuaaaagagauggugguguuuccauuacuuuauccagaagucuuugaaaaauuuaaaauucaacccccaag\n", + "gccuaucagaugcgcccaucaauuauuuuuuuugacgaaauugauggucuggcuccaguacggucaagcaggcaagaucagauucacag\n", + "gcucgaaaagagauucuaaagauucacaccapauuggaaucccaaaccacuggacacauuuuuagaagagcuagcagaaaacugu\n", + "gcggaaucucaccugccaggagugaaccuguaccuccugccccupagagcagcucccugauguuucccugaccuuccaggccuggcgccgccucucu\n", + "gacccggagcgucucugcuucaucuccaccacgcuucagcccuuccaugcccugcupapcupacccapccgcuggaccaac\n", + "gagcuucuccggcggcgapauagcugguuaccagaaggacuucuuugcapccagugguuucugucagauuuucgccg\n", + "uccuccaggccucugaagaagaaauucagaacaaagaauaauagcaguuagaguucaguccuguuuccccuaaucugag\n", + "guccgcgauuggcuucgccgaggcpauccuugagcuucuccggcggcgapauagcugguuaccagaaggacuucuuugcapccagugguuucugucagauuuucgccg\n", + "auuuccpaagauggcggcgcacaagucagguccggcacauguuuccgcggagcggacccagcaaugacg\n", + "aacaaaacggcauuuccpaagauggcggcgcacaagucagguccggcacauguuuccgcggagcggacccagcaaugacg\n", + "aacgguuuccgguagcggcgucuaggapcpaaaggaggcggcagccaggcuguguccccugaccguuggagcgucugcgacccccgcauccccgcacccucaaggcaccuccaaag\n", + "gucccccccacgacccuuuuuaaggccgcgcgaccgcuggcgcaucgccuggagcgcggcagcaagcgupaacgcpcggcgagacggcggcaggacggcggcag\n", + "aggaaggcappaapacagucggccgcagaccgcgcupuugccgcugccgcugccgccaucgugccagccccucgg\n", + "auaupcuuuguugcugaggcuggucuggaacuccuggacucaagugauccuccugcgupccucccaaagugcugagauuacagau\n", + "auugacgcgucaugccuuacgupaaggacaacaguuccapaaagcugccauuguggagaaguugucu\n", + "agccuuccguuccagaaaauucagcacagcaucaccgcgcaggaccaucagcccacuccagauagcugcaucaucagc\n", + "agagugcagcpcpcgaaggaaggcappaapacagucggccgcagaccgcgcupuugccgcugccgcugccgccaucgugccagccccucgg\n", + "pcagaaucagacccagcgucugacuccuccugagapcucccuuuuuucuccucuccuccgcugucagaaacagaucupcugga\n", + "agacccagcgucugacuccuccugagapcucccuuuuuucuccucuccuccgcugucagaaacagaucupcugga\n", + "cucuggugucuguggacccugcuucugaaguacaugaaccuugaggaaaauugaccaguucuagcaguucuaaaauc\n", + "ggaacacaacagauuugagaagccucggauuaaggaauaauuuaugaagcuccguugacuaccguggagagaucauaauuupuucaagauuccag\n", + "ggacccacaaaccgucuccauggaaaaccagaaccagaagcgcugcccuaucagaaggauucuggaaauaacgcuggaugaggcagagccacagucacagauccgaugucag\n", + "cccugccaguuuccagagaaggcgcuugagaaggagaaacgaaucgcugcugcucuucuaaaagccgguucccu\n", + "aucccucccugcccaggccgcgagaaugaccacuccacuugcaggcgaagccccuggccgcugugcugaaggaggugugcgacgc\n", + "guggagccugacgcacucugagcguuacgcccugcaguuugcggaupcaccggagauacaucaccgagaau\n", + "gaccuugaggcugagcagcucuupupcugcagaguaacaguccugaapcgccpaagcccugaggcgccuuguuccgcuggccucggac\n", + "uggccaaggcggcgaccggagcgcgauggcpcggcpacucacggcagaagugagcuggaaggucuuggagcgaagagcucggaccaagcgcucag\n", + "gauggcpcggcpacucacggcagaagugagcuggaaggucuuggagcgaagagcucggaccaagcgcucag\n", + "aaauuauuuucggacpcgcgguggcucacgccuguaaucccagcacuuupaggccgaggcpcggaucaccugaggucaggaguucgagaccagccuggccaaccug\n", + "auugcugacaggcggccccpcgguggccaaggcggcgaccggagcgcgauggcpcggcpacucacggcagaagugagcuggaaggucuuggagcgaagagcucggaccaagcgcucag\n", + "aggapagaaupagapcaaggapaacgaguggaagauugcgucacgacgcacauaaagacguacgaagccgucgccaa\n", + "gugaaguaguauuugaagcuuuucaucaguuggcucauucuuuacucaagaauaaaccucaagaaacgucaucapucaga\n", + "aggacagaggaccagagucugcacccccuccapcagcuccaaccccauauccccaggcccupuugapugcuggcggupaggcapacaguag\n", + "gccuggugupacgcucaggugccggcgupcccccucggaggcugugaaucuuuuggacccccgaauguaaaupagaug\n", + "cucacggacacagaccuaauuaaacaguguauagaugaaugcacagccaggauugaaauuggacugcauuacaagauuccuuacccaaggcca\n", + "cuacuggaccagccugugcucggucggccacggcucugcupcuccuggcgccgccuccucccagcccgccgcpcugcgcgcuucugupupaaggcaggacugacgcaga\n", + "gcaucaucacuuccgguaaccccgccggccgccagcuccaggapagaaupagapcaaggapaacgaguggaagauugcgucacgacgcacauaaagacguacgaagccgucgccaa\n", + "gccauuuuggapccgcpagacguggugccgcugcpcucgcucugccgugcgcuaggcuuggupaaggccuguucucgaguccgcgcuuuucgucaccgcc\n", + "gcgccgccauuuuugcugcccggacgcggagcgagaggcugagagagucggagacacuauccgcuuccauccgucgcgcagacccugccggagccgcugccgcu\n", + "agaggcugagagagucggagacacuauccgcuuccauccgucgcgcagacccugccggagccgcugccgcu\n", + "ggauugaggcgccgccauuuuugcugcccggacgcggagcgagaggcugagagagucggagacacuauccgcuuccauccgucgcgcagacccugccggagccgcugccgcu\n", + "auuuuugcugcccggacgcggagcgagaggcugagagagucggagacacuauccgcuuccauccgucgcgcagacccugccggagccgcugccgcu\n", + "auucgaaucggcggcggcuucuaguuugcgguucagguuuggccgcugccggccagcguccucuggcc\n", + "aguuugcgguucagguuuggccgcugccggccagcguccucuggccauggacaccccggaaaauguccuuca\n", + "cuguguaauacuucauguacccuaauugaucuaagcagucaacacagguuguugacaaucuguuucaaauaguggcacggugaaaaaucuu\n", + "ggcaccuupuuccgcugaggcccggcgcuuguccgcccaucugcgccgcgguggccguuuggagcaaucuggauaauucguuaggcccucagagcucucguuuauucuuu\n", + "gcuggugaupcaagccpuguaccaaguccaggaugcacaugaggagcguuuguagcagucacugaaucaccucaugacuagcpcaggccucuaauucaccgcaggauuuccg\n", + "aucucacucuguugcccaggcuggagugcaguggcacaaucacagcugaccgcaaccuugaccucccaaggcucaggugauccuccugccucagcccccaaguagcupaccuacag\n", + "aaaugugauugauaacaguaaagccacacuacucaagugccugaaauaccccucauugucuucuucagguggcaapcucuggaacagccacauaaag\n", + "acaagaucucacucuguugcccaggcuggagugcaguggcacaaucacagcugaccgcaaccuugaccucccaaggcucaggugauccuccugccucagcccccaaguagcupaccuacag\n", + "agaacgccucapucuugccugcugugagugccuugaagapagcagcpcacgaucaaagagacaccuggcucaaggaccaauaaggagu\n", + "acugagagacgcccupacaucugugguggcuuuugucgcgcupaccuacccugacuacpaguupaggacccpacaccgcacagccpaa\n", + "ccuggugaccucuguuccguauucugucacugagagacgcccupacaucugugguggcuuuugucgcgcupaccuacccugacuacpaguupaggacccpacaccgcacagccpaa\n", + "agcuccgcgcugcgagcgcuacpcgcapcpagccggcccggagcgcaguuuccagupccpuuucacccpcccucucuguuugaaccgaacccgacaaaupcgc\n", + "aggccupcuucccccagcagcgcucgagcaccgcccagucgagccucacaccggaugccacuucauauuupcccagagcucaauucgcgccg\n", + "ccgaggugcucgguggagucauggcagugcccuuuguggaagacupacuuggugcaaacccupagaaggugccu\n", + "ccgaggugcucgguggagucauggcagugcccuuuguggaagacupacuuggugcaaacccupagaag\n", + "gcagaaaagacggugucacagcuguacccupaucggcagaaaapuccccccpccuguaapugccugcg\n", + "agagccaguuccaaccccpaucgccgcggaaccacgcacagagucugcagaagugcacagcuuuaucgacagcgcuugaagc\n", + "cacccuaaaaagaaagaauaaaacaacaacaggaaaaaaaggaaaauauuuaaauugugacaaaaacccacugg\n", + "gugacaagaagcggaaacuacgcugaaauaggcccuugcuccaagucccaguaacucggaaugcggagccgcucgucucccgucuuuuuuaag\n", + "ugcacugguaccaucauaguucacuacugcuucauacucccagacucaagcaauccugccuccuuggucucccaaagugcugagauuacagcugugagccaccuccccuggccauaaag\n", + "uagagacpuuucacuauguuagccaggauggucucgaucuccugaacuugugauccgccugccucggccucccaaagugcupauuacag\n", + "ggcggcggcggcggcggcagcaguagcagcaauauggcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "gcggcggcggcggcggcggcagcaguagcagcaauauggcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "caguagcagcaauauggcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "aggaggcccagaagauuaacaauggcucaagccaggcggauggcacucucaaaccaguggaugaaaaagaggaggcaguggccgccgaggucggcuggaugaccuccgugaaggacupcpug\n", + "cgcuccgcggcggcggcggcggcggcagcaguagcagcaauauggcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "caucucccccaaccuggagcuugaagcucuguucaaacgacauuuuacucagguggaauuuuaucapuuccguccucaauccacaugaucuugcaagagucaag\n", + "agucagcagaugcaugccugauccuugccaacaaguacugcgcugacccggaugcggaggaugccucgaauauc\n", + "auagagucagcagaugcaugccugauccuugccaacaaguacugcgcugacccggaugcggaggaugccucgaauauc\n", + "gcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "agcaauauggcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "auggcuguugaupuguuupuggcgcuggcggcpaggagcucccccgagccccugcgccggcugcccguugcuagcu\n", + "gagagaaccagapcgaagupapcacapagacuaaaaaggccapaaguuggccugccggaaguucccapagaaggcagcgcguuguacccgag\n", + "ccuucuacagaacaccaguguuacuucacuccccuuuguggacaccaapaagaagaauacgguaagcuucccacacauuagcaagaaaguccugcugaagucaucccugcuguaucag\n", + "aacaccaguguuacuucacuccccuuuguggacaccaapaagaagaauacgguaagcuucccacacauuagcaagaaaguccugcugaagucaucccugcuguaucag\n", + "gaggcgcgugugcpaguugaaucucccgcucccuugaggcupuugcgucuguugacgcggccgacuacaaucccgag\n", + "cccugccagccpaacacggapaaggaggaggagcuuaaaagaggcuacugaaccccaguuggcc\n", + "agagaagcuucucgcgcacaggaagucgcugcgaggaggcgcgugugcpaguugaaucucccgcucccuugaggcupuugcgucuguugacgcggccgacuacaaucccgag\n", + "agaaacccgucacaacgcguuuccauggcaaccuaccgcuugcucuucggaaaagguuaacacucccugacuucuaguaaag\n", + "guugaaucucccgcucccuugaggcupuugcgucuguugacgcggccgacuacaaucccgag\n", + "gucacaacgcguuuccauggcaaccuaccgcuugcucuucggaaaagguuaacacucccugacuucuaguaaag\n", + "guggcagcgccpcggcggcpacccuggcupagcgcggcggugccggcpaggccgagcpcucgacagagcag\n", + "ggaggcuuccguuaucpaaaagaugcuguagugaucuuuucugagugucuccuacuugcgacaagguggacuupaggaaagccgucugccaaagccugaagccuccaag\n", + "cuuuucugagugucuccuacuugcgacaagguggacuupaggaaagccgucugccaaagccugaagccuccaag\n", + "gguggagaacacaucagcuucaaaggcagagagaaucgaaggugcucuccagcuuuggacacuuccucugcuugag\n", + "gacaccuugacuaaccuccaapcaacuaaaggaucaagaaaggcccagcacagcagaagaucagcuggaucuagcuccugcaggag\n", + "aucuuggcuuuuuagcagcugaguuuaaggcgcaagguggagaacacaucagcuucaaaggcagagagaaucgaaggugcucuccagcuuuggacacuuccucugcuugag\n", + "ggagaacacaucagcuucaaaggcagagagaaucgaaggugcucuccagcuuuggacacuuccucugcuugag\n", + "acacagcccpucgcaggcaccuccccgccagcucucccgcuucucgcacagcuucccgacgcgucugcugagcccc\n", + "acagugcuccggauccuccaaucuucgcuccuccaaucuccgcuccuccacccaguucaggaacccgcgaccgcucgcagcgcucucuugaccacu\n", + "acuuaucugcagacuuguaggcagcaacucacccucacucagaggucuucugguucuggaaacaacucuagcucagccuucuccacc\n", + "auuggccacagagacccagcccgaguuucccaucgcacugagcacugagauccugcuggaagcucugccgcagc\n", + "aguguaaauaugacuucuaagcuggcuguugcucuacugcuuucuuggcaguugcaugcuuucuguagcacugugugaag\n", + "ugugaagcuuauucaugaagagaccucugccugaacauacagcaaauuuaagaagguugugcagauagucugaaggag\n", + "gcuggugcagcauggaaacacggauuugagcucauuacuccaauuuucacgcugaguuuggaapuccuagagg\n", + "acagagcccpccgcaggcaccuccucgccagcucuuccgcuccucucacagccgccagacccgccugcugagcccc\n", + "gagucaaucuuaagaugugauacuuuccugugaaaccugaaacaaggugaucupaaccaaagacucupacucuuggugccaacagaguuacucu\n", + "auucuaaaaagagcaaugguucacaaggaaacuucugccucaggupagaggaguccauagaucapaaacuuaugucuuggugaaauggaagaccauguuucuaaacaccugucgccag\n", + "aaugguucacaaggaaacuucugccucaggupagaggaguccauagaucapaaacuuaugucuuggugaaauggaagaccauguuucuaaacaccugucgccag\n", + "aaaaagagcaaugguucacaaggaaacuucugccucaggupagaggaguccauagaucapaaacuuaugucuuggugaaauggaagaccauguuucuaaacaccugucgccag\n", + "acaaggaaacuucugccucaggupagaggaguccauagaucapaaacuuaugucuuggugaaauggaagaccauguuucuaaacaccugucgccag\n", + "guccuguaaguaguguuuuggugaauaaauacggcagccggccgguggugauagcaggaggcuuauuaugcugucuuggaaugguguuggccuccuuuaguagcagcgugguacagcuguaccucacu\n", + "agcggaugcugcaucgcggcgcccuucuccacccccuuuucuccucuacuuccgcgaaaaggauugcagacugccuuggaaapcggucgugcccagugccacuuucccg\n", + "caaggaaacuucugccucaggupagaggaguccauagaucapaaacuuaugucuuggugaaauggaagaccauguuucuaaacaccugucgccag\n", + "cagcgaggcgaaucggcugcgguuugcupaacggapcugcagcgcccacccugcgccagagaccagauaaa\n", + "aagugcapacggaggccgaagcggagcggucuapagccgcggccgcpucacccggcpuagcaguugcugagugucagcuagacagcagcgacuapcucpcgccggcgag\n", + "gagcgagguuucaccaggcuggucuccaacuccugaccucaaaugauccacccaucuuggccucccagagugcugagauuacaggcgugaggcaccacuccug\n", + "aguccugcuucucuucccucucuccuccagccucucacacucuccucagcucucucaucuccuggaacc\n", + "agaggupaguuggcgcugcpccpcpccgcggaagcugcgaugcggacapcagcggcggugacccgagcugccgcccgac\n", + "aguuggcgcugcpccpcpccgcggaagcugcgaugcggacapcagcggcggugacccgagcugccgcccgac\n", + "aucucaaggcuuuugagaggagacuuacugaauauauucauuguuugcaaccugcuacuggacgcuggaga\n", + "uaaaccaaapacuuggagugcagauggcauccuucgguucuuccagacaagcugcaagacgcugacc\n", + "aaaccaaapacuuggagugcagauggcauccuucgguucuuccagacaagcugcaagacgcugacc\n", + "gaupcgaagcupaggaauuucaaucccpagcgaaguuagagcuugaaggacggcggcggcugcpcgcagccccggaaccgaggccpcpcag\n", + "aaucccpagcgaaguuagagcuugaaggacggcggcggcugcpcgcagccccggaaccgaggccpcpcag\n", + "agacagagucucccuguguugcccagacpucucaaauuccuggacuuaagcgauucuccuacguuggucucccaaagugcupauuacag\n", + "aaauacaaagaguaugagaaagacguugccauagaagaaauugauggccuccaacugguaaagaagcuggcaaagaac\n", + "cgcgcucgcccaccgcccgcuccgcgcagcuccccgcggccgcucucgucgccgccgcagcpcgcgucggapagcccagc\n", + "guuacauaucuuccugugccccuucucccuguapugaagcucupccucggcuuuuggupagauaaaauccauugcugcuaaguacuccgguucccagcuucugcaaaag\n", + "ccccuauauuuaucuuuaaccucaagugaauguugcugccuuuguaguucaugagcaauguauacucuugaauuccagcucugugaaaucgguagaaaaugag\n", + "uuuguaaaauuuuggagaapaagucggaacacaaggaaggaccgcucacccgcggacucapcuggcggcpacuccaggacccupuccagc\n", + "guccuccuaaaugucuucccagccccuucgagagaauuguggaagupuugccagaucaaacacaagacacccaguuaaaauucaacuguag\n", + "ggaaauucaacuacugaggagguuacggcacaaaaaugucauccagcugguggauguguuauacaacgaagagaagcagaaa\n", + "cucpcuucuuguggagaggcaggagagugaaggccugccgcpugaggccuccaguccacggacggccacaggccacugcggcuggaaucacag\n", + "caacgucucccucccacccggcugagaacagccuggaaucccugugcagaguuugccucacaccaggccuugagcagccgcapacgccgcuccccaccgcgg\n", + "ggacuuggaggcggccggcgcapccgcgagaggcuucgucgccgcugcagcuccpcucccapagcgugcgcggaaccuccaggcccagcag\n", + "pacuuggaggcggccggcgcapccgcgagaggcuucgucgccgcugcagcuccpcucccapagcgugcgcggaaccuccaggcccagcag\n", + "cgcapccgcgagaggcuucgucgccgcugcagcuccpcucccapagcgugcgcggaaccuccaggcccagcag\n", + "uuaugaaagaaaaaaaauuacauuaucuugaagaacugcaggaguugaguauuccagaaaaugcaaugaaauaggucagcuacuugauuuuaaaagucaaauacuggaucuuuuauuaag\n", + "acaacgucucccucccacccggcugagaacagccuggaaucccugugcagaguuugccucacaccaggccuugagcagccgcapacgccgcuccccaccgcgg\n", + "ggcgcggucucagcucucggcupuucgucacupcgcpauuuggccgccgcpcuccggagccgcucgcucccgacacggcucacg\n", + "guucgucacupcgcpauuuggccgccgcpcuccggagccgcucgcucccgacacggcucacg\n", + "gucucagcucucggcupuucgucacupcgcpauuuggccgccgcpcuccggagccgcucgcucccgacacggcucacg\n", + "cgucacupcgcpauuuggccgccgcpcuccggagccgcucgcucccgacacggcucacg\n", + "ggcacucaguggcugaccugcpcggcagaggaugcuguguggagcggagccaccuucaucacccaccucuucaacgcc\n", + "aaaguacugaucugauuuccagcugacgcauucugccccuuuauuccaguagaggucagucgagcaucuggaagagaaaacaggcuguugaacuaugcaag\n", + "gaugccgagcccaggccgguuccggcgaaguuaaacccucggagcuggccucggacugcupcguuaccccuucggccacccccgcugacc\n", + "gaaguuaaacccucggagcuggccucggacugcupcguuaccccuucggccacccccgcugacc\n", + "ggaaccaacupacccpcuuugaagccaccuccapccagaaacuaauggagaggacccccuuccag\n", + "ccugupcccagcucaguuccacacagaccagugauuccacggaugccgccgcugccaaaacccaguuccuccagaac\n", + "agaccagaccaacaguaacaccaapcaggupcaggccuccgcccuccuccccuacuccapcccacugcagccucagcccaggagccaccagaucucccaacacc\n", + "aaauggaugaaaagaggcugcuggauccapuugaagguucauaaaggccucupauuauacucugaagaacccgcagacggaaugccugagugacugaagaaa\n", + "cuccugcuccgucuaggagucaaaauggcggcgapaaccuggagcagucccggagccugagccacugacaggagaggagapcggcggcggcggcggupaggagg\n", + "gaaauggaugaaaagaggcugcuggauccapuugaagguucauaaaggccucupauuauacucugaagaacccgcagacggaaugccugagugacugaagaaa\n", + "uuccaccuuccaaggagcuuuguauucuugcaucuggcugccupacuucccuuaggcaguaaacaaauacauaaagcag\n", + "gcggaacgguuucugacaaccggcguggaggcguggccacagccgcccagaaauucuacccaagcucccucagcacc\n", + "ccuccgapccugugaccucccacaccccuggcccgcuccgucugccccgupcuccugccaccguccccg\n", + "gcccagaggcacaucagugaccuguaugaagaccuccgcgauggccacaaccucaucucccugcuggagguccucucpacagccug\n", + "gcugucuagccuggagcagccgguucccagcgcaggaapcagcccuggcggcuccgcguggcggcu\n", + "ccccacuccaaugaggucacaauggcuggagcucugapcccaggcucccugagccaggaggagaggagaaaguccaaggaaag\n", + "agcgcgaggagcgcpcgaccccpccccgccaggccacagaccccgcccagcggccagcacccggcgcaggcccggcagccgagcugcgcggcggcacc\n", + "gugaaagcacugaaagagaagauugaaucugaaaapaaagaugccuuuccaguagcaggucaaaaauuaauuuaugcag\n", + "gcaaaauccucaaugaugauacugcucucaaagaauauaaaauugaugagaaaaacuuuguggugguu\n", + "guccugcuucuccucccucucgccuccagccucucacacucuccuaagcccucucaucuccuggaacc\n", + "gcugguucuucagaggaaucaucccugacugugucaucacucugagcucugacugcgcuccccucccccaccagupaccaguacucaagagagcucuggagugcuccugaagagaaauucc\n", + "gaccupcuaugcuccugauuuuauacagacugccauggcuccagauauaaaagaccaaauaaaaag\n", + "auaagaauugcuggcaacauaugcacuaaacuucguuuugaaaaauccccuugaugccgaucacugagaagugauccacag\n", + "gauccuuggcguggagucuuccucccuucucccaagucuuucuccgugaacuuuuccuccuggacuuugcuaaagcagaaccucccagcucuuugcugucuccgguugucucuucccuguauuc\n", + "caauaugaagagcuacggccaaguucaugcagucacaggcaaugacaacuauaucaccaaugcugccuggcugagagugauuuaagacaucauugauuggaag\n", + "cggccaapcggcapccagcccgccpuccccgccgcgcucuuuguccuggccgcgcgcpcggacgcgugcacccccagg\n", + "gagacapacagacguaggccaagagapaaccagagaggaaccagapagagacagagcagcaagcaguggauugcuccuugacgacgccagc\n", + "ggacuupcggcgccuggauaaacaccugaaccugacugagcuccgagccapacucpugccupcagacgaggccggcuucuccgcggacagcuapagaguguccugg\n", + "aaucupaggcpuaccpccucacggauccgcgccgcgccccccaccuguggcugcgcgcpupcugcgcuccccupcggcgccpcgcccpcugguggcgag\n", + "gcaguggaaaguuggagcugagguguguggcaggcagaugapagcagagaacugcugaacagagugagacucagaggacgugguugagc\n", + "gguguccaugacugapcapuguauguaaggcuuuguucaccucacuggacuuuaguuuuauagugacuuuauugaaaauauccugcaguaaugcaaaaacacuuacuuuuuaggaguuagaa\n", + "acgaaguuucacucuuguugcccaggcuggagugcaauggcacaaucucagcucacugcaaccucugccucccpuucaagugauucuccugccucagccuuccaaguagcupauuacag\n", + "gcuggagugcaauggcacaaucucagcucacugcaaccucugccucccpuucaagugauucuccugccucagccuuccaaguagcupauuacag\n", + "uugaugcuauupcccaucucaagcugaucuuggcaccucucaugcucugcucucuucaaccagaccucuacauuccauuuuggaagaagacuaaaa\n", + "guccucuucuccuapcccagccucuguggcccugugaccugcagguauupagauccccagcuaagacgccagguccuccuggaagccuagaa\n", + "cugcaggucucgucuucccuggucuguguccucuucuccuapcccagccucuguggcccugugaccugcagguauupagauccccagcuaagacgccagguccuccuggaagccuagaa\n", + "aaaccggagcugupcgcggcgcugcucugccguupugaggcgcggagcgaagugaapuggcccaggupccaggcugacugaa\n", + "uguaucuccuagcuauggacuaaauaauacauppaaauaaacaaguauucaugapugaaaaugugacccagcaggaaaauuacaacuauuuucaauugacguugaauagg\n", + "upccaggcugacugaagugaguagupugccagaccaggugcgucugccgcuggauugugauaggaagcagaguguucgugug\n", + "aauuuauccaguuggcgaaggacuuugaggauuuccguaaaaaguggcagaggacugaccaugagcupaaauacaaggaucuuuug\n", + "guacgucacaccguagapacggcgcpaggaauaaauuucucugugauugguuggugaagguuuucaaaccggagcugupcgcggcgcugcucugccguugg\n", + "gupcgcggcgcugcucugccguupugaggcgcggagcgaagugaapuggcccaggupccaggcugacugaa\n", + "guuuucaaaccggagcugupcgcggcgcugcucugccguupugaggcgcggagcgaagugaapuggcccaggupccaggcugacugaa\n", + "uuuucaaaccggagcugupcgcggcgcugcucugccguupugaggcgcggagcgaagugaapuggcccaggupccaggcugacugaa\n", + "cgcucuacuagccgacaguuuguugauggucccccuggaccuguaaagaaaacucguuccauuggcucugcaguagaccag\n", + "paaugaauccauaguugcaaaaacuacagugacuguucccaaugauggcpcccaucgaagcuguguccacuauugagacugugccauauuggaccaggagccgaaggaaaacag\n", + "guacuuuacaaccuuggaacagugacuccacccugaacagcaggcagcuggagccaagaacugagacagacagugupcacgccacagaguaauggap\n", + "gagagccaaaggaaaucaacauuugaauugacuacccaauguccugccccuguuucuguccuguagcacuuagg\n", + "gaagugaapuggcccaggupccaggcugacugaagugaguagupugccagaccaggugcgucugccgcuggauugugauaggaagcagaguguucgugug\n", + "gaagugaguagupugccagaccaggugcgucugccgcuggauugugauaggaagcagaguguucgugug\n", + "ggagcugupcgcggcgcugcucugccguupugaggcgcggagcgaagugaapuggcccaggupccaggcugacugaa\n", + "uuucucugugauugguuggugaagguuuucaaaccggagcugupcgcggcgcugcucugccguupugaggcgcggagcgaagugaapuggcccaggupccaggcugacugaa\n", + "agacugucacuggaacaccugcaugaagaauguucuuucauuuuuuaaaaacgauuuugcauauaugauuuauuucagcuuucaaa\n", + "ggaugugccaagauggcugcggcggcugaggugucugugcucgucgccagcgucpupcuuucgcccgcggcuccugapaucggucucagccgcgcgg\n", + "cuccaauuaaggaacagcuauauccugcuuccuucuguaagcagcaucgacuugugcaapuucaguc\n", + "uccagcuccaauuaaggaacagcuauauccugcuuccuucuguaagcagcaucgacuugugcaapuucaguc\n", + "agaccgucuugcucuguugcccaggcuggaccgcggugguauaaucauagcucacugcagccucgaacucauggacacaagugaucuuccuuccuuaacccccugagucccupacuacag\n", + "uaguacacaggugcuuagcucaagccugagaauuacugcaaucuaguaaggcggauuugaacuacugupaguucuauuuaggaag\n", + "auuucaucauguuggccagccuggucucaaacuccugaccucaagugacccgccugccucagccucccaaagugcupauuacag\n", + "aguugccauggugauuagagaaaggccgagaucuguccagcugcggugagaggaacgcugaaucgccgaagagaauuggcugcgcuuccuuguuugugagcuagaauuag\n", + "gcccuuucaagaauccuaugaaaguuguggaucaucuccccggaaaacacgcauauagaugugaacaucugccuaugguuuu\n", + "ggacccggcuccugccapuupugcgccgcugaacggauggcugapagccccgcggaucguuuaggaaagccggccag\n", + "gcauuccagaaaacagcugcaaacccugagagauauggcuggauuguugaccuccuggaguaguuaggccuuuauuuuuaguugcaaa\n", + "guacuuuaauuaucggacuaccagguuccuggcugaggapuuuuauaaauuccauaacugguuugaugaccgagccugguacccuuupacgaaucauuggaggaacaauuuacccag\n", + "apuupugcgccgcugaacggauggcugapagccccgcggaucguuuaggaaagccggccag\n", + "aguagugguauuuacagaugguupugacagaaaaaguaaauaacuacguuucauuacaguuuccuguuuccuucuugauccuucacaapaagauuuucuuuuuuagag\n", + "acacaggccauucagucccgaaucccaagacacugaagacucuguuugaaucagacucacpuuccuuccuagccacucucapacaggaaugcuucug\n", + "agaggagaaggcgccagaaccccgcpucugagcagcccagcgugcccauuccagcgcccgcguccccgcagc\n", + "gauuuauuccggucccagaggagaaggcgccagaaccccgcpucugagcagcccagcgugcccauuccagcgcccgcguccccgcagc\n", + "gccauucaccguggagcgcupapagucapccaggacucuuuagguggccccuccaucauuuucucauagaaaupauugacugaagcaag\n", + "ugauuuauuccggucccagaggagaaggcgccagaaccccgcpucugagcagcccagcgugcccauuccagcgcccgcguccccgcagc\n", + "aguccuuaguuacaaggcuccauccucacuuuguucgcuccucagucguccaggcggauuccuuuuucgccag\n", + "gcaccaaggcacagcuuagaguagacccgaguccugcucugcggaguucgucuucccagcgaagguacagaggcggaugaacugcugagacuug\n", + "auugacguauuuuaagauuuuuuuaacuucugaagucuagcaggccuguaagaacaaaaaucauucuguaggaauuaaaaacagaauccagucuugacaacauauccaca\n", + "cguccupagguguugauaccgguguugccauccccacugugcagaupaaaacugaggcacagaggauuaacuacaugccugapaacacagcua\n", + "gcuauugapcaccuacauugacaagaaaugccccuucacugguaauguguccauucgapcggauccucucug\n", + "cuucuuccaggucagugugcpccuuccacgcugccagcggaacacuggaauggcggaapaacgg\n", + "gucugcgcgucuguuguucccagcgcucugcgaagccugaaaaggaggagcaaccuguccagaauccccgcag\n", + "gcagauguaggcaccgguccgagugccugcccucuguccccgcggcupucucgucugcuccgguuccupcuccuaauucuugguccagcuucuuccag\n", + "gcacpcgcagauguaggcaccgguccgagugccugcccucuguccccgcggcupucucgucugcuccgguuccupcuccuaauucuugguccagcuucuuccag\n", + "gcaccgguccgagugccugcccucuguccccgcggcupucucgucugcuccgguuccupcuccuaauucuugguccagcuucuuccag\n", + "cpagcggcpcggcgccgaggccgcpcppaggapccgcagccccggagapaaaaggcpccggacggcgccagcagccagccccgaggacgcgagcggcag\n", + "gaauuugcacuacacaaauugaaugcaguuguuaaugacuucupcagaaauuuccgaguccguagacaaaau\n", + "caaaaugcauugaucacuacaccaaacaauguguggaaaaugcagauuugccugaaggagaaaaaaaaccaauugaccagagauuggaaggcaucguaaauaaa\n", + "cucauugupcuucccaagguacucugguagccccagcuucugaccugguccuuucucugguaupauaggaggagagcuccggag\n", + "aaapugagapcaggupcuapuggagaccaaagcacugaugugacggaaccaucagccaggcaacuggaccugguggauccaggaagacuuucuggaagag\n", + "ccugcccagcapcggcggucagaggcpcagcaccccaguucuccccgcacgccggcacucgcggcugcuggagccccggcuggcucaccccpccpcagaauupcuccag\n", + "aucgacggaagugcaccugacugagcggaaguaggagcucucagaggcuaagaagguggagaccggagaagcugugagguu\n", + "aucgacggaagugcaccugacugagcggaaguaggagcucucagaggcuaagaagguggagaccggagaagcugugag\n", + "accugacugagcggaaguaggagcucucagaggcuaagaagguggagaccggagaagcugugagguu\n", + "agacgccupaacugcggccgcpcucgcgcuccucgccaggcccugccgccpcugccauccuugcccugcc\n", + "gaccagaauacgaggaggaagagguggccauaccguugaccgcuccuccaacuaaccaguaaguuaagacugcuguucaggaauuupaagcuggcuccagaaaagaaguggaa\n", + "gaggaggaagagguggccauaccguugaccgcuccuccaacuaaccaguaaguuaagacugcuguucaggaauuupaagcuggcuccagaaaagaaguggaaaugaap\n", + "gcauacuaccuggcgucuuccuacauuuauugcuccucupaaaguguaaagucuuuaagauggaaagcaugagaaaauguguaucua\n", + "uuaucauggapugagapugucagagcucagaacucccaccccagccuccccgupacaggacccag\n", + "gcaucaggugcuccgaaucucuguagccgaugaggcccagguacagaaggugaaggagcuggaggaccuggagcaccugcag\n", + "cuggacuucuggcpccugcccacccuggcucccccaucgacguccgagugcccuuccccagcauccaggcggucaagaucuuucuggagucccacggcaucagcuaugagacc\n", + "cccaggcaucaggugcuccgaaucucuguagccgaugaggcccagguacagaaggugaaggagcuggaggaccuggagcaccugcag\n", + "acuuucuggagacccgcccucgccaacauggcggcgcccaguupcpuucguucgcuucgcguuuuggccapcpucupcuuuaggca\n", + "gucaguuguggaguggcguagacgaguuaaguccuggucugcguggaggucgacgacuccgucgcagacuacggaccugucupucucagccgccaaagaccccguccgguag\n", + "gcguagacgaguuaaguccuggucugcguggaggucgacgacuccgucgcagacuacggaccugucupucucagccgccaaagaccccguccg\n", + "ggaggucgacgacuccgucgcagacuacggaccugucupucucagccgccaaagaccccguccgguag\n", + "gauuaaagaaggcauccagcaagaacugcacaagaaacggagucagccggagaacaaggaguggucuuccacugccucacaggagg\n", + "aguucugccucgcuucccggcgcggucgcagcccucagcccacuuaggauaauggcgacagcugagg\n", + "agaagcggcaucgcggcggcggcagcggcggcggcuacaccpcuuggcccccucccuccuccguuccccccuccuccccccuccccucagcgguggcucccaagaaguccgagacacgcg\n", + "gaucaacucacuauccugaagguccauucucccaagaagapacagaaagacagaucuauuuguaagaaaggcuupuauccc\n", + "cuacgcagagccagaccagcpaccacagaaupcugaggcggcggcggcuguuuggauaaagucaacagcpacgupcgugacgccg\n", + "agcccagcccaagacaccapcauuugcugacaucugaggcccuucccaggaagacauggccucguucuugguguggccacugaggacggcgcugagapaaaguc\n", + "cuccggcgcuupccagaguggugcpcggcgcguggcggcgauccccacgugguggcuuucucacgcuagcccucuuugguccuccuugacgucccpccugupcccgcuuucugccgag\n", + "ggugcpcggcgcguggcggcgauccccacgugguggcuuucucacgcuagcccucuuugguccuccuugacgucccpccugupcccgcuuucugccgag\n", + "agcccgagcgguggcggagcggcgagcagcgagcagcgccugcpagcggccggucggucpuccccgcgccccgcacgcccgcacgcccagcpcccgcauugagc\n", + "uggcggcugugugucgccggagccgaagcgcgcaggcccgucccgguggccpagcpcpupcgcc\n", + "cugucguccgcpcpacgcggcggcggcggcggcgguggcggcugugugucgccggagccgaagcgcgcaggcccgucccgguggccpagcpcpupcgcc\n", + "ggaauuuaccuuuguacuucacacggucapuugguggugacuacgupucuggagcugacugccguccugacacguccuagagcugcaagcag\n", + "acuucacacggucapuugguggugacuacgupucuggagcugacugccguccugacacguccuagagcugcaagcag\n", + "aucccucaguggugugcagaguuugcgcuggccagapuuccagaaaggacagguuacuguuacucagcccuacccucuugcagcccggagccuggcucugcpuugcugaugag\n", + "aucagccucuguggacucggugcuucuccuggcaaguaaaccccaaggaggacugaccaguucuugaauuucuauacc\n", + "uuugguguugcugucccagccagaaucgcgucuggccggupaagccpaacuccagcccccuguaggagaggagaaaggagcgag\n", + "agagcgcgagugaggagcaggcpcaggcggcpcagccpcagccguggacagaggcccpcacagccaguugcugugccagapugugguguccggcuacag\n", + "acaaggcagccucgcucgagcgcaggccaaucggcuuucuagcuagapuuuaacuccuauuuaaaaagaagaaccuuugaauucuaacggcugagcucuuggaagacuupuccuupucgcag\n", + "ggucucacuccauugcccaggccagagugcpauauuugauaagaaacuucagugaaggccpcgcgguggcucaugcccguaaucccagcauuuucggaggccgag\n", + "gcuggagugcaauggugugaucucagcucacugcaaccucugcuuccupuuuaagugauucuccugccucagccucccgaguagcupauuacag\n", + "aaucggcuuucuagcuagapuuuaacuccuauuuaaaaagaagaaccuuugaauucuaacggcugagcucuuggaagacuupuccuupucgcag\n", + "acagcucugcapaggaagcaccupucpagaagccupcaggcucuuuggagacgcucpcuccggagagcgugg\n", + "gaagagugguguuuuuuucuucuucuucuucuuuugugguuucacauagcaaaugagugacagucucuacuuacagacaaagugagacgucaggcauugagac\n", + "auagcuccauagaauucaguuucugagaaccagccagaagcaugcagugacauugcacaaucugccucugaagcuggagauacuagcugcagagcucapagcugcuccacaucaccgac\n", + "acaaucugccucugaagcuggagauacuagcugcagagcucapagcugcuccacaucaccgac\n", + "gccaaccgcuguuucagccccuagcuggauuccagccauugcugcagcugcuccacagcccuuuucaggacccaaacaaccgcagccgcuguucccagg\n", + "aapuaccugaagcgaauuggcaccaaagcagcagcuguauugccgcaguucuagcuucaccuucacg\n", + "auuuuguuuuucagcucacuucaapuaccugaagcgaauuggcaccaaagcagcagcuguauugccgcaguucuagcuucaccuucacg\n", + "guuuuucagcucacuucaapuaccugaagcgaauuggcaccaaagcagcagcuguauugccgcaguucuagcuucaccuucacg\n", + "ggacagagaauugcucuguuacccaggcuggaguguaguggugugaucauagcucacugcauccucuaacuccuggacucaagugaucguccggccacagccuccugaguagcupacuacag\n", + "gcauggaaguauuuugaaccgagagucaccaacagauaagaagcagaaaguugagcgcauugcaucacaugauuuugaccccacag\n", + "gucuuguucagcguugcguaaucauccagaaagaugacaauggauuupcugacggucaguggagacaauccagucuucguacagucugucaaagaag\n", + "guccuucuggcacuccucugguggaccgcccccaucggccacacuugcccugcucuccagugauucuguagcuccuggcuccguagucucgcggacagcucucuuuccuggaag\n", + "ggagguuccaaaauccgagguuugauuucagccugcccuugccagugccupccgcupagccguuauuggcugccguuaaggaccguuacguuucccgg\n", + "ugcccuugccagugccupccgcupagccguuauuggcugccguuaaggaccguuacguuucccgg\n", + "cagguccuucuggcacuccucugguggaccgcccccaucggccacacuugcccugcucuccagugauucuguagcuccuggcuccguagucucgcggacagcucucuuuccuggaag\n", + "puuucaggcguggagguuccaaaauccgagguuugauuucagccugcccuugccagugccupccgcupagccguuauuggcugccguuaaggaccguuacguuucccgg\n", + "ggucugcaggcgcgcgcucccgaggucccgccucgcccgcugagccggccuguaagcgcugcggagauupcuagaggcggaggccupccacggcggaggcgcugg\n", + "gccugcuggccggacguccggucugcaggcgcgcgcucccgaggucccgccucgcccgcugagccggccuguaagcgcugcggagauupcuagaggcggaggccupccacggcggaggcgcugg\n", + "ggcguggagguuccaaaauccgagguuugauuucagccugcccuugccagugccupccgcupagccguuauuggcugccguuaaggaccguuacguuucccgg\n", + "gccggccuguaagcgcugcggagauupcuagaggcggaggccupccacggcggaggcgcugg\n", + "gcuggagcgcaauggcucaagaucacagcucacugcaaucaagguauccucccaccucagccucccaa\n", + "aggcguggagguuccaaaauccgagguuugauuucagccugcccuugccagugccupccgcupagccguuauuggcugccguuaaggaccguuacguuucccgg\n", + "gcuacgcpcugccaccgccccpcgacccaauuucgcggccuagupcguacpccucuuuugaaagccugaguuacgauguauugagcgcgucguaugcggccagcacuaag\n", + "gguuggaggagcccggagcccgccuucggagcuacggccuaacggcggcggcgacugcagucuggag\n", + "pacccggccgguccggcgcgagcccccguccpcccuggcucggcccccagguuggaggagcccggagcccgccuucggagcuacggccuaacggcggcggcgacugcagucuggag\n", + "aguupagcaggcgacgccgacgcgagucuggcggcugcugcuugcgacugcggaggccpcgaggccggugaggacgcggcpcgagcgagaggccgagg\n", + "gcgacgccgacgcgagucuggcggcugcugcuugcgacugcggaggccpcgaggccggugaggacgcggcpcgagcgagaggccgagg\n", + "pagcaggcgacgccgacgcgagucuggcggcugcugcuugcgacugcggaggccpcgaggccggugaggacgcggcpcgagcgagaggccgagg\n", + "gcucgcpcggcgcagucgccgcagcagccgagucugacggcgccgguucgcugcccgguccgcccgcggugagag\n", + "ggagcggucccugcaacccggccggcpaacugccuucuaguuuuuagucucagaccagaccaccpcgcaccccg\n", + "aaggcggagcggucccugcaacccggccggcpaacugccuucuaguuuuuagucucagaccagaccaccpcgcaccccg\n", + "gucccugcaacccggccggcpaacugccuucuaguuuuuagucucagaccagaccaccpcgcaccccg\n", + "agacggcggcggcguggccgcacgcgcggcccggcuucuguccucgcggcgcuccggcuccuggccccccacgcc\n", + "guccucucuaggaapuapapcgucuggagaggaccccccgcgaaugcccacgugacgugcagucccccupcuguuccggccugcpaac\n", + "auuccaauggapcugacagcuucccgccuccuccagcugcuucaggcuaaaacccaggaugaggaggaacag\n", + "uguguccucucuaggaapuapapcgucuggagaggaccccccgcgaaugcccacgugacgugcagucccccupcuguuccggccugcpaac\n", + "ccagcgcgccuguguccucucuaggaapuapapcgucuggagaggaccccccgcgaaugcccacgugacgugcagucccccupcuguuccggccugcpaac\n", + "augugaccggaapcuccucacggacgccgucccuccucggcgcggccugagcgcccggcccgaccccggcc\n", + "guggucagcuguagcuggaugugugccuugaaaggcugacaaguuugcccugagugacucaccuacugucaccugauccaacaagauuugupcguagccugccgaupugacgccaguuaaag\n", + "ggucpaugccgaugccggcuuggaguuagagaugagucaccgcugagagcagcugcaguagcugagcaguggcagcagagaggcagacgugagcugapcgcagaggcaggcag\n", + "gaaacapucpaugccgaugccggcuuggaguuagagaugagucaccgcugagagcagcugcaguagcugagcaguggcagcagagaggcagacgugagcugapcgcagaggcaggcag\n", + "aucapauccccaaagaaagcaapaccaaggccpacugcupugaagguccpaggcugaguaapacggaagg\n", + "guugcccapcaaccgcuccuucaggcgugaauguggcggcugccucugcgaauggacggcgupaagag\n", + "ggugcgacugaggcguggcgucugcupcaccugaaggagacuupcacccgcgucgugccuccupuugugaggagucgccgcugccgccacugccugugcuuc\n", + "acgccgcggugcgacugaggcguggcgucugcupcaccugaaggagacuupcacccgcgucgugccuccupuugugaggagucgccgcugccgccacugccugugcuuc\n", + "aaggagacuupcacccgcgucgugccuccupuugugaggagucgccgcugccgccacugccugugcuuc\n", + "aaggcuuucupaaauaaaguccauacucupccaacgcgcaaauccucguccgcgagaacugcaaggcccgcaaugcccugcgccugcguggaccg\n", + "ugacaaaauucuaucuguucuuguuuuuugaaggaaaaauucaauugcucugaauauggaaauagaucuugcccagaaaaugaaagaucucupuguccgaguggcu\n", + "cucuguugacauuggcucuugaaggcaaacuucauaaugapaagagucaaguuuuguguaaccugaagcauauacagu\n", + "guccauugccagcacuugaguaaagauaaagaguaggagaaucaaagcuguuguauaauuaguucucuucucauccacacccauaaaccaguucaagaaap\n", + "cuccugcaaaugauaagaggcuugaggauacuucccaggaacuccugccuuuuuggaggugacucugucaguuaaagugugaaugaagaguggagcauaaaa\n", + "agaagcggagccgcgagucgagccgagccacugcccccgcugcccgcpcgccpupucccggcggcuggaupcagcggcggcgcpccgcpcggcg\n", + "gcccagcgccuccucgccagccccpugcgcgccaagcacgugcgccggcgcugaagcpucccggagg\n", + "gcgccgugcggucuccggacgcucgcugcucagcccgauccccgccaacugugcaggcggcugacccgcagcggcagcggcagcagcgaggacucgagcgcuggcugcagcgacacc\n", + "gaguuuucaagccgacuguguggcagcugagaggaguuuugcacguggaucgccguucpupcgag\n", + "aggcapuugcagcuguggacucaucacuaacaapuuuccuguauucccaggagcucagcugcaggaggcagg\n", + "ggccacguccaccggagcauccugcacugcapccggucucucgcuccagcagagccugcgccuuucugacucgguccggaacacugaaaccagucaucacugcaucuuuuuggcaaaccag\n", + "aaaauccccaagaauggaaaaacaggccugcaggaaaauaaagaggcapucaaaaugauggcuaagucaaguguucuguuguuuu\n", + "ccaccggagcauccugcacugcapccggucucucgcuccagcagagccugcgccuuucugacucgguccggaacacugaaaccagucaucacugcaucuuuuuggcaaaccag\n", + "aagacucauapuuucaggaccuugcagcuucucagcaauggagcugaguuuucacuuaggcaauuuguuuacugcuguga\n", + "paguuguucgcugucccugcccugcucugcuapagagaacgccagapaggcggcuggcccggcggcaggcucucagaaccgcuaccggcg\n", + "ccaaacugcaagcuuupaguuguucgcugucccugcccugcucugcuapagagaacgccagapaggcggcuggcccggcggcaggcucucagaaccgcuaccggcg\n", + "cuuuccacacuupcaaagcaagccgcgaggaggaaccagacaguccuguuaguuguggccagcccucauucccuggaa\n", + "augaaaggaupaccucaccagagaggacuggucucagcaauguccuuaaguggucaaaacaugcugcgguugag\n", + "ucuccacccacauuugcacaaaggaccaucaccuguccuuccuggaaucucuaaaguuuucugcuuuccuucuguccug\n", + "apaagcuccagcugucccucccgcaguuggcccugugguguuccgaagccgguuacguacggccugapccaggcgaaccucaggcucuuuguccuacuaaaaagcgcag\n", + "aaaaaugcaaacacaauucugcucacugguguauguuuuucuucaccaggaaauuaucucauucaaagcuagugcaacuuuauggagucuguauacagcggaagccccuuuacauugugacagaguuc\n", + "aguugaaagauguguuuuugugaguagagcaccgcagaagaacugaagacuguugugugcuccccgcagaapcuacc\n", + "uuauuugucuuccacuagugaaggaaggcacgaucgagacuuucauacgcuuuauaauaauucgucucacccuucccuuagagacucccucaauaucacguacucauggcuuucuaacagcugagaa\n", + "agagucagaaucacagguggauuaguapaguguuauaaaagccuugaagugaaagcccgcaguugucuuacuaagaagagaagccuuca\n", + "ucccagcuacucaggaggcugagaupaggauugcuggaccccaggagucccaggcugcagugaacu\n", + "agapcgcuggcgcpcugagccgcccpaucagcgcgagcacccagcccgccucggccpapcagcgcggcacugcpcg\n", + "aguauccaccccgcccgcucccggugacgugccagccccaggcccacgccgcucccgccccgcgug\n", + "ccpccuupcuccaccucucggccccacuuccgccpcaagcguuuguaggcggcgcugccguaaaucaggcggucugcuugccgcaucacgcaag\n", + "cuaguucuucuggagcucaacuucuugccaaccacapaccaagcugaccaaacagcagcuaauucuggccc\n", + "gugacauacuggagaucpcccaauggagcauccuacgcaaggacauccccuccuucgagcgcuac\n", + "gaccuauucaaacucagucugucucuugacuggaggaggagaaggaaaaguugagcacauugccaaccggaguuccccaag\n", + "aauggcaaguuaaaaccaaagugucagcaccucaacaacauuuuuuuuuggcuuaacaaaacaucaaacggcauacaa\n", + "augagacugaugaucugucacugucucccaucaccuagaupacugucuaguugcaggaaaacaagcucaggccuccugcugauccuauuuu\n", + "aauggcaaguuaaaaccaaagugucagcaccucaacaacauuuuuuuuuggcuuaacaaaacaucaaacggcauacaaaug\n", + "gccccgguggcggaggacgucccggaggaucccucuggucpcgccuggcuuuguguagccagccag\n", + "cuccgacagccgccpugcccugcaagcuguuccgcgcguccugcccgucuguccccgcpucgucgcccgccacagccgcgcc\n", + "augcgcccugcagcccugcgcpcccugcupcugccucugccuggcguugcuuugccupcggugcggacaagcgccugcg\n", + "agaaaggacaccagcuuggaaucaguucggaccugugucugcugcacagcugaaucccupaaa\n", + "auaacuccaacgcucaagcaagucaaggacacccacggacucaacaccgcgaccagauuggaaaaggu\n", + "aacuccaacgcucaagcaagucaaggacacccacggacucaacaccgcgaccagauuggaaaaggu\n", + "ccaacuggcucccugccccugcccccgccccuugacaucccagacucccuggcuauuuaaacagagaupugcccccauccgcacacuguccuuuggccaccggacauc\n", + "acucccuggcuauuuaaacagagaupugcccccauccgcacacuguccuuuggccaccggacauc\n", + "gccucaguggcuuuagaggauguggcugugaacuucacccgagaagagupcuuugcupuccuugucagaagaaucucuacaaagaugug\n", + "uuuguaaaacuuaaagcpcgcagcauuaacgcuucccgccccggugaccucucapucuccccgccaaaggugcuccgccgcuaaggaac\n", + "guauuuaaagcaugugaugaagaucacaaaggauaucucagcagagaggacuuuaaaacugcuguugua\n", + "aggcugccagccaggcupaaagcggugguagcugguupuugcupcucgguuguuguagucgcg\n", + "gcggupcguggccgcgguaggcugccagccaggcupaaagcggugguagcugguupuugcupcucgguuguuguagucgcg\n", + "gaaaacaacucacgaggcaaaaaaguacaucucguggauggagcapcgaagugguuacaaguacagacucuggagccagacugccupuuugaauugugcgguuucag\n", + "cuuggcuggucacagcacagugcuccupcccapcugugaucuccugucauuugguugccauuuuccugugaagapuagagaauaugcacccagucag\n", + "cuagcgccgcugugcccccuggcgcccccgagccugccuggucgagccacgcggaggcgcggcguuuccaccagccgcpcgucccpupaggacgapacucugcuuaag\n", + "gcuccuucgcuccugcuuucccggcucggupucccuucgcggccacccpagacgucuuagacagucgugguuccugugaucuguguccucuuugcagaag\n", + "uucuguguccaucucaugugcugcgugugucuguaaagccucauuccgugcugucuggcaggaagcuccaucucaucucaucaucucacggcccuggcacugccucagc\n", + "ggcucugccagcagacagccuuggcacacaggcacaapcuggagcccagagaugagagugcccaapag\n", + "augugagccuggcpcugcccgcuaaccugucgcugaagccccagaagcpcccucaggccaggccuacccugccuccggcccagc\n", + "cuuccccggcupcggcuggagagccpagucgcupugcgupcugccucgccgcgucucgccacg\n", + "ccucccccuuccccggcupcggcuggagagccpagucgcupugcgupcugccucgccgcgucucgccacg\n", + "ugugguuucuauuuguuggcgauuuugcugugugguagagucgugcucacccugcacccacgupccuuucuuagcuuaaaauggagaacaugccaccaccugccugacupcugau\n", + "aaauucuacugcaguggaguccaucuucacagucauaugagcccccugaaauugacuuccauaguucuuuaccuucaaggucuuauuguug\n", + "cgcugcgcguguuucuggucgcgcggaccpagcuacccggugagaaguccuggugcugguaccgaccugcugucccugcagcucuccu\n", + "gcupucucuucugcgucagucgccccagccaaggcacacauuuuaugcupccccgucugucugccucggccuccagcaaggagcuccuc\n", + "ugucgcugcugcggucgcugcgcguguuucuggucgcgcggaccpagcuacccggugagaaguccuggugcug\n", + "acuuccgcugguggccuagagcpcccgguauggaggupcuagaggccgacgccagccagagagcg\n", + "aaauguucuuuupccagagucupcauauaugaaugcaaauccguguuuguucacaacuaagcccagcugagacgaucacuuuucuguaggccauuuguccag\n", + "aaugcccucuuggucgagugcaguggcucacaccugugaucccaacacuuupaggcugaggcaggaggauugcuugagcccagaaguucaagaccagccuggacaacaua\n", + "gagccaugaggagucacucaapuuuuaggcagagccgugacacaaccagagauacuacgagcaaagguuccggaacapcapcaggacag\n", + "guuugagagcaauggcgcgauuucggcucacagcaaccuccgccuccupuucaagcuauucuccugccucaacaaccuccugapcupauuacag\n", + "acaagaggccaugugaggacacagagaaagcagccguuuacaagccaagaagagaggccgcaucacaaaccaaccuuuauggcaccuugaucuuagacuucuagcuccagaaca\n", + "gagaugcaaaugaupaacaauggagcccuuguccccaggccauuuguggcagauccupcuccapaggcaaagcuccucugccucugcc\n", + "gcaggcgcccaagccgccgccgccagaucggugccgauuccugcccugccccgaccgccagcgcgacc\n", + "acacagugcaggcgcccaagccgccgccgccagaucggugccgauuccugcccugccccgaccgccagcgcgacc\n", + "pagccuauaaaagcuggugccggcgcgacccgcggacacacagugcaggcgcccaagccgccgccgccagaucggugccgauuccugcccugccccgaccgccagcgcgacc\n", + "aaaauguuuucagcuccuggaggcgaaaggugcagagucgcucuguguccgugaggccpcggcgaccucgcucagucggcuucucgguccgaguccccgg\n", + "gauccccuuacccpcgucucggcugucgcgcccupccpapaggcugcaggaagcggcggauccggcggcggcggcgapcccpupuggccgaacuucucccgcc\n", + "caucaguuccuccuugupuccgaggcgcucugccgccggccccuccucacuucuuccucccup\n", + "pauggauccaagcuauuguccugcccauggcuucccaucucaggacccucucuggccgcuaucaucccagcaguggaguucagcccacuacucugaaccag\n", + "gcacuucugacucgaguccccgccgcgcuugucgucgccgccgccpauccgcagccccgcgcc\n", + "aguacacugucucuacaggccaggaaagaguugugugucuuupucccuuccgcuccgccuapuucccggccaggccgagagaccaagcapacc\n", + "agcccagguagccgcgccgcaggcucpcgucgcgaccucgcgccucpccgcgupcacggcggccggcpugcucccggcugcugcugcugcccaacaaggag\n", + "gcgccccggccpccacupccacaggccacgcggccacgcaguccgagcpagccgagccpcpcgapcagcuccg\n", + "cgcucggcgccccggccpccacupccacaggccacgcggccacgcaguccgagcpagccgagccpcpcgapcagcuccg\n", + "gaacgucccapauggaagugcuuggaugcggugcugcuggcugcggaugugcgcaaggagaupauggagagccugaguuggcauucguauaaaugaccug\n", + "ggaaggaacgucccapauggaagugcuuggaugcggugcugcuggcugcggaugugcgcaaggagaupauggagagccugaguuggcauucguauaaaugaccug\n", + "ggcgccccggccpccacupccacaggccacgcggccacgcaguccgagcpagccgagccpcpcgapcagcuccg\n", + "ggccuaaggcupccgacggcggcggcagcapagcupaagcggagaagccpagcgcpcucagucppcggcggcggcggcggcuccp\n", + "gagagaagaggcpaguggaccuggucagcccuaccccacugaccccaccggacccaggcgcggccuccgccacagccacagccccugccccugcugcggcgcggcgaggcgaggcg\n", + "ccuggucagcccuaccccacugaccccaccggacccaggcgcggccuccgccacagccacagccccugccccugcugcggcgcggcgaggcgaggcg\n", + "aaugapcagcagccaaccaccuggccagacccagccgccucagccagccuuagaaaggcuuccacgauaguccaccuggccugcccacg\n", + "ggcccggucggacuaggacccgcggccugagagacgcuggaggaugcggacgcggaggccgccupuagcggcggcpaguccuggcgcucugcag\n", + "acaguggauccggaagcacaggagaccaagagaccagagauaccaggaugagagauaggaccccugguugccagguucgagaaguccuaggcugagucccuggaaa\n", + "ugccagccgccaguggucgcacuuggapucucgccgccaguggaaggagccaccgcccccgcccgacc\n", + "agugccagccgccaguggucgcacuuggapucucgccgccaguggaaggagccaccgcccccgcccgacc\n", + "auauaguaacauagugugguacuuugucuugaggagauguccuggacucacacggaaacuuapcuacgga\n", + "cauuugucggccccgcccccccgacucccaugaucaggacaupaaagacccccpugacaauccacuuuuccuccccaguacgupagcccuagaggac\n", + "cacgcgcccgcccccagcuucgcgcccagaucgucgccuauccugcuugcgcagccgcuaucgcgucugcccaccgacgaagc\n", + "gcagcuggagagaaguuaggcagguccuapapcaggcucgagugcupcccgccuccccgcpacuguaggcccpcuccgccucgucgcagcggcag\n", + "gacgcagcuggagagaaguuaggcagguccuapapcaggcucgagugcupcccgccuccccgcpacuguaggcccpcuccgccucgucgcagcggcag\n", + "aaauggaaugaauccccaagauggcuuaaggaugcccuucuguuuuggaaugcuuucucuugguguauaucaagguugguucaguuuaccagagaaaagaugccag\n", + "ggucucauucugucacccaagcuggaguccagugacauggucacagcucacugaagccucaaccuccuuggcucaagcaauccuuucaccucagccuucuaaguagcuaggagcacag\n", + "agucuugcucugccacgcaggcuggaguacaguggcacgaucucagcuuacugcagccucugccucccaag\n", + "cucuacaucaapucaggaauauaaagaagagaaguggccauuuucuuaauccagucuaucauuguuggacauuupuugguuccaagucuuugcuauu\n", + "ucaaaaaguggauagaacgcaaacaacuugauuauuuaggaauuccucuguuuuauggaucuggucugacugaauucaapaagaag\n", + "gguccccuccucggccgccccccgcccggccgcccgcccucpccuccccccpcccucgguccccucccccgcuggcpcccggacagaag\n", + "pcpuccgagccggcuggcgcaggugacccgcaguuacccpcucgguucccacguaaugcupaaaccccggcugacgcgccccucccccgcccgcagugcggcucggcggaguac\n", + "acguaaugcupaaaccccggcugacgcgccccucccccgcccgcagugcggcucggcggaguac\n", + "guccugugugugccacapupuguccagcgagcggucuccuccuccugcuagugcugcugcggcgucccgcggccuccccgagucpcpapagagcpuguggauuugucuugacg\n", + "gcuguccupuagaapuuuggcagcccuapagaugaauuucuccagcguuggacccgcccagagcggagaagcaacacccuuccagccacuacucuguugcuaugaaacaaaagacuaggaag\n", + "upuguccagcgagcggucuccuccuccugcuagugcugcugcggcgucccgcggccuccccgagucpcpapagagcpuguggauuugucuugacg\n", + "pcgcccpcgccuucuucccgapacgccaggaccgcucgcupcucccgcggccgccucgcag\n", + "gugcugaggaaccucuaaucaucucccauggauuugugaucagcguugcagcucucccagcagcccuggacagug\n", + "aguguupaacggccgcuucccguucaacgcuuuauugapcguauccuaguggcccccauccggucuccguuuuggaagacccgccucggcacagccaggcucaguccggccuugcg\n", + "agaapcgucpcggccgucpacggaagccpaggcgcugccgaccgcgccugcgacagcgucagcccugcgcggagcgccggcccg\n", + "ucaaugaacagucugaaacauugcuuuuuuucucugguacauuuagguccuuucugaaaugguaucuaugauucagcuauucaaaaccuaaugaaguuggugacuaugacaauguggagaaauc\n", + "gacauuacauuucacuugguuacagcugacupauuuuaaucauuuggagccacacugaaaaaaaaauuucccccugcaaucuacucuuaacugauagucgcuaacuuugguuaugugug\n", + "guccuuucugaaaugguaucuaugauucagcuauucaaaaccuaaugaaguuggugacuaugacaauguggagaaauc\n", + "aucauuuggagccacacugaaaaaaaaauuucccccugcaaucuacucuuaacugauagucgcuaacuuugguuaugugug\n", + "paaggcggagcuuggacgagccgagaggcpcucaaaguuccuacccgcgagapaagaagcag\n", + "cuuccacacuagcauauuuaccugucugucuccagugccaagcucagcccccagcaccuguagauacacaauagaugucugcuga\n", + "aaaaaaagcgcggcgaaagcuaaaggccggcgcacgcupcggugguggucccuaagccpccgcggccggugca\n", + "ccuuaacuucugagcucaccuauugucuuupaagaagcagaaggaauaaucccauaacuacccucupcuucauuuuucauucuccucccucaaa\n", + "caguagacauugaaaccagagauugucuucagaauacauauaaucugaauagugugcuggcpagugguuugucggagcagccacacugauucgguguuuuugcag\n", + "ugcauucaacuucuacagaaguuaacauauaaugucaaaauuuucuauucuggugccaauauagaugaauuaauuacguuccugauagaucacau\n", + "aaucaaaaaaagcgcggcgaaagcuaaaggccggcgcacgcupcggugguggucccuaagccpccgcggccggugca\n", + "cpaggaguggcagcggcaaggcagcccaguuucgcgaaggcugucggcgcgccgcggcccgcaggcacccggcacgcgccuuccccgcaggcacccggcacgcgccuuccccgccgccacg\n", + "gcuucacgcaggccugcgaagcuggagccccuggauagccuuucuugccgacagaggcpagaaauuugcuacuuccuguauaccuuauccuucucccuucccagucuaagauacgaacuauaa\n", + "aguuucgcgaaggcugucggcgcgccgcggcccgcaggcacccggcacgcgccuuccccgcaggcacccggcacgcgccuuccccgccgccacg\n", + "cgcgccgcggcccgcaggcacccggcacgcgccuuccccgcaggcacccggcacgcgccuuccccgccgccacg\n", + "gcpccaggacgaaucccuccauccpagcagugguggcgguggaacagguggccupugcuggaggcag\n", + "ccagcggcuccpcuccgcuggcucpcgucggaucggagccgccpcgcpcggcccag\n", + "cagccpcccugccuuccagagcuccuggagcggccugucccccpacaccpacccaccugcagapcuuaccgcucaggagagcagaacaag\n", + "aucgacacccgagcugcugcpccaggacgaaucccuccauccpagcagugguggcgguggaacagguggccupugcuggag\n", + "agccpcccugccuuccagagcuccuggagcggccugucccccpacaccpacccaccugcagapcuuaccgcucaggagagcagaacaag\n", + "gacacccgagcugcugcpccaggacgaaucccuccauccpagcagugguggcgguggaacagguggccupugcuggaggcag\n", + "guuuggcaccugccgaucggugacaucgacacccgagcugcugcpccaggacgaaucccuccauccpagcagugguggcgguggaacagguggccupugcuggaggcag\n", + "guugcaggaaguuuggcaccugccgaucggugacaucgacacccgagcugcugcpccaggacgaaucccuccauccpagcagugguggcgguggaacagguggccupugcuggaggcag\n", + "aguacacugaaauucaaagucaugcucauaacuguuaaugaaagcagauucaaagcaacaccaccaccacugaaguauuuuuaguuauauaagauuggaacuaccaagc\n", + "aaacuagcuuccaguuaguacacugaaauucaaagucaugcucauaacuguuaaugaaagcagauucaaagcaacaccaccaccacugaaguauuuuuaguuauauaagauuggaacuaccaagc\n", + "gaccuuaaauauaucgagguggcuaauugauguauaauaauuuacaaaauuauucuucuaugcuacagagcuacaauucaauuuacaguaguaaau\n", + "gagcccuggcucuccpcagcuggapucgcgcugcgccuguupcugcaccucggaccapcuucugcugcaucugcagcc\n", + "ccuaucgagcccuggcucuccpcagcuggapucgcgcugcgccuguupcugcaccucggaccapcuucugcugcaucugcagcc\n", + "gugagcccuauucccagaggcagguggugcugacccuguaacccaaaggaggaaacagcuggcuaagcucaucauuguuacug\n", + "gcaacuuucauucccucugaaauaaaacagugcuuaggccaguaccuagucuguuuccaacugugcg\n", + "ucuucauuucccuauuuguaaaguuggagugccucccuguccccucacgucucauguguguacuccuaccaugcag\n", + "guucccagagapcuucuugaaaagcaaguagagcagaagacuggugagcacgguguuucccagcaucuccacagugccagcacagaggaggacacucaagaaauguuuguuaa\n", + "caggcgcagaaaggcacaggacucgcuaaguguucgcuacgcpcuaccggaucggucggaaaug\n", + "gcugaaguggagagaucgccugagcccaggaggucaaggcuacagugagccgugacugcaccacugcacuccacccugg\n", + "gcagagguggaggagacacugaagcgacugcagagccagaapagugcapaaucaucgucgugaacacagaag\n", + "cauuauccuguagcgupuaaauacgaugguuuuugacuuuaaaggacaauugagaacuggagacauaauauuacacagcuggucuucauuuccug\n", + "agucgagguggaaaaaaguuucuuccuguauugaaagaaaucuuggacapaucccuugucucaacugugugaaaaugaa\n", + "uguauguuuuaacuggaaaaagucuuccaugaaaacgucacuuuuaaaaaauaaguaaugccaucuguuuuccuaaaagacugaaaupcgaccauucuuag\n", + "ccuuugaucucuugcuuugaugcucaaacagaagaaugauacaagacugaggaucuugccaggcaag\n", + "cpcpccgcgugacgugccpaagccggagucuagagcuccpcgcpaggcgcggcc\n", + "gcuggaguguggugacacuaccuugacucacugcagcaucugccucccpuuccagugauucuccugccucagccucucagguagcupauuacag\n", + "gucccugugaugcupaaacugagucacggaggcpagagauguguuugaggaauupcugagaccgugaucucacccccgucaggccuggupcuccuuugacacucagcggcag\n", + "ugucuuguucuguugcccaggcuggaguguggugacacuaccuugacucacugcagcaucugccucccpuuccagugauucuccugccucagccucucag\n", + "gcugcugcuccggcgcggagcccagagccgguucggcgcgucgacugcccagaguccgcggccpcgcpag\n", + "acagugucuuguucuguugcccaggcuggaguguggugacacuaccuugacucacugcagcaucugccucccpuuccagugauucuccugccucagccucucag\n", + "gcuggaguguggugacacuaccuugacucacugcagcaucugccucccpuuccagugauucuccugccucagccucucag\n", + "ggcaggccccgccccccgcccacgaggaaguggcugcugcuccggcgcggagcccagagccgguucggcgcgucgacugcccagaguccgcggccpcgcpag\n", + "ugucuuguucuguugcccaggcuggaguguggugacacuaccuugacucacugcagcaucugccucccpuuccagugauucuccugccucagccucucagguagcupauuacag\n", + "aguggcaauaaccapcaauaaccaggcgugucccappagccccgcucugcagcccugugcgccguagagagcuggacuuaggcuggcagc\n", + "agaggaguccacupcuuggagucaguggcaauaaccapcaauaaccaggcgugucccappagccccgcucugcagcccugugcgccguagagagcuggacuuaggcuggcagc\n", + "guccacupcuuggagucaguggcaauaaccapcaauaaccaggcgugucccappagccccgcucugcagcccugugcgccguagagagcuggacuuaggcuggcagc\n", + "gucagucggagcggcaggucgcgagagcapcugguggccagcpagccucgcagaggaaagcaucagucuugcugaaauaagccuagaauuggaac\n", + "gugacagaguuaguccuugauaauugccugugugucaaupaaauugaaggccugaaugauacuuucaaagaacuagaauuucugagu\n", + "gccccgccucgcuuccagcgcgccgagcggagccuaacgccpuccucuaggaaccucpccpcagcacccgcpauucugcuggcguccuccgcugcc\n", + "acgccpuccucuaggaaccucpccpcagcacccgcpauucugcuggcguccuccgcugcc\n", + "aagccaggaaaugccuccugagagaggugaaggcagcgucucaguaugcaapaapauucapugaag\n", + "gcuauuggucacacuggcccagapcacgugacupaapcacaggcugguccccucccccuccuucucagguucaccccugccggcc\n", + "cccgccggcccagcgcaggcuccuccgacuccgccagcgcapcgcggcugccpacccagcagcpcgcgcgg\n", + "aacaauaaaucugagaaacccugugcuccagcaggugcuggaaggaaggaaugagguccugugcguuuugacacagaagaucacgacg\n", + "agcgcaggcuccuccgacuccgccagcgcapcgcggcugccpacccagcagcpcgcgcgg\n", + "gagaucgguuuccgauuccpuggccpuggcggcggcggcgcuccggucgcgaupccagag\n", + "gagccagcaaggccacccauccaggcaccucucagcacagcagagcuuuccagaggaagccucaccaagccucugca\n", + "uuucuuugauggaauaggcccuaggacaccuuucuaaaaagacucccugugguguucagaaucacuccuacagucagguucuccaca\n", + "cugaccucggugugugugugaguguggugaaaaucaagupapaaagugagcaagcaccugaacaag\n", + "gaaucaaagaucaacucccacugaggacaaauggaccuguaauuccpugugacgagagaacgagauuuaccuuccugaauuaaaaaacag\n", + "ggagagugagcugcgcccagccgcccagccagcccgccguucucuggccgccguccpcgcgcgcagcgagcpcgcgacuaugccaag\n", + "acaaaacccgagagaggcgugagcagcgcuguguuugcgagcpagcgapcgccggcupugugugcuccug\n", + "uuucuucuguagcugagcacuugcupapagugccaaacaucucaguguuuguguuuuuagaugcacuaaccaacaauagcaagcuuuucuccaagc\n", + "auuguggagagaguuaucugupcuugagaagcugcucugccacaccaguaaggaucapaaagaaaauacuuaggccacaccguugcagucuuugauugcaugccagucugaagcauuuu\n", + "aucuaugcaguuagaucaguuguucccaacaaaagcaauaaugaaauaguccuggugcuccaacaguuugauuuuaauguggauaaagccgugcaagccuuuguggaug\n", + "agagcuauaccuucccuaagauaagaaggaugaagagcuggcauucacuaacaggacccugaaggcaaaaacacupcaguuucacaaaaapaacaaguagucucucugaag\n", + "uuuugacgugaacuguucggacccucagugcuaccugauagaaaacugcauuccaggaaaggaacacagcugugca\n", + "ugcugcugcagcccccgucggcuccucuuuuccaguccuccacugccpcupcccggccgcpaaggaccgaapauacagcgugucccugcggcggcugcaagaggacuaagc\n", + "acugccpcupcccggccgcpaaggaccgaapauacagcgugucccugcggcggcugcaagaggacuaagc\n", + "cpcupcccggccgcpaaggaccgaapauacagcgugucccugcggcggcugcaagaggacuaagc\n", + "gugaagagaaggcagagaaaggacuuagcguccagugacuccaggaaaacgacagagaagcuucugaaaacauuuuugaaaagacaagccaucaaaacugccuucagaagcaaaag\n", + "agaugaagcacuacccagucuuacccaaguucgaagagaaaacgaccucuauguuuugccuccuuuacaagaggaagaaaaacacag\n", + "uuugaagcuuucuuaacucagaaagaaacuuccaacacaguuucccaaagaaaaaupcaccaapcaaa\n", + "auuuugauuuaguggauuugaggcapcuuucaucucuaacaaauucccaagugaugugaauaa\n", + "acggaacucccupuaggaguuugaagcuuucuuaacucagaaagaaacuuccaacacaguuucccaaagaaaaaupcaccaapcaaaguaagcaa\n", + "acggaacucccupuaggaguuugaagcuuucuuaacucagaaagaaacuuccaacacaguuucccaaagaaaaaupcaccaapcaaa\n", + "acggaacucccupuaggaguuugaagcuuucuuaacucagaaagaaacuuccaacacaguuucccaaagaaaa\n", + "uaagcaaaupcagagauauuaacugguaaaaguccaacugaucacccapuggacugaaucucucaacug\n", + "ucucgcucuguugcccaggcuagaguguaguggcgcgaucucggcucacugcaaccucuaccucccagguucaa\n", + "gcpcuggaggcuggcgccaggcgcggaggacucccgguaucuuuugacaggcuggcgccucggcucupacccgcag\n", + "gcccupauacaauaaucuggaaaaccagacuugcaggaugcagacguugaucauaugaacagauaugcacagaa\n", + "agaauugacucgcgcccucguccgccgccauaggccagugccpuuuaapccaggaaaggaagcauucapaauuuagguguagccagaagaaaaucag\n", + "gacucgcgcccucguccgccgccauaggccagugccpuuuaapccaggaaaggaagcauucapaauuuagguguagccagaagaaaaucag\n", + "gaguuuccuugagcaaugaacgauucgcgaauupcagcccccagaaucacagcagauuaacagagacuccapugccucguggucagaacaaauuuauagacaaaaaag\n", + "gcagaauugacucgcgcccucguccgccgccauaggccagugccpuuuaapccaggaaaggaagcauucapaauuuagguguagccagaagaaaaucag\n", + "augucccaucguccuagcgcggcagaauugacucgcgcccucguccgccgccauaggccagugccpuuuaapccaggaaaggaagcauucapaauuuagguguagccagaagaaaaucag\n", + "uucacaugugaccaguguuggaauauaaugugcgacucugccagacccuguuggcuacauuaagugucagcuuguguccaaaaucuuuggccaccaucacacccagagaauc\n", + "ggugupccgaagauaugcucaugugguguugaggaaagcagacauugaccucaccaagapcpagaacucacugaggaugag\n", + "agucgcagcpccaucuucggcpcgagupcucggccugugcaacccgcaccugcgucccucgcccggcccg\n", + "aauguaagauggcggaguagcaacgcaaagcgcuugguauugagucuguggccgacuucgguuccggucucugcagcagccgugaucgcuuaguggagugcuuapuaguuggccagg\n", + "caacgcaaagcgcuugguauugagucuguggccgacuucgguuccggucucugcagcagccgugaucgcuuaguggagugcuuapuaguuggccagg\n", + "agauggcggaguagcaacgcaaagcgcuugguauugagucuguggccgacuucgguuccggucucugcagcagccgugaucgcuuaguggagugcuuapuaguuggccagg\n", + "aacauuauuucapauacaggapuaggagguuaugaggcugucupaggcccgugagacccag\n", + "uuugcugaggaugauggcuuccagcuccaucuauuuccccgcaaaggacaugaucucauuccuuuuuauggcuggauaguuuucc\n", + "acaguuacagugcagaagcagaagcaaaagaauuaaccagcucuucagucaagcaaauccucuacucacc\n", + "cucgcuaacuuuccpcggaagaggaggaggaggaggaggaapcuuggagcgacuacppaugcggag\n", + "aagcagucaguucccugcacccagcaccucacagcccuuccuccgugcgcccugccpcggcgagcuaggcggcagcggcgcggcgcpcucggcggagcggccc\n", + "agugaaaauuuuapaaguagauuuuagccaaaugugaggaugguccgaauaauuaaaacucugaaaguggaauaagcuauuuucugaggcuguuucucuaucccu\n", + "gaaaaugugauaaagacaauacugagaaagauauaacucaagcuaccaauagccacuucacacauggagag\n", + "gcccgaagucuaccgagcccgaguggccuaccgagcccgaguggccccgcagcguccaggaggcgcccgcuccgcgguggcgcucuuggagguggugucggag\n", + "acgccgccuucpcaggcupaucuuccgaacupagcggagaguaapcucgaccccpacgcgaguccggccuucuggacuccgguucagg\n", + "agcugugaggucugguuccccgacgugcugcagcaagugccuuugcccugccugupcucccuccauggccaacucugcu\n", + "ggucucacuguguugucuaggcugagugcauuggcacuaucauggcucacugcagccuggaacuccupcucagugauucuuccacuuuagccuccugaguagcugagacuacag\n", + "ggagcuggagccggcgcggaggagcpcggccgcggcugugcccucuccuacuccucaccgcgcgagcgcpaaccaguagccgcggcugcuucgguugccgcggucgguggucguu\n", + "ugcuggcaggupcgcpccggcgcgagcugaccgagcacucggcpcgcggcpacugcggcccguggcggcgugcgcpaccugcgcugacuagguccpaag\n", + "cucugcacaguuccugccuucuaaguaacaaagacacagcaaggccgguuaugauuuacaaucaccacagcccucagauuaguguuucggagcugacgcaaccag\n", + "guggcugcgcuggagcggcagaucuuugacuuccupcuaccagupcucccauccuagccaacuuccugcacauc\n", + "aauugcucagcugccagagaagugacuggaauagagguuguagcuuaggcaccgcugcucccuccagucccuccgugcagccg\n", + "aauupaapaugaaggaggcugugccuccpuugcacgaagaguccgagucauuucucagaagguuuugauaggupccuuagaggagacgccgccg\n", + "cugcccugaggaguaaguaccguuaauaacuccauuuuacaguugaggaaacaaaugcccaaagauauguccgagucacagugucaugaaggacagaggcuggauucaag\n", + "gaaaaccugauuggcgcccucuuggcgaucuucpcaccucguggucagcauugcacuuaaccuccag\n", + "aaguacugccacauccgccuggcaggcuccaaggauccccpccuauuucaagaccaagacaugguggcupccuguuccug\n", + "gaauupaapaugaaggaggcugugccuccpuugcacgaagaguccgagucauuucucagaagguuuugauaggupccuuagaggagacgccgccg\n", + "ggaugaaggaggcugugccuccpuugcacgaagaguccgagucauuucucagaagguuuugauaggupccuuagaggagacgccgccg\n", + "gaugaaggaggcugugccuccpuugcacgaagaguccgagucauuucucagaagguuuugauaggupccuuagaggagacgccgccg\n", + "gguaggcagcccagagagupucaugccauccucgucpcauucagcuccuuucpuggccuccuugaggagcuccag\n", + "gugcuaaagcaapauaaaccaaaaggacagccaguaggugaggagaggccauggaauacccgccaacaagauaaucaucgcuggaauaauapaccugucugaauguag\n", + "acccuuucugcupagccucuuguguccagccuaggcccgcgugcagcgccgacggaugaccgucuucuug\n", + "uuagccaacpcaappcpaaggaggupuuucucccagccaaucgacpcgcgcccucguugccgcucu\n", + "gupaggauaaacgaauggaccaguugccuauccucccucccuggcaccccupaaaauaggucugcagccagaaaacugaaggucagagagg\n", + "aguugaaacugguugacaaccauuaaccupuugcaacuacagguggcacuggaagcagacugguuccuggac\n", + "gauguuuacggcggccgagguuggagcggcgcugcucggccgcggacacacgapacgcgcccgaggagcugcagguggcagcccaggcgguccgaacccgucggccggccgagccuggag\n", + "ggauguuuacggcggccgagguuggagcggcgcugcucggccgcggacacacgapacgcgcccgaggagcugcagguggcagcccaggcgguccgaacccgucggccggccgagccuggag\n", + "aaaaugucuucaugaggucugguggucuuuuucccugacaauuuguaucugguguuuuguaaagcauuaccauuuuauaugaaguuaaagcaguuacuuugaaaaaguuacaup\n", + "accaguagccgcggaccucggugaguacaaggugguppucgccagcagguucccucuccccggccccagcucuggacgcucaccccagugcaacgcccugagugacggaaagag\n", + "gucuggcggcuucucuguugacaacucagcugguuccacacccuggcaauugugaagaguuggccaaauguuuguccacugagcugaucuccucucuggagcaccpccaccaggapag\n", + "cccaggcuccgcggcuugcggccugcccpccucugcagcpcgccggcggaagupacaccaguagccgcggaccucg\n", + "cgcggaccucggugaguacaaggugguppucgccagcagguucccucuccccggccccagcucuggacgcucaccccagugcaacgcccugagugacggaaagag\n", + "gcugcccccaaguguaacuccagcacugugagguuucapauuggcagapaccaapacc\n", + "aagaggaaaagugacuucucaguaauagacugucaaauucpcugcugcccgaguguucgcuuuguu\n", + "cuucugcagacuacaguggcucaggaaccpaugcagugccaggcucaugguauccugcagcag\n", + "cgacccaucaggacgccagagcugcuucagcggugaccaccuucucccucuaacacauucuucccuucuucacaaacggcccau\n", + "auggcggcgcccagcagagucaggugcggacgacuuugucuguaggagcagcggcggcuugaggacccpag\n", + "acccucaagaaucgacccaucaggacgccagagcugcuucagcggugaccaccuucucccucuaacacauucuucccuucuucacaaacggccc\n", + "capcuuugaccagcuacuugagcgugaapcggcgcccgcacgaapcgucccagcuuggaggcpcccggaupapcpccgagugcaguaucccgccag\n", + "cagacccucaagaaucgacccaucaggacgccagagcugcuucagcggugaccaccuucucccucuaacacauucuucccuucuucacaaacggccc\n", + "agauggcggcgcccagcagagucaggugcggacgacuuugucuguaggagcagcggcggcuugaggacccpag\n", + "agacccucaagaaucgacccaucaggacgccagagcugcuucagcggugaccaccuucucccucuaacacauucuucccuucuucacaaacggccc\n", + "gaaucagugacauucgaagacguugccgugguuuucacagaugaagaguggagucgucugguccccauacagapaccucuacaaggaggug\n", + "gugcgcaggcgcguugguuucccgaccugaagaggcgccgucuucccpucccgagcacucugugccggag\n", + "accaacagcaaagccuuuacugccaagacuuccugugugcggcgccgcuaccgugaguucguguggcugagaaagcagcuacagagaaaugcugguuuggu\n", + "gccuguuccugaacuuccupaagucaaccuucuucggcaccucagaugaguucauugagaagcgacgacaaggucugcagcacuuccuugaaaa\n", + "gguccugcagagugugguucuccugucagacagccaguugcaccuauuccugcaaagccagcucucggugccugagauagaagccuguguccapccgaaguacc\n", + "gupcuugagcgucaguaguggcacucpaugguggcaucgcuuuacauccuapapacucucuuaccacccpauuaag\n", + "aacuuucpuuuucccugguaaagaaugauaagaacagaggcauacuaaccuugauccuguauccucugucccucaucagauguuuccuucca\n", + "aaggagaagccgugaucuggcuauauggupcgcpcggugucgcugupagcuggugcuguucucag\n", + "cugccuugaaaucccuuguugapccugcaaccuugugcuuccgaccggagacgccuuuggucccucggugucugcacuggcugcuggucaaggcuucaguguggaguaauugacacuuucgag\n", + "agaccauuauaaaacagaauaugaaaauaaacuacaugaugaacuagaacaaaucagauugaaaaccaaccaagaaauugaucaacuucgaaaugccucuapaaauguaugaacgagaaaacag\n", + "guuacugcauagugaaagcucucugaaacaaugcucuacuggaggcaagucuaacauacgcaaauuggaagaugaugacuugauuguaauuaucaccaupcuaaacagcggaaauu\n", + "auuugaagagcaccuacugcagaguuaggcuuaacuccacccaacagccaagucugaaaccacugacgguacc\n", + "gccgucccacguggaccugagccgcgccggucgcgcgcccgccagccugccgccupcupucacgaaag\n", + "acucauuuauaccaggaaacagacaagagaacaagaggcugccgaagacaaaacuucucugcaagcaccugugcacagcaaugugcgupcaucugugagaagaag\n", + "gaagcuucguauuucaguaauaauuuuguccuuugucaauuggaagaagaggcupaacucccuuuggaaggaacac\n", + "agaaucugugaaguuugagcaagcggccuucccaagauguaccgaauaucucaacugaugucaacaccaguagcaa\n", + "gacaagagaacaagaggcugccgaagacaaaacuucucugcaagcaccugugcacagcaaugugcgupcaucugugagaagaag\n", + "gaggcugccgaagacaaaacuucucugcaagcaccugugcacagcaaugugcgupcaucugugagaagaag\n", + "acucccaccagcucgcagcccuccuucggacccucgauccgagagcgccccagccagagcuugugccc\n", + "accaaccccgccaggucgcpcacucccaccagcucgcagcccuccuucggacccucgauccgagagcgccccagccagagcuugugccc\n", + "gcaccccucccccaggcaccaaccccgccaggucgcpcacucccaccagcucgcagcccuccuucggacccucgauccgagagcgccccagccagagcuugugccc\n", + "acugucucuccccauccpcagcpaauggcugagccapuucgccgcccccgccgccgccgccgccgccgccgccgccgccgccgcccgcuuucggcucpccucag\n", + "gaccguagcauccugagacauuuugaauugacacuucucaagauuugacuggaucagaguucauc\n", + "ggauugagccggaaguccccccagagcggaugccgcggcpccugupagcpucaucuucucucugcugcuguagcugcc\n", + "gaaagaagagauuacucacacuccuucgcaagcacagaaccaguuguacugagcuuuuugcuaagcuguuucagccaaga\n", + "guacgcgcacuuccggucuuuguggcuugcagcucpupuggcucauuuccuggccgcuccupcuucgcg\n", + "cgcgcacuuccggucuuuguggcuugcagcucpupuggcucauuuccuggccgcuccupcuucgcg\n", + "ggaaagaagagauuacucacacuccuucgcaagcacagaaccaguuguacugagcuuuuugcuaagcuguuucagccaaga\n", + "acaaacaccaaggaguggaggucagagugucacuuuuuuguuuucuuuuugaaagaucauucgagaaacacgucacug\n", + "cuuguacgacagaggugguuugcucuuccguugccccguggcuucagcucaucuuuggcaggaaggcgaggcuuccgcccggcacap\n", + "gaccccgccucagucuuccapcggcggupuguccgcuucucucugcucuucgacugcaccgcacucgcgcgugacccugacucccccuagucagcucagcggugcugcc\n", + "aupcaucggcaagaacpaccugcccugaccgccgcucaggaaugaauuuagguauuuccagagaaugacacaaucucuucaguagaag\n", + "agacgagguucucacaauguuguucaagcuggucuccaacuccugaucucaagcaauccucuugccuuagcguccugaauugcupauuacap\n", + "ggcgagcucacucucuggcaucaaguuccccgugcucaguuucccuacacaagaguccaagaggagag\n", + "agucccguggcgucggcpagcggcgcagcgcpccpccpacpacugucggcugcaggcggcc\n", + "gcagcgcccaaagaugacguguucugccagcgccacgucaugaggaagugccggcccacugaagccgupacgcgcccagcggagcuaaucag\n", + "acugaacugaapugaacuagaggagaagapugacupcpagcagcugcpagaagcaaapacgacugapaauaaucaggagaccacugaggcgugaa\n", + "ggugaacuagaggagaagapugacupcpagcagcugcpagaagcaaapacgacugapaauaaucaggagaccacugaggcgugaaguacuaggcgugcgauaacugaagga\n", + "agacgccugagucggagagacapcagagguugccaagcccuggcugccacuugucagguucccugugcuagac\n", + "aaacaucuaacuucaucaucuaguaccugcupaggacacugagccaguuuaacucaugccupugauggugucaagaagaggaaagauagccca\n", + "uuccaaaaccaucucccugucauuccuauaaccuccccuuuccauacuuccagaggaaucacaccc\n", + "auagacugaagaggagcaagaacagaaacapagccaguuacagaucuaucccaagaauucupagagaugauggugucugcagcagagugacagcaguggagauugagagaaaag\n", + "gaggacggcgagcagcugugcccagagcucupaaaguccccucucuuugcuucuuauaaauuaaguuccuuuccaccaguuapcaaguccgccaag\n", + "gagucupcuuuccgaggacggcgagcagcugugcccagagcucupaaaguccccucucuuugcuucuuauaaauuaaguuccuuuccaccaguuapcaaguccgccaag\n", + "guuuucaaaaaupaacauauugaacccuugguucuacaacuaccuucuuacaacgaaguuaguaugcagugcucuccaagucaauaaggaaagug\n", + "ggagccugagucupcuuuccgaggacggcgagcagcugugcccagagcucupaaaguccccucucuuugcuucuuauaaauuaaguuccuuuccaccaguuapcaaguccgccaag\n", + "cacaaaagcuaugcugcuccaaucaaaacugaaaaugcuuuuaaugucugagcaaucuuaagaguauugauuuaaguggacaga\n", + "gugaaugcgcagupugcgucggccacgaccuuuuggccagguuapapcgacgcugag\n", + "pcggcggcggcggaagcggaucgcacucucuuugupcaaccuugaaacgaaagugaccgaggagcuccuuuucgagcuuuuccaccag\n", + "agguugcaguupcgcucagcagcuguggcagccgguugaggucuggcaguagcguupcugaagcagcggaguucgcc\n", + "gucagaauauuaaauauaagcucaguuucuacaacugguuuggcagaaaucaaauccgaguuugucuacagugauucagapaccaggccuuucgcgaug\n", + "uuugaagauaauupagucugacagaacaauuaaaauugaauuauuguuucuaauagauuuuaagcccauucugcaguggaauuucaugaacuagcaagag\n", + "gaaaacaaacucaggaagaaaaagaaaagcagaagugaucaaggagagcgcucgaguugcaauauuuuccuuuggcugcugacaggcaguuacuauaaagcauugugcaug\n", + "gucucupucugaucaauaaugcugguguucccggcgugcuggcucccacugacuggcugacacuagaggacuacagagaaccuauugaagugaaccuguuuggacucaucagugugacacuaaau\n", + "aggaagaaaauauaaaguacacuuuuaaaacaugaagucuucauagcagcuuauagucguucagagaaacauguuccacugagaaugacuugagagagaggauuacaucauu\n", + "agaaugaugaaaaccgagguuggaaaagguugugaaaccuuuuaacucuccacaguggaguccauuauuuccucuggcuuccucaaauucauauucacag\n", + "cuggauccccaguuccuggugcugaauuccauccuuucuuccuaguucuguucuagguggcaagaacc\n", + "gcacuucgcgcucaagcgaccggaucuucaaaccgupaguggugcggcggcuagagucccuggacuccucaaccuapagcuacucgcgag\n", + "agugugcuuugaguagaagcugcacupccpacucggaggcgcgcugcgugagccggccgcagagcc\n", + "gugcuuugaguagaagcugcacupccpacucggaggcgcgcugcgugagccggccgcagagcc\n", + "gaacuccuggccugaagcgauccuccugcuuggauuccugaagugcgagauuacaggugugagccaccauaccucaacacuguauuuucaacccgcucuucguucaaucuccaaag\n", + "guaccapccuuuaaaaagguucagcuggccpcacgguggcucacgccuauaaucccagcacuuupagguugaggcuggcagaucacgaggucaagagaucaagacuauccuggacaacaug\n", + "guguuuccuggcgcauucccggccagcccgagugacucacucggccaaggaaacucccapcccgcccaggacccccaagccgccgcggacgcag\n", + "auucccggccagcccgagugacucacucggccaaggaaacucccapcccgcccaggacccccaagccgccgcggacgcag\n", + "agugacucacucggccaaggaaacucccapcccgcccaggacccccaagccgccgcggacgcag\n", + "aauguggcucagcugccccuggucccaucccapcagagcuccuccugaguacccuugagacuggagcagauucagcagaaggcagauugcccccucucccuggagcuggcucugaag\n", + "agucucacucucgcccagguuggagugcaguggugcgauuuuggcucacugcaaccuccgcuucccpuucaagcgauucuccugccucagccuccggaguagcupacuacag\n", + "acggagucuuguucuuguccaggcuggagugcaguggcaugaucucgacucacugcaaccucaguccuccpuucaagugauucuucugccucacccuccugaguagcupauuacag\n", + "pccgcaccgcccuucgcagccgccucugccgccgccgccgcguuggccucgccgccccugcucgg\n", + "acggagucuugcccugucgccuaggcuagagugcaguggugugaucucggcucacugcaaccgccaccucccgguuucccgugauucuccugccucagccuccugaguagcupauuacag\n", + "puccggapccpccgcaccgcccuucgcagccgccucugccgccgccgccgcguuggccucgccgccccugcucgg\n", + "pccgcaccgcccuucgcagccgccucugccgccgccgccgcguuggccucgccgccccugcucgg\n", + "pcpuccggapccpccgcaccgcccuucgcagccgccucugccgccgccgccgcguuggccucgccgccccugcucgg\n", + "agcggcgccucgcgcgucaggcaaucuggccaauugcgcaucuuuuccgccuaccgcacggccccgccccugccacaggaucgauuuacggccgcag\n", + "auaaagcugaggcucggccapacugugauauacccacauccccggaacuaggugaucgcggugcaggaaccag\n", + "cpcguccucaggaugcacugaggcugapapaggcggcggapucgaggucgcggucccucuccuccgagcgcccggcuggapapagucacg\n", + "agapaaucgagcguuugcaggcauucgagcuccugguuggupugaaggaauguuggaguagcgaggcapupauaauaaagag\n", + "guuuguuggagacugaaccguugcaaggaacagacgaagaugcaguagccagugcugacuucucuagc\n", + "aaauuuccaaggaaacuauauuucuuacauugauggaaauguauggaaagcauacaguuggaccgagaaacu\n", + "aauucucagagaaaauaacuugacugaauuacacaaggauucauuugaaggccugcuaucccuccaguauuu\n", + "agauuuauccugcaauaaaauacagucuauugaaagacauacauuugaaccacuaccauuuuugaaguuuau\n", + "uagagauggaguuucaccguguugcccaggcuggugucgaacuccugagcucaggcgauccgcccgccucagcuucccaaaguguupauuauaggcgugagccacugcaccuggcacag\n", + "gcugaagugcaauguugugaucucggcucacugcaaccucugccucccagguucaagcgauucuccugcuuuggccuccugaguagcupauugcag\n", + "ggcgaccacagcagccuccgccuccugcugcucaggacuauucugcgcupcuagucggcggugacccggacugcgcccggcaguggcuucgcpcgacgcgucgcc\n", + "gguccggaggccgapcgaccacagcagccuccgccuccugcugcucaggacuauucugcgcupcuagucggcggugacccggacugcgcccggcaguggcuucgcpcgacgcgucgcc\n", + "auuuupagcuucgagucaacaauaaaggaccgapugccgagcpaguggccucguugguaggacacpcccgagucgcgaggcuup\n", + "agaggagccgaguuagcucagccaggcggcgacuucggcggcgccacgagagcpcagcggaggag\n", + "cupuuccpccagugauccagcuccupccaucagccacggccaggcappcagcugccaccaaagcuggagguucuagaggacuug\n", + "guuuuccagccuucuccuucaggaggcacagcapacccugguggccucucugaccccuucuacccuccaagaagcgguucccuggcccuuggcgaccccagcucggacccugcauguucccag\n", + "guuuacauccgccpugcgcggcuucgccgcccgaggucguucggcucpuaccauccuccgcgcc\n", + "gcuucuagagcapcauccacagugacguggucuuuguaguacacpaagccauuccpugcaucgcugcguccupugcacguagugccuacuuugccaac\n", + "cpcpcpcugagcguguuuacauccgccpugcgcggcuucgccgcccgaggucguucggcucpuaccauccuccgcgcc\n", + "gagcguguuuacauccgccpugcgcggcuucgccgcccgaggucguucggcucpuaccauccuccgcgcc\n", + "guuuacauccgccpugcgcggcuucgccgcccgaggucguucggcucpuaccauccuccgcgccauggacaccagcgaccuguucgccagcugcaggaapaugupccgagugcg\n", + "accaugaacccguccugacccaggcucugaccuccuuccugcccagguaccugcuggagcagcgagacguggag\n", + "guccgguguuuucuuacccaccuccuucccuccuuuuuauaauaccagugaaacuugguuuggagcauuucuuucacauaaag\n", + "gaaacuuuuccuaaaaggaaguggcaauuuuaacuaaucuccccuccgccgcucccagcugccgcuccag\n", + "agacgcpcuagacgcuggcgcugagcaaccugaggccugcagacuccgacupccccupcpcpacggaccgcggccaaggcpcgcuggacgguggcggc\n", + "aggcugcucccggacaapcaacgagcguuucguuuggacuucucgacuugagugcccgccuccuucgccgccgccucugcaguccucagcgcag\n", + "auauuaaggcgccggcgaucgcggccugaggcugcucccggacaapcaacgagcguuucguuuggacuucucgacuugagugcccgccuccuucgccgccgccucugcaguccucagcgcag\n", + "guaguuccuuucccacaaucggcupcgaggcggcgccagcgaucagagcagcgcupuguucapccaag\n", + "cuacuguucccccaccuccuuugccuccagccuccauupagagcuguuccccaaccuaaaauggagucuapcacuccagcuggcccuccugaaaauguacuucccuugucg\n", + "gcggcccgaaacgccgccgcggagccgaggcggagccgcuguccucguccccagcggucccgcccaacgcccgacucu\n", + "gugacacaacuaaaaaaaaacaaagguauuuauggaauuccacugagugguaauggaugaugcaguucaaauaacuaag\n", + "gacuucuucagaagcuugccaguuuuucaagcugauuucucucacuggcaacucuucagagugcuguuccuacuccacccuccccuggug\n", + "gugcugaagagccauuggaugguuuugagcacgagacaucugauuuauguuuuuaaggaucacccuguuguuggagaauggacuguuuuaug\n", + "aaccggaaguagacguaccucacggaagccggcuuuggcccugcggcugcuaccgucgccgcggagaaauuguuggaucuggcagucuaggaaug\n", + "aaucuccucucagccuuuaagcucaccuggucagaauccuuggaugagccugupaccguuccuccuagcccggugguuuggaaccaguggcuuupacuguaagagg\n", + "ccgupugagaaupcuugcgaguuuacccccaccuccccagccaccagccugupucucaaaccaaggcuacuuggugcucugcuuugaguugcagag\n", + "gacguaccucacggaagccggcuuuggcccugcggcugcuaccgucgccgcggagaaauuguuggaucuggcagucuaggaaug\n", + "aggugacuucaucaaugcuccuaccccgaguucuugagacagaccuggaccgauccccuaccuupugugcacucuupagaacgapcggapuccg\n", + "guuaaccggaaguagacguaccucacggaagccggcuuuggcccugcggcugcuaccgucgccgcggagaaauuguuggaucuggcagucuaggaaug\n", + "accaacgaccugaccuccguccaccupcgugaaauucagcugccgcuucacccuucpagguccaggagcguugguacgcccugcucuacgauccugucaucuccaa\n", + "gcaucgccgcgguucugcucggcucgcgcuupcugccuggaggcucaagugccacccgacacggagaccuucauccgcgcugupcucgguguuuguguccacgcuguugacc\n", + "gugucaggcccauauugugucuggaguugguuccugcuggupuucguggucucgcugacuucaagaauggagcugcagaccuuccaa\n", + "ugguuuuuuccacuuuguugaauuguuccuauacucaaaauugcaccaagacaccuugucucccaaaugcaaaaugugaaauacgcaauggaauugaagccugcuauugcaac\n", + "aaauuuguacuuaguaaugacacacauuuguuugccugauucccagcucucuuaggauaggucuucuupaaaugcuuucauuucuaaugcaaagaaaauugugcaggcagccacguuaag\n", + "augauaaugaauguggaaauuuaacucaguccuguggcgaaaaugcuaauugcacuaacacagaaggaaguuauuauugu\n", + "ggcgcccggucccpuccacagccgcacucacuccgccgcgcucuccgccaccgccaccacugcggccaccgcca\n", + "gcuucgacggccgccauuuucuuucuuucuuagcuguuagcugagaggaagucucugaacaggcggcagcggcucuuauagugcaacc\n", + "gacggccgccauuuucuuucuuucuuagcuguuagcugagaggaagucucugaacaggcggcagcggcucuuauagugcaacc\n", + "cuuucuuucuuagcuguuagcugagaggaagucucugaacaggcggcagcggcucuuauagugcaacc\n", + "gcgcaagaauguaauagagcuucgacggccgccauuuucuuucuuucuuagcuguuagcugagaggaagucucugaacaggcggcagcggcucuuauagugcaacc\n", + "cggccagagcucccagaccccuacccacagccaggcpacgcgcacagucccuccacgcggaaagaaguaccuucgccggucaccggcuccugcagg\n", + "uagcuupucccpaaggagcupaggaccuaggcggccguuccgcggagcccggccgaggag\n", + "gucccuauguuaacuacuugagacaaaaauaaauauggccuucuacaguuauaauucaguucuggcuauugcucgaacaag\n", + "guagagacuuggcuucpcccuucuagcuupucccpaaggagcupaggaccuaggcggccguuccgcggagcccggccgaggag\n", + "agcuupucccpaaggagcupaggaccuaggcggccguuccgcggagcccggccgaggag\n", + "agagugacgucapcgaggaaagaggcggaaccguagagacuuggcuucpcccuucuagcuupucccpaaggagcupaggaccuaggcggccguuccgcggagcccggccgaggag\n", + "aggugucgucuccugcccgcgaaacaccacccaccguuagugupuccacagguuucgagccccuguugaaaaugucagcucuguggcuaag\n", + "cuccugaaacupcacuggucuccuggaaagupcgccauuaccuugcugccagccgcgccuucguugucggcauuugugaccuggcccgccupuccaccagagccc\n", + "acagaccagauggacccaagcucucuucccaugacccccucuuucccagagccucuauugagcugguggaagccgaagugucagaauuggagacccgucuggaaaag\n", + "agugcgccugcgcgcpuccggcgccgagguucuugacugcugugccggacgccagguguagcc\n", + "gcugucagugcgccugcgcgcpuccggcgccgagguucuugacugcugugccggacgccagguguagcc\n", + "cacuuccgucgagcagccaauauaugccucauucugcagcagguaaucuaagauagauguaacagaagcaauauuaagaauuagcagau\n", + "ucugcuguuuuaugagacaggcauuaguguccccacuuacaguuaaggaaacugaggcacagagcaguucaguggc\n", + "gcacucugcuguuuuaugagacaggcauuaguguccccacuuacaguuaaggaaacugaggcacagagcaguucaguggcaugaggucacacagcug\n", + "ccacaggacgaagucuucaggcuggccgccucccucpaaccupcuugagccaggugccgcccuauggaupag\n", + "ccagccupcaacaaguuguuguuuugaaaauccaucucaaaacaacaacaacaaaaaugcuuuauggaagaaaguacagaaagcgagaaapaugugaugaccaaagcapaauaa\n", + "gagugagapcagaggaaauacucaaucugugccacucacugccuugagccugcuuccucacuccaggacugccagagg\n", + "gcagcpagauucccggccggacuggcggacgagcgucgagagacagaagccgaggagaggaggcuaagccpcggcgcpagcgcacugagcaggcaaagucgcapccgccagc\n", + "gagacccuaccucccaccgcccugcccagaucuguucugcaacauucaccguucucugcauccagcucugcuuaucugcuguuaccuuggacaccagagcag\n", + "cupccacggacugccggaccguupcugugaggcagcgucucagcgaggcggcacccggagcc\n", + "gucccucgucccagccccpacuuagccgagcccggcuggcaaccccagccccagccgcggccgcccupacgcagacgccaaggccccuccggccapccpagccpccggccuagccag\n", + "ugugcuggagaugcucuaggaaaaaauugaauagugagacgaguuccagcgcaapuuucugguuugccaagaagaaagugaacauc\n", + "agugaggucpcagguucgcuguggcpcgccupccgccggcuguuuaacuucgcuuccgcuggcccauagugaucuuugcagugacccag\n", + "ggcagguucgcuguggcpcgccupccgccggcuguuuaacuucgcuuccgcuggcccauagugaucuuugcagugacccag\n", + "guuccggccuguaacggccacucggccgccacucccgccuggugcccuacucugcuguguuucgcaggcagcuucccaucguacgauugupcucagg\n", + "cuggcccupauuaggugcagccguguuaaggagaggacauucgagapcguggcgaagugaagaggaaccucacgccacugccuggagcuccg\n", + "guuaacccuggcccpccggagcccggaggcgcacgcacggcccpacccaggcgucccgcuccucgccpagcgccccuucccccga\n", + "ucuguucucupaggcaguaapccguggagcuggccucggccucggcaucpagaggcuggacuuccugucucucugugcuga\n", + "auaccuucucgaaacaaaagauuuuccuaccugcuuauacuugguaaccgapaauuacuaagacuucuugcucauuucugaguauugucuuuauauccugacacuauga\n", + "guuuupcugcgguuggapccgcaguugcagucapuccgccagcucpccagcgcaupcugcugagaccgcuccggacgugcgaagcguucgcggugcgguag\n", + "apuccgccagcucpccagcgcaupcugcugagaccgcuccggacgugcgaagcguucgcggugcg\n", + "gaacuuugugagaauuuuaaugcauggaaaagcuguccauguuccaacugcuguacauccaaaagucucaguguaauagcaggaccaaaauauucugucaaucagcugaccauauacuua\n", + "agagacacgaauauguuucagccgcaacaggcugcguuucagccggaagagugaaapcaccuugaaaacgcaaguuu\n", + "aucgcaccuggccaugaaggcuuuuagaupucuggagcuuggaggagaagucugaacuaaggauaaacuaaag\n", + "agaggccaaugagacuugaacccugagccuaaguugucaccagcaggacugaugugcacacagaaggaaugaagu\n", + "cggcucpcggacgcggcggcugcugccpagcgagccggcggcgcpcgagccgagcgcg\n", + "gucucupuugucuucuucucuguggagacugccgagcgccuccuagccacccacgugagcccgccccuggaugccugcaccuaccuaggcuuggacuccggagcccggccuguccag\n", + "ccuaugucuccagcggcagcuacagcuacaugaccuccucagccagugaguuccugcucagccucacacuccccpcuccupcccagauugugcacucccagguggag\n", + "gagcagcagcuucuggcggccpagcucuguggucagcugccugcuggapcccuguccagcupuccupagcguccugcagcacugccaccugcag\n", + "cccugacugcuucuuccucucccccagagacapcaggcacauaucucaacgugcccuggagugaauucuucaagaggacagguguucg\n", + "agccupaccugupacccugagacgcugcccgcagaguacugccuucccagcgcccgccucuuuccugugcuccaccccucgapagcupaccccaggaccugcugugg\n", + "ggucuugcugugucagccaggcuggagugcaguggagugaucauggcucacugcagccuuaaccuccupcucaagcaguccucccaccuuggucuuccaaagugcupauuauagac\n", + "accgagucgacccgcpccgcccpuccugacapaagaguccccpagcucugcggugccccpagcccacag\n", + "paaugcagcaguggaaucugugaugaggccucgugcauccaugguggcaccugcacagcaaucaaagccgacuccuacauuugccucuguccccuupuuuaaaggucgacacugugaagaug\n", + "cuuucaccuugaccauuccucaguucagagagucucugagaucuuacgcugcaacucccuggccacuggagccccagcauuaccuuuccuuc\n", + "cgaucauagaagccauugagaucccgcaguuuaucggccgcaguuaccugacguaugacaacccagauaucuugaagag\n", + "aucugcaaccagaguaauupauuugacaaggacugugaaaggcugacucucccuguucucuuucaugcuggcaccpcagagugupaacuacugccucaauaguaaguaca\n", + "aagccauugagaucccgcaguuuaucggccgcaguuaccugacguaugacaacccagauaucuugaagag\n", + "cguupccgcgucccccacgcgcccccggagacgcccuuuccgugugcgcccpacuuggugaaacuuugcaggcgccggcugcgaa\n", + "agagaaccacauacuauguaaccuccuuuuucuguucugucccagcgaucauagaagccauugagaucccgcaguuuaucggccgcaguuaccugacguaugacaacccagauaucuugaagag\n", + "cgaucauagaagccauugagaucccgcaguuuaucggccgcaguuaccugacguaugacaacccagauaucuugaagagguaauaagcuucaacaggcaccuuccucagcuuucup\n", + "agagccgcggucacgcgcccgcccgaaggcuccugucpacapcgccgccccgugucggcccccgcagagcucgcggcccccgccuguccpcgccgcc\n", + "aaccaagcgugucuccggcugcaacuccagcaagcgcgccgcugccgccuccacgcccgcccgccggccggccgagcc\n", + "gcaaggcauggagccugcacuuuacucugaauguugguggcgccuucagagcauuguuagcaapuccaugugaucacacugacaccugagagagugacacaccauguacauggcugguau\n", + "gccgccccuuccccgcgccgcagccgccucgccgccaccgccgcgagcucggccgccagugguccucggacuuuaggugucupuugaag\n", + "gagguuugucuccgaggaagacccapaacuggauaucuagcgagaacuuccuccggauuccccggcgccucpaaa\n", + "gucupcuuccgaauauguuuuaugacgguugauuuuacaccaggagguuugucuccgaggaagacccapaacuggauaucuagcgagaacuuccuccggauuccccggcgccucpaaa\n", + "cuuuuuaugcagauugaagcucucuuuccacaaaaauuuggaagauggaccgacuaugcaaaaagauacuguaaugcacacaucag\n", + "gaauugaauaccagcuuugaagagupaaaaaauaaugagaacuccaaauucaggugccauggagacagucaupuugauaacucgcauguuuaaacaaacugcuauugccaag\n", + "gcaggugcuguaaaggauuauauuaagaugaugcuucagaaugauucgcuuaaauuucugguuuuugcucaccauuuaagcaugcuccaagcuugcacagaagcagucaucgaaaauaag\n", + "acucguuacauuaggauagauggaaguguuucaucuucagaaagaauacaucugguuaaucaguuucaaaaggauccugacacucgcguggcuauccuaagcauucaggcugcuggccag\n", + "gaccuguaugacaagguggccupaaaagaacucuugucucaggacuuuuuauggagugcuucuguuuugucccuuaggauuaaguuugaag\n", + "ggacagccauuuugcccacuuguaaaagagcuaccuuuucccacgaguuggagccugaggugcggaguuucgugaguuuuuacugacucgag\n", + "acuacuguuugcuuuuccuaguucgaaaaagaaaaacagcaugauauucgaucauuuuuuguaccacaaccuaaaaaaagacaguug\n", + "uugucccguugaacgucacuuccgcuuapcggacacgucccaaaccuguggcpaguuggagauucugcggcgaauacgccaggugugacuggcuggaaguggcguggcug\n", + "accgccguccccaccgccauccgcccucccggccuggccugcccuugcgcccggcuccccagugcccgccgcccgcccgccgcgcucccgcgcuccguuccgcccaggccgcgcccagcugga\n", + "ucguauuuuuauccaaaagaaggaccuggaggaggaugagagcguuacugcugcacaccuaaagucaagg\n", + "gaggaagagaucuguggcugcpagaucucugcggauupcuccagccugacugacccgacagugcpuggccuapaggcgcucaga\n", + "ggaucagugacauucapauguggccauugacuucucucaggaggagupagugccugcagccugaucagaggaccuuguacapaugug\n", + "cucugcggauupcuccagccugacugacccgacagugcpuggccuapaggcgcucagaguaggaacccpugcagacpaucugccggauccccaggc\n", + "aaggucuucacgucugaggaagagaucuguggcugcpagaucucugcggauupcuccagccugacugacccgacagugcpuggccuapaggcgcucaga\n", + "ggcggaaguaguguaaccagcupagccagccggcaggacgcugugaguuggcgugcuagup\n", + "uuugaggaagaaaaugaagaaauuggaggaggugcagaagguggacapuaaaagaaagagacuuuuuucuaaagaau\n", + "accggcucgcggcgcguggaggcugcucccagccgcgcgcgagucagacucpupucccggcggcgguagcggcggcggcggugcgagc\n", + "aguggcggugaccaccggcucgcggcgcguggaggcugcucccagccgcgcgcgagucagacucpupucccggcggcgguagcggcggcggcggugcgagc\n", + "cgcagcucagccupcggcacagccagaugcgagaugcgucucugcugaucugagucugccugcagcauggaccupucuucccugaagcaucuccapcuggapacgacugccaug\n", + "cucagccupcggcacagccagaugcgagaugcgucucugcugaucugagucugccugcagcauggaccupucuucccugaagcaucuccapcuggapacgacugccaug\n", + "cgcagcucaaccugagcuacacagccagaugcgagaugcuucucugcugaucugagucugccugcagcauggaccuuggucuucccugaagcaucuccapcuggapacgacugccaug\n", + "gagcucggcgcggagcccggagcccgcagccgacagucuccugcucccguacgcupcgccagcuccggccgugcugcccggcugccugagagcgcgcccggcc\n", + "auccguggccacagcugguuggcgucgccuugaaaucccaggccgugaggaguuagcgagcccugcucacacucggcgcucugguuuucggupugugcccugcaccugccucuucccccauucuca\n", + "agccugacaugguggaaaacacagcaugcguggaccugguuauuucuagccuggcacccugaugacaggag\n", + "apcpcpaggcpcuggcgcuggagcacaucucccggcggcpccgcggaagcagugcagacgcggcuccuagcggaupugcuauugugaggcgguuguagaag\n", + "acagagucuugcucuguugccaggcuggagugcaguggugcaaucucagcucacugcaacucugccucccagguucaagcgauucuccugccucagccucccaaguaauuaggacuacag\n", + "acuuucacuuucgguccupagcuaggccggcggcaguggugguggcggcggcgcaapugapcggccccagaaccccag\n", + "gcaugaacucucuupuuguguuacccuguuugcuguuuacugucaagaugcugaaagaauguucuuauaaugauccaagaggaaguggcaa\n", + "gaagaagagcpaagaggcggacagcgaggccaagauuucagcugcpacggucapagaccuccaggcgcapaaggac\n", + "gcgaugacggcgccgccagcaggccaggcggacupcpcuccgagcpacupacccagaccgacuapacupagcpcggcgcggcc\n", + "acacuucuuccapccucuggcagccaggacagaguugagaccacagcuguugagacccugagcccugagucuguauugcucaagaapccuuccccagca\n", + "cauggugaauauaguucaugaugauauauugaauuauuggaaaaugccaagaaaauggauguuaaguguucucgccacaagaaugaugacuauaugag\n", + "paggagucccucuuuuuccauuguuugaaaucguuucagaaggagugauaccagguccucucuguaccuccggcagaauucagcugugaaacugacugguccupccucuuuuug\n", + "gcucpuacgcuccacgccgucgcagccacugcuguggucgccggucggccgapccgcgauacugguugcccgcgguguaagcagaauucgacguguaucgcugccgucaag\n", + "cgcucpuacgcuccacgccgucgcagccacugcuguggucgccggucggccgapccgcgauacugguugcccgcgguguaagcagaauucgacguguaucgcugccgucaag\n", + "gauguaaccauuacuaacgauggugcaaccauccugaaguuacuggagguagaacauccugcagcuaaaguucuuugugagcuggcugaucugcaagacaaagaaguuggag\n", + "uccacgccgucgcagccacugcuguggucgccggucggccgapccgcgauacugguugcccgcgguguaagcagaauucgacguguaucgcugccgucaag\n", + "guuauuauugcagcagaacuccuaaaaaaugcagaugaauuagucaaacagaaaauucaucccacaucaguuauuaguggcuaucgacuugcuugcaa\n", + "ggaagcagugcguuauaucaaugaaaaccuaauuguuaacacagaugaacupaagagauugccugauuaaugcugcuaagacaucc\n", + "auaaagagaguuuuaaugagcaaaaaacuugcagaaucugaaggaaaaggcugguauagcuguacgaaguggcagagcaugaaauug\n", + "agaggaggcggaguuucggccuucgccugcuggaaaagcaguaggaucggccaguggcgacagcaggagcugagccuaagcccuggcpcuuupcuguag\n", + "aaaggaggaaggacagcacagcugacagccgugcucagaaaguuucuggaucccaggcucaucuccacagaggagaacacgcaggcagcagagacc\n", + "ggcccuuccgcaaucggagcccucacagaggccaaacugauauaaaucugcuuaggaggccugauucacagacgcuacagg\n", + "aguucgcccguuccuggccugacccccaccaaggcccauaccgcaguaggcuccucpcugccccucg\n", + "uaagaugcggaggapugacgcacuagcucuccaguucgcccguuccuggccugacccccaccaaggcccauaccgcaguaggcuccucpcugccccucg\n", + "acuagcucuccaguucgcccguuccuggccugacccccaccaaggcccauaccgcaguaggcuccucpcugccccucg\n", + "agcucuccaguucgcccguuccuggccugacccccaccaaggcccauaccgcaguaggcuccucpcugccccucg\n", + "auauauaaggupaggccgccggcccguucgguuccpcguuaccaucguccgugcgcaccgcccggcguccag\n", + "paucucggacucccuggacccucccuccagcccagccucgcuagcuccgccugcgguacgugcucccgccuccgacucaa\n", + "aacuupagcucuguacuuuuaagagcuaaaucuauuuuuucuuccguaguuggcaacaccauu\n", + "aucguucuggcaggaacagccagupagguuccagcugagcgcuccccagaggugagcugauccccagccacagcacacaggaccaggcugcgagaacag\n", + "agaggcuggagagcagagcaccaagaucguucuggcaggaacagccagupagguuccagcugagcgcuccccagaggugagcugauccccagccacagcacacaggaccaggcugcgagaacag\n", + "aucauaaauacugcucuaagaaapacaggaagucucagaggcuggagagcagagcaccaagaucguucuggcaggaacagccagupagguuccagcugagcgcuccccagag\n", + "gucucugucucuccuccucccuccuccugcuccpcggagcccggcauppccggcgcccggcaggccag\n", + "uggauccpacccapapccgccccccpccugguggcacugagcapccccccagcccccaccuccugccccacgag\n", + "acuaapcucaucucugapcuccaugugacucugguggagagguagaucaugauuupcggcaauguuugcucacucuuucccuuacuagaguucugccauagaauc\n", + "agagucaucacuaapcucaucucugapcuccaugugacucugguggagagguagaucaugauuupcggcaauguuugcucacucuuucccuuacuagaguucugccauagaauc\n", + "ggcuccaugugacucugguggagagguagaucaugauuupcggcaauguuugcucacucuuucccuuacuagaguucugccauagaauc\n", + "aucacuaapcucaucucugapcuccaugugacucugguggagagguagaucaugauuupcggcaauguuugcucacucuuucccuuacuagaguucugccauagaauc\n", + "ucucugapcuccaugugacucugguggagagguagaucaugauuupcggcaauguuugcucacucuuucccuuacuagaguucugccauagaauc\n", + "gugacucugguggagagguagaucaugauuupcggcaauguuugcucacucuuucccuuacuagaguucugccauagaauc\n", + "ggcggcaaugaggucagugacugccpaguccugcapcpcggcgccaagcgcapagcccggcugaguggcagcccag\n", + "agugacugccpaguccugcapcpcggcgccaagcgcapagcccggcugaguggcagcccag\n", + "ggcggcaaugaggucagugacugccpaguccugcapcpcggcgccaagcgcapagcccggcugaguggcagcccaggugagcgcucapagcccpugapccpaacccag\n", + "agucgugacupcggcaaugaggucagugacugccpaguccugcapcpcggcgccaagcgcapagcccggcugaguggcagcccag\n", + "agaaggcuuuggcuucugauagucauggacucacuaggcugcugaggaagaucaauaauaccuacuggaaucagucaugagaagucaagcauggaaauugugaauuguguguguggccagaccag\n", + "augaucccugagcagcugaagaccagaaaagccacuaagacuuucugcuuaauucaggagcuuagaggauucuucaaagagugu\n", + "guguuuuaggaagagugucccgcagagacccggcpagcugccaggagcucupauuccagcggcuggaag\n", + "gaapaggccgugcapapaggccgugcapappccgugcaggcggap\n", + "gagagugagccgcaggcuucpaggcgapcppagcagcgccgaggccgccgccuccgccuccgccgccuaggacuapupacggacaagccccg\n", + "ugcaaguggugacccaggaugaaagagagcagcuguacacaccugcuuccuuaaaaugcucucugcaaaaugcccaggaagcccucauugugacauggcagaaaaagaaagcuguaagcccagaaaac\n", + "guggcccuggaugugugupaagaggucpccgagaauggcuggaagaaaauugaccccaugguuccagcuuuuuccaggagcccauuucagcag\n", + "acucugauuupaacccagacguugugcuuguuaacaggacaacuuugaguccuugcuaucuucaucuucacccucgauuuggagaag\n", + "cucggaagauauaaguuacaacccccagaagucuagccuagcgcuauuggaugguguccagcuuugccggaauuagagag\n", + "auagagaagcugagacacaaagaaguuaacaagagccagcaapacaggaccuggauuggagcccapucuaacuccagaaccagcgccaccagcucaggcacaaagcggcaguugcauagag\n", + "cucgccggcccgccccgaaccgccccgcgcupaauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "gaauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "cgcgcucucgccggcccgccccgaaccgccccgcgcupaauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "gccggcccgccccgaaccgccccgcgcupaauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "gcgcupaauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "paauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "cucccggauccagagcccggcggcggcgaagcagcagcugcggccgcgcccuugccagagccggugcguccgccuagccccgcuccgccugaggccgucapcucccgagg\n", + "puccggcccaggaggcuupcgcgcgcagccaucccpccucgccpaccuapacgcaggcaacgccugcgcccgcucacc\n", + "aggaggcuupcgcgcgcagccaucccpccucgccpaccuapacgcaggcaacgccugcgcccgcucacc\n", + "cuccucgcugcpaapuccupccccpcggcggucgccaggucucapccpuacccgag\n", + "ucucguuuccucucaguccauccacccuucaupccagagcccucucuccagaaucugagcagca\n", + "acauggccaauggccgcgcgcucugcccgccccgccuccucgcugcpaapuccupccccpcggcggucgccaggucucapccpuacccgag\n", + "guaccuggccaagcugucgucggupagcaucucagaggaggagacgugcgagaaacucaapccugauccagaggcaggugcag\n", + "gccgcguugcgcucccgccacuccgcgcccgcuauccuggcuccgugcucccacgcgcuugugccuggacggacccucgccagugcucugcgcag\n", + "gauuggaacaucaguuaacaucugaccacugccagcccacccccucccacccacgucgauugcaucucupcuccapauaaagcaggucuupugcacc\n", + "guugcgcucccgccacuccgcgcccgcuauccuggcuccgugcucccacgcgcuugugccuggacggacccucgccagugcucugcgcag\n", + "agaaagagaaagaccccaaguacuggcgagaccaagcgcaagagacacugaaauaugcccuggagcuucagaagcucaacaccaacguggcuaagaaugucauc\n", + "gcguugcgcucccgccacuccgcgcccgcuauccuggcuccgugcucccacgcgcuugugccuggacggacccucgccagugcucugcgcag\n", + "ggagcgcagcgcacccagcgaguccgucugucaggccgccuccucuccggccgucugauuuucuacccuucggcgcccugcucuuccuc\n", + "aguaacagccgccgcugccgccgccgccaggaaccccggccpagcgagagccgcpcgcagagccggcccggcugccggacggugcggccccaccag\n", + "agacaggauauucacugcuguggcaaggccuguagagaguuucgaaguuaggaggacucaagacggucccucccuggacuuuucugaag\n", + "aaaacauaugaccgcugcccccuggagcugguccgcugcauccggcacauucuguacaaugaacagaggcugguccgagaagccaacaau\n", + "guaguaacagccgccgcugccgccgccgccaggaaccccggccpagcgagagccgcpcgcagagccggcccggcugccggacggugcggccccaccag\n", + "aacagccgccgcugccgccgccgccaggaaccccggccpagcgagagccgcpcgcagagccggcccggcugccggacggugcggccccaccag\n", + "gapcggagaaggcuggagcgcggcggugauuuugugccapauucccagagacgcgcugaaaggcuggcapcuuaggaagcup\n", + "ggucaacugguggcapaacaaaaccccgcugagacuggcugaaacacaagupccugugcucapugcaggaaguggagcauccaapagag\n", + "ggcggcggcggcggcggcagcagcagcagcugcaagagcccucgcagccucpcaggacccacguccacacccgagagccccucccup\n", + "agcauucugagaacagcapccacgccaggcgccugccucuccccacagcacagccaggaupccuggagaaggccggcagcagcagaggagacccupagucapauggacaccag\n", + "gaagccucuugacucccaaaggagaggacagugaggaagaugaagauaccgaguacuuugaugcc\n", + "gaguguccgccgccuccgccpcggcccaccgagcugugcacgcguccgugcaagcccccpacccggcgccauguagcgccccgccgauuggaggcugccccgccgcpaa\n", + "ccpcggcgguugcaucagauucuaggaagugucuguagccgcagcugcpuccpauucccagcc\n", + "cuuuuccuuugcggucuugaaggugcauaggcuuggugccuguccaagagccugauuauuucagaaggaugaguuucauuucugagguuucupuag\n", + "aggaugcagcgcgcuggcpagguuuggagcagauggauaccguaucgacgupccuccgguauguugccgcugcguugag\n", + "uuucauaaguacaagccagaccuuugauuuaccuacccuaucuucuuuacugaugaagcugaaacuacuuugugaugccuauugucccagaucuuucuguuaauugccuaacaacaaacca\n", + "guuuagaaacaucaacuggaaucaauuugcauuugaaaauuagaucagcacaaagacuugauauugugga\n", + "gcagcgcgcuggcpagguuuggagcagauggauaccguaucgacgupccuccgguauguugccgcugcguugag\n", + "gcgcuggcpagguuuggagcagauggauaccguaucgacgupccuccgguauguugccgcugcguugag\n", + "uuuuuccucauuucuuuuuuagguuuagaaacaucaacuggaaucaauuugcauuugaaaauuagaucagcacaaagacuugauauugugga\n", + "gcuggcpagguuuggagcagauggauaccguaucgacgupccuccgguauguugccgcugcguugag\n", + "aucuucuuuacugaugaagcugaaacuacuuugugaugccuauugucccagaucuuucuguuaauugccuaacaacaaacca\n", + "gguuugcccucguagcuauuuccuggapaapuagcuacaguuuccugucccucuucagcacuucuccagcucca\n", + "aucccugcaguggaagugaggaggaagaaaggugaacuccuuuucucaagcacuucugcucuccucuaccagaaucacucaga\n", + "agcuapccaugaguaccuuguuuuugacuggaaggagcugupuggaccguuucccugaaagcuagaaga\n", + "agcaggccuaagcgcggccgccguggcuccugcgucucccaucgugccgugcgucccgcgccgcguucgaguucucggapapcguuagccccgcgcagccgccggcgucgccgcc\n", + "gcgucccggaagcgcccgcpccpugcgauggcggcgguggcugcguugcagcupcugcpcggcpcupacgg\n", + "guccagcgucggaaguggaagcugaaccugauugcagaguuggaguccagaguucuggcugagccugucccucugccagccga\n", + "acucaggagcccgcggcccagguggugcpcggcccuagcccggcugcggagcgcugcgcgagcggcpcuggcugaccccgapacccccagcgcagcpugcggcg\n", + "ugagaagccapaccaagauggaucuucuccucgacaucagcuaagccuggaggacucuuccccucagagacc\n", + "uuacccuacaugccugagaagccapaccaagauggaucuucuccucgacaucagcuaagccuggaggacucuuccccucagagacc\n", + "aacuccuuuacccuacaugccugagaagccapaccaagauggaucuucuccucgacaucagcuaagccuggaggacucuuccccucagagacc\n", + "uuuggupcuggcccuuggcccuccaacuccuuuacccuacaugccugagaagccapaccaagauggaucuucuccucgacaucagcuaagccuggaggacucuuccccucagagacc\n", + "aaccggaagugaucguguuguggcggaaggaggagcuuucupaguagccggugcugagagaaccguggcuggcaaag\n", + "ccggcagcggcggcggcagaacupaggaggaguuggaggccggapagcccgcgcucpcggcggcuggag\n", + "ggcagcggcggcggcagaacupaggaggaguuggaggccggapagcccgcgcucpcggcggcuggag\n", + "gcagcgcaccgaguucccgcgaggauccaugaccugacpccccggagccgcgcugccucucpuguccupucggupagcccagugcucgcaggccggcpcpccggagg\n", + "gaggagaaguggcgucgaguccggccpcaguagaggaacuugcgguagugacccucpccucgcc\n", + "agaggacccaggcccucggaggagcuucgcggugccagccucugcagguccucugapagcaacaucapcucccucag\n", + "guucagaggucgccucuagcuucccaggccagucagccacggagcccgupcaggaapcagcagg\n", + "cuccgaggcuggcgaucggcggagcucccaccuccgcuuacagcucgcugccgccguccugccccgcgcccccaggagaccuggaccagaccacg\n", + "ccuccgaggcuggcgaucggcggagcucccaccuccgcuuacagcucgcugccgccguccugccccgcgcccccaggagaccuggaccagaccacg\n", + "ccacuauuucugauucagaucaccugucaucgaaguuuaaagaapaaacaggagacagaaauacacugaaccaaaaag\n", + "cagcguccgucuccaagagaguaugaagagagugcgucuguapcapaagauggcggacaagcgcaaacuccaag\n", + "guggaccaguuugagagugaaguggagucacugucagugcagacacgcaagaagaapcgacaaggau\n", + "accacuguccucagccaaacugcapacuccuaaguagaucagagcuccuggaacuuucucaucuuuucagcaucucaacccuguggaaucuuuuaacucccaag\n", + "ccuuguccagugaaacacccucggcupaagucaguucguucucuccucuccucucuucuuguuugaac\n", + "gguccuuguccagugaaacacccucggcupaagucaguucguucucuccucuccucucuucuuguuugaac\n", + "uguccagugaaacacccucggcupaagucaguucguucucuccucuccucucuucuuguuugaac\n", + "ccugauaaugaaggcuggauaccacuacaugcagcagcuuccuguggauaucuugauauugcaga\n", + "guuuuugauuggucaaggagcacauguapcugucaacagugaaggagauacaccuuuagauauugcggaggaggaggca\n", + "agaucugcccuguagagccuugcgguuccacugcuggccuccggauucccpagcccccagcccgacaggacaaccuuccuuccccgcuuccuccuuuccag\n", + "aucauaugcuuguaagagaaugagaguauuaaccuuguagacuucuguaapcuaagagaaacacugagcuaaauaauugapauauacuauguucauggcuugaaagacu\n", + "gaggcagaucugcccuguagagccuugcgguuccacugcuggccuccggauucccpagcccccagcccgacaggacaaccuuccuuccccgcuuccuccuuuccag\n", + "apcpcggcgcpcpccggccpcugugcaccugcgccucggcpccgccupcaccguccccggcccgcccggccccgcc\n", + "cgcpcpccggccpcugugcaccugcgccucggcpccgccupcaccguccccggcccgcccggccccgcc\n", + "gcpcpccggccpcugugcaccugcgccucggcpccgccupcaccguccccggcccgcccggccccgcc\n", + "agaggcgcuuucggcuuccaapaagugcupcuauaauuaauguuuuuauuaaauuuggapaaguuuuugcagccuuucgccuagcguggccuucag\n", + "guugauagaaguccagauccugaggaaaucuccagcuaaaugcucaaaauauaaaauacugagcugagauuugcgaagagcagcagc\n", + "cguuauuggcugcpaagaaccucgccpaccuaacccgaagcuccgcccccucgcgguuacccuggauacccgucaggcucpcugcagagaag\n", + "acccccugcuugguugcacccucagauaguacccaugagcuucacuguucagccucpcccaggcgcuuccuggaaucucuccuuggccpuuaaaaugcaguucccgcucaaaaugcuuauag\n", + "gagcucugucagaggcgcuuucggcuuccaapaagugcupcuauaauuaauguuuuuauuaaauuuggapaaguuuuugcagccuuucgccuagcguggccuucag\n", + "gacucugcuucuagaagcccagucuucaaaaugagcuuaccuuucagugauuuggauaaggcauaguuuuguuuuuaagaccccuuuuucugauuaaagugcccaac\n", + "cpucagcgcpccaccauccagccccuupcccgccccaagcagcugucgaggacgcacucagccugcgcagcc\n", + "auauuuuuuaggaaaguggagucaacuuauauuugaggaaggcguuuauaggaauuuaugcuuaucccagagaucuug\n", + "cauuuuccucucagcugucuccuguucgguguuuuccagcaugugcugccuggcugcagcugucucccugccuuggcucpugauaucucuccagcagcaacucup\n", + "aaucucagcaupaacaagccuuugugucacacugugcaaccuuccucccuuucuuaaaugcuup\n", + "gucaaaucucugcuauaucaguacuggcuaaauuagguguuaaaugauugagcuucaagaupcaaaucaugacuucggacuacauuccuccuugccuggcggcupaaauucc\n", + "guucuccuaacuagcaccuuccccucuccccugacucagcugguagccccuccuccccgcaccugcccaaaggucacuggacag\n", + "gucucuuaaccuucauuaacugugccuaugucaaaupaacccugguacaagauauuuucaccuaugcuaaaguauuggcacugaucgcggucaucguugcaggcauuguuagacuuggccagg\n", + "aucupuuuucaaucacggcuccgccaucuupucaucguacggaaggagagacaaaacugcaguacagguuuuugag\n", + "agcugucaaaucucugcuauaucaguacuggcuaaauuagguguuaaaugauugagcuucaagaupcaaaucaugacuucggacuacauuccuccuugccuggcggcupaaauucc\n", + "cccuuuuacugcuggcupaaggaggagcaucagaccacagauccuggaaggcacuucucucccugacugcugcucacacugccgugagaaccugcuuauauccaggaccaagga\n", + "gagapcpugcuaccuggcagcuccgcpugcguggccggugcuggcupaguucuggucucaggcaaggupacupcacaucaucaauacg\n", + "gaaucauggaaaacuagaagaguuucaagugacaggcaaauguccaauuuucugaagaaaaaagacaccuuuuaccuccucc\n", + "cgcagagagapcpugcuaccuggcagcuccgcpugcguggccggugcuggcupaguucuggucucaggcaaggupacupcacaucaucaauacg\n", + "auagagaacgucacuuuucaccaugaapuucuucuggagguguugguuuaaupauuguggaagagaaugacuccaauauuuggaaguucugguaca\n", + "ugcguggccggugcuggcupaguucuggucucaggcaaggupacupcacaucaucaauacg\n", + "agagagapcpugcuaccuggcagcuccgcpugcguggccggugcuggcupaguucuggucucaggcaaggupacupcacaucaucaauacg\n", + "agaagaucuuuaacuccuccaaccaugaagaccuucagaagaugaaauuccugcccaggagaguggaugcccacagagacacugguuguuucauauucugccuacuaaagacuuaucuguauucaag\n", + "ccggucuuuccagccccgagapaccugguuccucugcccaggcuucugucacucugucaccuacgcu\n", + "accucaccuuugucccugcgcpcugcggcupauccggucuuuccagccccgagapaccugguuccucugcccaggcuucugucacucugucaccuacgcu\n", + "cgaucuucccaucccacauccuccggcgcgaugccaaaaagaggcugacggcaacupccuucugcagagaaagaccuccgcuucacugccccggcuggucccaapucaggaag\n", + "cupcggagaagcugcuuccuccupaacaaccgccucccgcuccuagcagguugcuacugccccgaacccgcgcugcapaacagcpcaaaca\n", + "accccccacccccgcagucuccgccuaagacuuuccaaguccuguaguuucgagcccgcugcccuuugccuccupcggagaagcugcuuccuccupaacaaccgccucccgcuccuagcag\n", + "gaaugcagauaaapagugcagaaggcacgaggaaaccaaagugcucuguauccuccagucuccgcgccuccacccagcucaggaacccgcgaacccucucuugaccacu\n", + "caaagugcucuguauccuccagucuccgcgccuccacccagcucaggaacccgcgaacccucucuugaccacu\n", + "gucgaguagaaggaccgccgcuccggccucccgcgacuucucgaaggupcaggucccaccuuguggagg\n", + "pcupccggagccggccuggucgccagccuaacccggcacagugagcggagcgccupcggcggcggcggcggcgug\n", + "pcpcgcgagcgagcgcgcpcupccggagccggccuggucgccagccuaacccggcacagugagcggagcgccupcggcggcggcggcggcgug\n", + "paggcapccpcpcgcgagcgagcgcgcpcupccggagccggccuggucgccagccuaacccggcacagugagcggagcgccupcggcggcggcggcggcgug\n", + "ggaauacagugaguaaccugaucaugauuauaccuccaauguucggugcaguucagaguguuagagacggucuggaaaagcgguacauugcuucuuauuuagcacucacag\n", + "agugagcggagcgccupcggcggcggcggcggcgugauggcuccggccgcggaccgagapcuacupccccacgaccuccacgcuggacuggugcgaggagaacuacuccgugaccug\n", + "aaguacuucagauuugagaaaagagcacauaacuauggcuaaaagaupauuuguaaucucuggaguuuuuuacuucaagucugaggauccaaacugacuaagugaaguaaagaaauaagcag\n", + "gagcgcgcpcupccggagccggccuggucgccagccuaacccggcacagugagcggagcgccupcggcggcggcggcggcgug\n", + "pcgcgagcgagcgcgcpcupccggagccggccuggucgccagccuaacccggcacagugagcggagcgccupcggcggcggcggcggcgug\n", + "gccpcpcgcgagcgagcgcgcpcupccggagccggccuggucgccagccuaacccggcacagugagcggagcgccupcggcggcggcggcggcgug\n", + "gacuucuccagacagguuauguuaccugcagaggcugcccugaagcucccuguggccuggagacu\n", + "gcaguuccugagagaagaacccugaggaacagacguucccucgcggcccuggcaccucuaaccccagac\n", + "aguuccugagagaagaacccugaggaacagacguucccucgcggcccuggcaccucuaaccccagac\n", + "aaaauggcgacucccgcucgugccccggagucaccgccguccgcggauccggcgcuaguagcpccugccgaggaagccgagugcccgccgccgcgccagccucagcccgcgcaga\n", + "auaaaaagaaaagacuccgcacggcgcpugagucagaacccagcagccguguaccccgcagagccgccagccccpc\n", + "aucagcccggaggaagaggagcgccgccgaguaaggcgcgagcggaacaagcuggcugcggccaagugcaggaaccggaggaaggaacugaccgacuuccugcaggcg\n", + "acaguggugagcucuuagcuucaccaggcucaucaaagcugcuccaggaaggcccaagccagaccagaagac\n", + "agagagguugagaacaacccagaaaccuucaccucucaugcugaagcucacacccuugcccuccaag\n", + "cgcuaagcgucccagccgcaucccucccgcagcgacggcggcccpacccgcpcugugaacc\n", + "aucuugagacucgcuaagcgucccagccgcaucccucccgcagcgacggcggcccpacccgcpcugugaacc\n", + "uugcggagcaggagcuggccaaccuggagaaguggaaggagcagaacagagcuaaaccgguucaccuggugcccagacggcuag\n", + "agacucgcuaagcgucccagccgcaucccucccgcagcgacggcggcccpacccgcpcugugaacc\n", + "cccaaugaagcgcgugaapcaagcggugaupuucugcgccagupcupagcccguccpcuguacaupcugcgcgcaag\n", + "aguccguugaggcugccaggcgagucaggucucucuggaccucgccugacucggcupcugugccugaaauugacccagcuccaccauacuccuugauu\n", + "aggaauugaaaacaagcaguuccccaaccaaacpcacaggcugcguuugcagcuccuguaaaagcuccauacccagagcagugucuccuagcucccag\n", + "guuacauuuaguaacacuuuuugaaaaugaucgucauuucucucaccucucaucuuuggaacpag\n", + "gcacccuuuuccuggcapcugcgucccuguucuucccaggaggcuccucgcugccuggugccguagaggccc\n", + "acagucgccgcgcuuugcgcacccuuuuccuggcapcugcgucccuguucuucccaggaggcuccucgcugccuggugccguagaggccc\n", + "agaacaupaggcacugaacuuacuacaucagaacuccugcugagguauaagaggauacgucuaauaacucaauugcuguaaaccu\n", + "ugaacuuacuacaucagaacuccugcugagguauaagaggauacgucuaauaacucaauugcuguaaaccu\n", + "acaugcgcaauacucgcgcugccuccguggucccugccuggcugagguggcagcapcpacgcgcagcgcu\n", + "acucgcgcugccuccguggucccugccuggcugagguggcagcapcpacgcgcagcgcu\n", + "gaugcgcaugcgcggccgauuugcacaugcgcaauacucgcgcugccuccguggucccugccuggcugagguggcagcapcpacgcgcagcgcu\n", + "caaucaaggagccguguggcucgccacuaaccucugcccugcagccgcgapcgcgcpaaaucccgagugcaucuggaauacgcagagucaguaagaccauggcuacguccucgaugucuaag\n", + "gugugaaugucacagaucaugauuugacauucggaagucuaacagaggcccuucagaauaaugucacaccauauguagucucauugcaagcuaaagauuguccag\n", + "uacuacugcuggauucuaaagcacaacaaacagaguuggaguggauuuccucuccacccaaup\n", + "upaagaaauuagugguuuggaugagaacuauaccccgauacgaacauaccaggugugccaaguc\n", + "ggcuucuaggcggcgacgccucuapcgcagcggcgaccaagagcuggcguucuaggaguucacaagccccgaggcggcccgcaguacccaapcuagcgcupaaccgcuugaagcag\n", + "aguuguuccggacacauagaaagauaacgacpaagagcpcccgcuuupuccaggcagguuuupccuccugucuggupaggaggccgcagcgcagcacccugcucgucacuup\n", + "gacpaagagcpcccgcuuupuccaggcagguuuupccuccugucuggupaggaggccgcagcgcagcacccugcucgucacuup\n", + "pccaggcggccgccgcgagucugguauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpaucaugguguucuacuucaccagcagcagcg\n", + "guauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpauc\n", + "aggcggccgccgcgagucugguauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpauc\n", + "agucugguauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpauc\n", + "aagugcacggaggaguuccpccaggcggccgccgcgagucugguauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpauc\n", + "guuccpccaggcggccgccgcgagucugguauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpauc\n", + "aguuccpccaggcggccgccgcgagucugguauccugagcuucgugaguugagcgcugcugcuccgcgguggagucaccgcaccgcucccpauc\n", + "uauaaaugaucaaccagaaauuaucuucaaaggaauaaaaccagaaguauguaaauaaaaagcccaagauaaagaaacagaaaagcugacacuacaugaagcagag\n", + "guuauaauauaacuuauccucucaugcuuuuuuccugccccuucuccccaaaucaucaacaauagaagaagaagaaaac\n", + "cucacucuggcagcuagagguuuugccucuggccagugaccauuccuuugaguagugagcuuucuguucuuuccaguaacugcuggcaa\n", + "guuauaauauaacuuauccucucaugcuuuuuuccugccccuucuccccaaaucaucaacaauagaagaagaagaaaacaugucaggacacaa\n", + "uaccccaggagaupucgaggagagaccccpaguagagagagagaaacucacuccccgaguccccgacccuccccaagcaag\n", + "cucacucuggcagcuagagguuuugccucuggccagugaccauuccuuugaguagugagcuuucuguucuuuccaguaacugcug\n", + "gcugacgucggaugagugauccggapacgcuccgaccgcggccpaggcuccupccpcuccgag\n", + "gacgcugacgucggaugagugauccggapacgcuccgaccgcggccpaggcuccupccpcuccgag\n", + "pcgcgccpcpcugcaggaagcagcaggagacgcccggcagccpacggucpacgccug\n", + "ggauccgagcpauaccccaggagaupucgaggagagaccccpaguagagagagagaaacucacuccccgaguccccgacccuccccaagcaag\n", + "cugcgcuccccccgccccuuucccucgccuucggcugacgcugacgucggaugagugauccggapacgcuccgaccgcggccpaggcuccupccpcuccgag\n", + "gcpcacgcacacacgcaagcacgccuccacuuaacucgcgccgccgcggcagcucgaguccaccagcagcgccguccgcuugaccgag\n", + "acacacgcaagcacgccuccacuuaacucgcgccgccgcggcagcucgaguccaccagcagcgccguccgcuugaccgag\n", + "agugcugaaggucgacpcgagaacuacaguucccgucaggacgagcggagcggcggcuuguugcauccuuaauaaggag\n", + "aguugucucugupaaguuuguccuccguccauugcgaccaugccgcagauacucuacuucaggcagcucugg\n", + "caucgguccguccugcuuccagcugcugcagcgcgccuucgccgccaaagcauccagcagcccccugcuccggcccagc\n", + "ccccacaucgguccguccugcuuccagcugcugcagcgcgccuucgccgccaaagcauccagcagcccccugcuccggcccagc\n", + "ugaagaagaaguaaaauauucacaagaugaagauuuuuccagaapacuuugagucaaagauggcuuuuuauauuugacaa\n", + "agauauuucugaugaagaaaacgaucugcucuuaccuauuuuaugaaucagcagcauaguguaucagaguggcuaaugacaucugcuuu\n", + "gauucaaaaucuagugcauuagacuuuugaacuagcuguuccuucaagcuggaaggcuuuuccaucucuaugcacauggccaauuucacuacucaaaugccaccuucuca\n", + "ggcgcagcagcgagguggcpcugcgugcgcaaacapcggccgccuucupcccggagaacg\n", + "pacapccccugcuggaagaggcgcagcagcgagguggcpcugcgugcgcaaacapcggccgccuucupcccggagaacg\n", + "gccaaggaugcccauucgguccugaaacgauucccucgugccaaugaguuccuggaggagcugcgccapcaccaucgagcgagagugc\n", + "gacapccccugcuggaagaggcgcagcagcgagguggcpcugcgugcgcaaacapcggccgccuucupcccggagaacg\n", + "ggaucccuggcaaggcaggccuagguugcaggcuagccccccucucuuuucguuggccccaggagcccggcpccugaauggcag\n", + "gcpcgcugcggccccugcucuaccuccuagcgccggugcgcggccgaggccgcacuaccugucugcpaaagcpauccaccccaggacgucpucgcugccg\n", + "ccccugcucuaccuccuagcgccggugcgcggccgaggccgcacuaccugucugcpaaagcpauccaccccaggacgucpucgcugccg\n", + "gcucuaccuccuagcgccggugcgcggccgaggccgcacuaccugucugcpaaagcpauccaccccaggacgucpucgcugccg\n", + "cuguuugucuuupcuggagcugcapucagccuggagccgcugccacapcauccugcaaacuugccccacucacauccacgcuuaccagupagcucucacugcacagccag\n", + "agucuucuucugcauaucgugcuagaggupaaaucupauucaggaccguccaccaccaccucccacccgcuguguaaaccugg\n", + "cuuuugcgcaggcgucgcgcccupccpccpcggcaccgcggugcgcaagcgcaaccgucggupucpaucggucgccugagag\n", + "paagcaacuccpcgccuuucuuuugcgcaggcgucgcgcccupccpccpcggcaccgcggugcgcaagcgcaaccgucggupucpaucggucgccugagag\n", + "guaucaccucuucupcucaagauggacaacaagaagcgccuggccuacgccaucauccaguuccugc\n", + "uuuauagguaugaucucaugaaaccuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugag\n", + "ggccggcggcagagcuguccggcugcgcgguggcccppcccpcggcapcaagcagcgcggccucggccuaugcgaccgguggcgccggcgcggcuucugccuggagag\n", + "ggucguuugcacpaccupaggcugupacaccuapaagacccugaugugaauuuupacuuggaaggagaaggcupcgc\n", + "agagccggaguaacpacucccagcugcgcgucgcagucccgacgcgagaapcuggagucggcguccagccuagagcccccggupagccaggccpacgcgugcacc\n", + "agucccgacgcgagaapcuggagucggcguccagccuagagcccccggupagccaggccpacgcgugcacc\n", + "uuuucauuucucacaaggacupugaagaguucugcagccuuacagagacuggaaaagaagcccaaaccaaggcccccagagaggucccccaggccccuuupucccugagccucagcuggag\n", + "cccgccgccugcgcpagcccagcacagaccgccgccpaccccgagucgcgcaccccagccccaccgcccaccccgcgcgcc\n", + "auaugacaguacgucagcagcpauggcccuagcaguggcggcggcugcagaagcccaagcagccgcggccgcaguggaggcuagagccggagcggcggcggcggcggcaccccpaguuuaag\n", + "accauucagaagacuguccacccguccucagcccccucucuucgupcuaucuacucaguugaucccucccucgcuggcuuggcucugacuccugcucagacccaucaccuuugccgg\n", + "gaccauucagaagacuguccacccguccucagcccccucucuucgupcuaucuacucaguugaucccucccucgcuggcuuggcucugacuccugcucagacccaucaccuuugccgg\n", + "pcggcagcggcgaccggagcgguaggagcagcaauuuauccgugugcagccccaaacuggaaagaag\n", + "aggcaagagugcuggapcggcagcggcgaccggagcgguaggagcagcaauuuauccgugugcagccccaaacuggaaagaag\n", + "gcauaagaaucuaagucucugaggaagguagcauagugugcaguucacuggaccaaaagcuuuggcugcaccucuucuggaaagccuggcc\n", + "gcagagccuugguacuuggaccugaaccuugcuccgagapaguccucgcggacgucagccaag\n", + "aaaguaacacagcuagugacuagaaccacgugcccuggcuaccacuuccgagugacaucagcugccgauccauaagaaauaccuucaaaccaaugcap\n", + "guuucggaagccggaccccgcccgcagccgcagaagccucgaguccacaucupucucuaaagucucgccguagccagaucccggauccccaccuucuucaccaguucccpcguccuccag\n", + "gcugcagguugguggcpaggapacagcugcpcgcpapcgccgcgccgcpccauggcggagccaggaagccpaguccgagacccgg\n", + "ggaaggcgcpcagcagcggcuccgaguggccgcggcggupcugugccggagucuccucccuuugguccgcugcag\n", + "gugccggagucuccucccuuugguccgcugcagguugguggcpaggapacagcugcpcgcpapcgccgcgccgcpcc\n", + "ggugagucuuacuguugcpcuccpccgucgaccaugccgcucgaccuccaccuccgcupaagcugaggcgccaaacggcucccagapucccpaagcgc\n", + "ggcggugcguucuucuacacaugcgcapuupcpucuucuuccuucucgccuaacgccgccaac\n", + "cgccaacauggugagucuuacuguugcpcuccpccgucgaccaugccgcucgaccuccaccuccgcupaagcugaggcgccaaacggcucccagapucccpaagcgc\n", + "gagucuagucuuuguucpcuguccaaaggacgcuagcuguugcaccuguuccucccugcgcguaag\n", + "agaugacgcgacacgccaagugcgupauucccgcggcccuggccacuacccggccugccccgcggcaagauggcggccugaacgcagcuggcagcggcggaaa\n", + "gagcuguggcuaaaggaaguggapccgupaugcggagagccgapcuaacucccggacagcggaacagagagagcugccgacaaacagacg\n", + "uccagaguccuucuggccacaucucugagccugccuccuucuugcuucucagcaggcggaggagccgucaccucccaga\n", + "cugaagauucaggugccccapacuggaagaaauuacagugccuacuuggaaagaagaagagauagcgacuugccccaguccaaccccagagcgg\n", + "aaugagaucuuuuuuucuaacauuuuacauaauauccucagagaagaucacgcccuggugacuagagcuguggcc\n", + "acagaaggcgaupccgagagcugaggaacuacaacuccuagaguacuccgcgccgccpacgccgcgcggcugcpcupcgagcgcaaagauguccgcgcccgcugccpaggcgag\n", + "acacuucucacucuucacuggaccucugguacaagauugagaggauuccuauuacuuacaaacagacuag\n", + "gguccucgcucagcggcccggcaggccgcacaacuguaaccgcugccccggccgccgcccgcuccuucucgguccggcpcacagagcgcagcgcggcpccggcggc\n", + "ugucgaauagguaccupucaacuccacacacuucucacucuucacuggaccucugguacaagauugagaggauuccuauuacuuacaaacagacuag\n", + "cucgguccucgcucagcggcccggcaggccgcacaacuguaaccgcugccccggccgccgcccgcuccuucucgguccggcpcacagagcgcagcgcggcpccggcggc\n", + "uucaucuggcucuccaugaauguccugcuuuucuggaaaaccuucuugcuguauaaccaapccagaguaucacuaccuccaccagauguup\n", + "acaacuguaaccgcugccccggccgccgcccgcuccuucucgguccggcpcacagagcgcagcgcggcpccggcggc\n", + "ugcagugucgaauagguaccupucaacuccacacacuucucacucuucacuggaccucugguacaagauugagaggauuccuauuacuuacaaacagacuag\n", + "agagcccuuucacacaccucaggaacaccuuucggcugcccgcuccccagacacaccugcagcccugcccagccggcuuugcucacccacug\n", + "gagcagagcccuuucacacaccucaggaacaccuuucggcugcccgcuccccagacacaccugcagcccugcccagccggcuuugcucacccacug\n", + "cugcugucucugcacpuggccagagccacacagcccuuucuuuaagucaggaguugcccugucagagcacaaggcaagaaggaagugguaaapacggapaagcccugagaggacugagagg\n", + "agcccuccccacacucupcgcggagcacaaugauuggucacuccuauuuucgcugagcuuuuccucuuauuucaguuuucuucgagaucaaaucugguuuguagaugugcuupaga\n", + "acacucupcgcggagcacaaugauuggucacuccuauuuucgcugagcuuuuccucuuauuucaguuuucuucgagaucaaaucugguuuguagaugugcuupaga\n", + "acccacagcacucauuccuggagcuacugguugguuuccugagaggucccagaacucugcgaagugaguccagcgcug\n", + "aacgaacaguggucugauuuggcuggagagcaaguuuccucaapcgccgupaauuuagcugg\n", + "ggucgucuuugcuapcugapuuugcaauuupucccgaccuucgcgcccucugcuuucccgccgcacuccaccccacgcucugccguggacag\n", + "cuauugaupcccaagcguaaccaggcucuucugauuggccgguguacuucaguuuccguccaagguccgccuccuaccuccuucugcuucgg\n", + "ggapcaupaucagcuaccuguuucugccucaaccacggaccaauaauaugagaucuuuguucaccaguucuacagugaupugcuuccuuuuggcuucuggaaup\n", + "ggaaucuagagcaacagcaaagcugaggucaaacuaccguaaggauggacaccaaggaagcuguguuupacaaaaagaaaucaagauaag\n", + "cgauaggucupuguucupaggaccccuaaaapagcagcucugccaggucagagcuugagguagcaugugugccgcuuccaggaggccagg\n", + "ggcguggcgauaggucupuguucupaggaccccuaaaapagcagcucugccaggucagagcuugagguagcaugugugccgcuuccaggaggccagg\n", + "ggagccacccagugcucggcccgccccgcaacccgccggaaccgccgcccgcagcgaggaagcgcccgcgcpcgcaggcggccgga\n", + "aauuacuuuuuccaaaggcuggapcuucacuccggcuggcgccgccgccuagcgcgcuccugcuucgccgccacgguccppcugccggucccpuacc\n", + "acuccggcuggcgccgccgccuagcgcgcuccugcuucgccgccacgguccppcugccggucccpuacc\n", + "auaacucccaaacggcaaguuucuacaaaguuacaacagupaggcgccacaacuucacugccauuuugugaggugcugccgccccuccuccggcaag\n", + "gccggcucgcuaaugguggacgcgugaggcggaggcgcpcggaggapaggccggagcpcagcgcggcggcgcc\n", + "cggcucgcuaaugguggacgcgugaggcggaggcgcpcggaggapaggccggagcpcagcgcggcggcgcc\n", + "gcucgcuaaugguggacgcgugaggcggaggcgcpcggaggapaggccggagcpcagcgcggcggcgcc\n", + "guauuagccggagccggcucgcuaaugguggacgcgugaggcggaggcgcpcggaggapaggccggagcpcagcgcggcggcgcc\n", + "cpcuucgcguccccuapugccggccccgcucccccpcgcccggcgcaccgupacuacauaucccagcaugccgcggcgccggcggagcgaggcgaggcgcg\n", + "ggcucgcuaaugguggacgcgugaggcggaggcgcpcggaggapaggccggagcpcagcgcggcggcgcc\n", + "ccggagccggcucgcuaaugguggacgcgugaggcggaggcgcpcggaggapaggccggagcpcagcgcggcggcgcc\n", + "agguucagcupagaccccucacacacaggugaaggcguggcuguagaaccucagacccccuggucuccucagga\n", + "gagcccgaggcccggaacagcgccaggugacuucgagagcupucaccgcggaaaagaagccauugcgccccacagcuacgugaagupaapccpuucguupcgagagag\n", + "cagacagccucaucccaguuaagcagaagaggugccpcugccgapaaggacugugccugucugcacugacuguccauccggccuggaucuuucucuccag\n", + "acuguagccuccacggccgccgccgccgccgcgapccgcccgcggccccguccgagcccggcccgcgccc\n", + "gcacagcgcccggcucpuugcggcggcagcaccupccgcgauuggcguccggcupcagcgccgcccgcgccccucggcg\n", + "auuuagupcaaggugcupuugacucccggcucugccccaguagcucupucccaggaagcagaggup\n", + "acagcgcccggcucpuugcggcggcagcaccupccgcgauuggcguccggcupcagcgccgcccgcgccccucggcg\n", + "ucpuugcggcggcagcaccupccgcgauuggcguccggcupcagcgccgcccgcgccccucggcg\n", + "ccupapaggaggccuuggagaaggaggapaaaaapcugupauuuaguggcupcugcacccccuppcagcagagccca\n", + "ccccagucupagguuaccgcagacagccucaucccaguuaagcagaagaggugccpcugccgapaaggacugugccugucugcacugacuguccauccggccuggaucuuucucuccag\n", + "auugaggagcugccucgcgcapugugcgaggcugaguccaagagauagcaaaucgagucuuaaauaauccpagaaagacgcccpuagauuugag\n", + "gcggaauuaaaccccgcuccgagagcggcagcuucgcgcgcggugcgcucggccuaugccugccccgapcgucugguaggcaccccgcccucucccgcagcucgaccccc\n", + "aaaguguguuucucuuauagaugguucuguauguapuucguaggaugcuugugguguuucuugcgccpcugcgguucuuacaagcugugaaaacuacuacggcuucucagguuag\n", + "agacauuguugcugaagcccucuguccuguccuucugcggcagucuucacuggcugugagccucag\n", + "aauuuugaauuuuucuuuauggcgupagaggccacagcccggacuccaucgacucccccggcucuuagacua\n", + "uuucucgcucuguguuccaggcuggaguacaguggcgcagucaupucacugcagccucaagcuccugugcucacgugagccucccgccucacccuucagaguggcuaggacuauag\n", + "ggcpcgcpaaaauggcggcggcggcggcggcggcugcagcuacgaacpaccggaggaagcagcpauggag\n", + "ugcuggugcupccggaggapacgcgccggagcpaccgacpaccgagcgagcgaccgacgcgccacccgccgacgccucagccgcuupcccgcacggacccucuacuuca\n", + "paccgagcgagcgaccgacgcgccacccgccgacgccucagccgcuupcccgcacggacccucuacuuca\n", + "cpcggugccccggcgapagcguggcggcgagcuguuuppuuggcgacggcagcccgapcggcgcaaggccugaggcccagcacag\n", + "gccaggugcaguggcucacgccuauauuuccaggacuuugagaggcugaggcpcggaucaccugag\n", + "ggcpugccpcggugccccggcgapagcguggcggcgagcuguuuppuuggcgacggcagcccgapcggcgcaaggccugaggcccagcacag\n", + "ggagccgauauguggauuuacucccuugauggaagcagcugcugcuggccaugagauaaucgugcaguauuuucugaaucac\n", + "gcggugccccggcgapagcguggcggcgagcuguuuppuuggcgacggcagcccgapcggcgcaaggccugaggcccagcacag\n", + "pcpugccpcggugccccggcgapagcguggcggcgagcuguuuppuuggcgacggcagcccgapcggcgcaaggccugaggcccagcacag\n", + "guggcggcgagcuguuuppuuggcgacggcagcccgapcggcgcaaggccugaggcccagcacag\n", + "ggugccccggcgapagcguggcggcgagcuguuuppuuggcgacggcagcccgapcggcgcaaggccugaggcccagcacag\n", + "aguuccggcuguuuguucpaaguggauccgccgcugccggagcagcccgaapagcugcggaucgcgaggccaguaccgaccccgcccgcccgcgcgcaccgcccccgcccgcc\n", + "guucpaaguggauccgccgcugccggagcagcccgaapagcugcggaucgcgaggccaguaccgaccccgcccgcccgcgcgcaccgcccccgcccgcc\n", + "gccgcugccggagcagcccgaapagcugcggaucgcgaggccaguaccgaccccgcccgcccgcgcgcaccgcccccgcccgcc\n", + "cggaagaacccaucaaagcccuuccucccgccgccucuccggaaugaggucucagcacccgcgcpacagcacccuuccuccugcgaca\n", + "aguuaccccgcgcgccuccgccccucucccgccggccccgcgcucggcgcagacucguuuguuuguuucugcaggagcccaagaagaggccgaaaccgagacc\n", + "cuuuacacggauuuugaugaaauucgacaagaaauugaaaaugaaacagaaagaauuucaggaaauaauaag\n", + "ggaguaagcccugaaccaauucaucuuaagauuuuuucacccaacguugucaauuugacacuuguggauuugccagga\n", + "aggcgaacugupccccggccccauucauugccguggccggcpcacupccccguguuuucagaguc\n", + "aaaugugaggcagcuuucgccacgaaggaucggcugcpcgcacacaguacgacacgaggagaaagugccaugucacguguguggcaag\n", + "cupaapagccacucccapcggapaggaagccucucccgguuaccapagcaapugguccuuugucgaggag\n", + "cgcggcccagcccggccggccpcggcgccccgagcccpccccgcgcggcccgcgcccccggcccccgcugagccccpccccgcugcggccgaggcc\n", + "auguuucucccgugcuccucucggccagccgcccgccacgcugucggcgcuauagcaacgguagcuagcugcapccaguggcacg\n", + "ccgacuuccuccuggucggcggcugcagcpugagcggcggcagcggccpauccuggagcc\n", + "ggagccgacuuccuccuggucggcggcugcagcpugagcggcggcagcggccpauccuggagcc\n", + "gacuucauagaccucacguugucgaagacucaacgaaagacuccaaccguuauucauaaacauuaccaaauacaucgcauuagacauuuuuac\n", + "cucaaggaaagagapagugccaagcuguuacuguuuacccucuggcccagaucuuucuucagaagaaaccugaguggucucacag\n", + "gupcgagccagccagucccgcugcacacgcucgcagucugupcccuccpaggcggcggaggucaccgcpagapcpcgcagc\n", + "agucccgcugcacacgcucgcagucugupcccuccpaggcggcggaggucaccgcpagapcpcgcagc\n", + "ggcaaaaagccacupaggccagucccgaucaguccuuucuggcuccagcuccagaucccgugcggagcaacagcugcg\n", + "guggaggccugaauuuugaucuauguucuaccuacauccagcuggcugaaaguacuugaggaucac\n", + "ccggaagcucaucucaaaaugcugaacugcucuuuggaagucgccggugcuguuguaguuggagucuguucacpccugagcuucgaggccaggcucccpugucguua\n", + "gucggcuuccggaagcucaucucaaaaugcugaacugcucuuuggaagucgccggugcuguuguaguuggagucuguucacpccugagcuucgaggccaggcucccpugucguua\n", + "cacaaagaaugaaccagcaguggaagagaaaauacuguaagcuggcugacugcuggugaagaaaaugcuuuauuuuuguggcaggcaucugupaucuguaauagaa\n", + "gcgcgcguucccggcagcugcpcuccgaggccagagagaaaagacugcgagguggccgcagcuguggccggagag\n", + "cacaaagaaugaaccagcaguggaagagaaaauacuguaagcuggcugacugcuggugaagaaaaugcuuuauuuuuguggcaggcaucugupaucuguaauagaaau\n", + "paucuucaauauucauguuauuuucuccuuuggucuuauaugauuguuaccuuuaugaagcuuuagugauuacaaagcacuuuuuuuguccauuuuuaccugagcuuuguaaacucugauuugcag\n", + "auuuccaagucuccucaaaaggaaaagucucuauaagaaaaacugaagacacaggaguuugcucaaagaaugcugaaauagaucuccag\n", + "uuuuuuauaaggccgagcgcgcggccuggcgcagcauacgccgagccggucuuugagcgcuaacgucuuucugucuccccgcgguggug\n", + "aaucaaaaacaacucuccucucucaagccgccuccaggagcgcaucaccuggagaagagcgacucgcuccccgcgccggccgcggaagagcagccag\n", + "gcucccuuccuguacuuaaauugccuugauauaaagupuucauaacagaacapauagccgucucuggcucgugcucuc\n", + "gagguaaaccpaaacagauaugcacuaaccaggcpugccaaccuggaucuauaacugugaauuccccacgguggaaa\n", + "ccpapacgcaggcaggcggcpcagcpaggcggcagcccggugcgguccccgcggcucucggcggagccccgcgcccgccgcgcc\n", + "ggaagugcgguguuuuagccgguggcugcugucucupcpccgupaggcucccgaggupccpcp\n", + "agugguuguguacgguccgcagcggcaggugaagucuagcagaggacgcggccaggcgauucggugaagcgauuccugcaggcguugguuccccucuuugaccug\n", + "guacaaagaauuuuacgugaaagauuuugucgucagaguccacauaguaaccuauuuggagugcaaguacaauacaa\n", + "acacuuaagugagcugcugaaaagaacugcucuccauggagagaguaacucuguccuuauuaucggaccccgaggaucaggaaaaacu\n", + "gcaugccpagugguuguguacgguccgcagcggcaggugaagucuagcagaggacgcggccaggcgauucggugaagcgauuccugcaggcguugguuccccucuuugaccug\n", + "gguccgcagcggcaggugaagucuagcagaggacgcggccaggcgauucggugaagcgauuccugcaggcguugguuccccucuuugaccug\n", + "ggcugcuccupuguagugagaugucuccagccapccaagcagcagcaguagcagcagcagcaguagcagcagcagcagcaacagcagcagcagcagcaacagcagcagcaaagg\n", + "gagauaaacgcccuuucccuggcccaggaucguccggacgugcauccaapccgcaccccucucugugcgaguggcpuucuuucuupcgaccugg\n", + "aacaggccggccucggccgcgcuggcgacucggcggugcuggugcugccgccuuccccpcccucguuccuccaggcccag\n", + "uccccggcugccuccucccaacaggccggccucggccgcgcuggcgacucggcggugcuggugcugccgccuuccccpcccucguuccuccaggcccag\n", + "auggugacpcgccaggcuapcggccuggccacugagccpugcaguggcagcpagaguaccuggcgauggcgau\n", + "aaccgccucgcgccuuccgucgcccgguuuccauggugacpcgccaggcuapcggccuggccacugagccpugcaguggcagcpagaguaccuggcgauggcgau\n", + "cuuucaauuguguucgcagccgccgccgcgccgccgucgcucuccaacgccagcgccgccucucgcucgccgagcuccagccgaaggagaap\n", + "aucuuucaauuguguucgcagccgccgccgcgccgccgucgcucuccaacgccagcgccgccucucgcucgccgagcuccagccgaaggagaap\n", + "ccgccgccgcgccgccgucgcucuccaacgccagcgccgccucucgcucgccgagcuccagccgaaggagaap\n", + "caaugaagcagcugcugacccagcucuaguuuucpaagucagaugaccuuuucccucccgcggcucucuaccucucgccgccccuapaggacacc\n", + "cacuucucagacapcggcugccpcggapcuccucacuucucagauggagcgguugccaggcagapucuccucacuucucagacpcggccpcagagacgcuccucacaucccgg\n", + "aguugacgaugucccuaacagcgaauuccaaggcgcccguguagcaggagaggagcaagucggccacg\n", + "aaagccugaauuccucauaccacacupcupccagagacpcaggaggagcucuucucag\n", + "ccuuuugaugguccuaauucucaaagguaaccuuaapaguguauuuugcuguugguucuguggaugacaggugacaaaacagg\n", + "puagaggaggagapaggaggaggapagguggcggcgccguggcggaggagcaggagcaggap\n", + "gucaaacaggaaaagaapaagaaggaagaagapuagaggaggagapaggaggaggapagguggcggcgccguggcggaggagcaggagcaggap\n", + "agcuacacuguggccuacaaaccaaccacaacgagaaagaguuuagagaauguggaaaccaaagaagcaaggaaaagccugacagcugacaucucaacacag\n", + "guucaagcgauucuccugccucagccucccgaguagcupauuacaggugcaugccaccacaccagg\n", + "paaccagaugcagaagucacugcauuuuccggcaagccaapuugucugcaucucaagagupucagcaagagaaacucuacggcu\n", + "acugcaccuccgcuuccggcuccagcuggucccagcccaaaaugcggcgugucaggacccccpuucaggcugcaggugcagcagccgcgcaccccagccuccggcugag\n", + "acugcauuuuccggcaagccaapuugucugcaucucaagagupucagcaagagaaacucuacggcu\n", + "agugccgcggcggcccggagguggcpaggacggcuccgcgcugcaugcpcpaccapacccgugcpccgccuccagaga\n", + "augaggcugccagccuugagagcaccaccguuaccugguugaagapapaaguccagcauuggccucugcagcguggaucucccggccaggcucucagcugucag\n", + "ggcggcccggagguggcpaggacggcuccgcgcugcaugcpcpaccapacccgugcpccgccuccagaga\n", + "ucuccpagucgcuguugcugaggcugucgccugagguuuuucgcgcuccucccuuuccuccuccucuuucuccuccuccuuauccgaaccccagucagaccgaucugcucugcucucg\n", + "gugugcucacuccuauuupaagagagaapcacagcagcccugcapccccuggcucugcucguguuucupcuucugcug\n", + "aguaaacaucagucuccaaagauaacuacaucccuucuucccaucaacaauggcuccaaagaaaaupauccaugaagaacaagaccaagagccacaggaucucuuugcag\n", + "ggucucacucuguugcccaggcuggagugcagugguguggucauggcucacugcagccccgaccucccaggcucaagugaucuucccaccucaaccuucugaguagcuaggaccacag\n", + "augccacaguggagcuauccuuggacagcacacaaaauaaucagaagaaggugcuagccaaaacacucauuucucuuccuccucaggaagccacaaauucuucgaagccccagccaaccuaugaggag\n", + "cuagaggaagaagaacaggaggaucaauuugauuugacagucgguauaacugauccugagaagauag\n", + "ggcugaguuuuaugacpcccggugcugaapcapaacaacuugauggugcuacuuugaacugcuuuucuuuucuccuuuuugcacaaagagucucaugucugauauuuagac\n", + "gacpcccggugcugaapcapaacaacuugauggugcuacuuugaacugcuuuucuuuucuccuuuuugcacaaagagucucaugucugauauuuagac\n", + "paguggagccagcagcugagaccccggcaapcaaccauggaucuggaguuggaacpacaaugcgccaucaggccggcagaagcuggcagaugapccgaguugcggcacacaggugccag\n", + "aucuccaaauagaggaaauuggaaagaaaaagauaaagcuaaucuguaauuucaucacccggagacaacugcuguugacauugcauugugugucuaaggaggacuuugacag\n", + "agaaacaaagugauacacgcuaggcauguccagacauuaaccguaaucagaagccuccuapuugcaagccuccuuggcuaaugguup\n", + "cuuugugccucacucuucucuuacaccupagucaagucuggauccucugcuccauauuuauuuagcaaauaaaacacugaucucaaacagcaacggaaccuguguacuugag\n", + "gauacacgcuaggcauguccagacauuaaccguaaucagaagccuccuapuugcaagccuccuuggcuaaugguup\n", + "gagaaacaaagugauacacgcuaggcauguccagacauuaaccguaaucagaagccuccuapuugcaagccuccuuggcuaaugguup\n", + "cucuuagcucupccacagcgccagcgccacucugccaggcucccggccaucgcccgccuggugcgccgcccgccagcucuuugcccgcgcpccgcccgccgcpcucapcagacc\n", + "gcugcagcaagaugupacaaccucaccugcuggccagccaccccucpccagguaguugucuuggccuguccccucaucuucaagcucuucuccuccauucaag\n", + "gccgcaauguaagccgcagcugcaccgacgaaggcuggacgcaccuggagccuggcccguaccccauugccugugguuugg\n", + "ucgcccgccuggugcgccgcccgccagcucuuugcccgcgcpccgcccgccgcpcucapcagacc\n", + "pccacagcgccagcgccacucugccaggcucccggccaucgcccgccuggugcgccgcccgccagcucuuugcccgcgcpccgcccgccgcpcucapcagacc\n", + "agcucupccacagcgccagcgccacucugccaggcucccggccaucgcccgccuggugcgccgcccgccagcucuuugcccgcgcpccgcccgccgcpcucapcagacc\n", + "acucugccaggcucccggccaucgcccgccuggugcgccgcccgccagcucuuugcccgcgcpccgcccgccgcpcucapcagacc\n", + "agaagaacaaaagcauuuggaaguaacaggaccucuuucuagcucucagaaaagucugagaagaaaggagcccugcguuccccuaag\n", + "pacagaagaacaaaagcauuuggaaguaacaggaccucuuucuagcucucagaaaagucugagaagaaaggagcccugcguuccccuaag\n", + "ggagaauguacauucaugcauuuuggcaagacugaguccucugaguupugucucggaacucuccuauuuuccuucuaaapucuuauguaag\n", + "uaaaaugucauuaggagugagaaucaggaaugauggauucacggucuaguugcaagacucaucacaggccauuaaccucugaaaagccuuuaucugcuucg\n", + "ugauaauugaaaauccucugauccaaagaaaggaaauagaaagagaagaaaaauucagcccugcaacuccuag\n", + "guuggagagccaaaauacuuuacaacuucagaccggagaaaaggccagaggugugaaguuagacucuaugaugaaacagagucgucuuuugcg\n", + "augagugacuccaaggaaccaagacugcagcagcupccuccupugaggcupuupacgcupauucupaapaapauggccagcc\n", + "pugacaugagugacuccaaggaaccaagacugcagcagcupccuccupugaggcupuupacgcupauucupaapaapauggccagcc\n", + "accccagccccgcccggaggcgccccgcggccccggcuagccapcpcggccaccucugcccuacuccuucccuccgcguuccpccucggagccgccuugaggagg\n", + "pcgcagcggcgagaggaggcgaagguggcugcgguagcagcagcgcggcagccucggacccagcccggagcgcapcggccgcugcagguccccgcuccccuccccgugcguccgccc\n", + "aauucuguccacagapcggcgcagupcugcuucgccgcgagcucgccuccpcucccacgucguggcuuccpcagguaccpcagcuggagacgccagagccggcgg\n", + "guugcucgupccccgcpcagaagcgcuuccacugcagagagccaacagaacpapcuguacagcugcgacaucaccgcccpccaugcacgcggaucgaguuugauaacgaug\n", + "cuucaaauauguuuuaacuuuuauaaucacupaauauaaacaugaauagcuuccuuaacugugaaucagaacacucaaucag\n", + "gcagapugcccaccugugugccagcgccuguccggcgccugccugccgccuccguggcgaapacacag\n", + "uacgcacguccugauucuccuggagucuccagcccgcccaguggccgcagucacccagguccagaggcggcgguaucacaggcucuccgac\n", + "pugguguggacggagaaagugaaaggugaggcacggcccugcagauuuuccagcggaucccccgguggccuc\n", + "ggcacaacacaacaaaauggcugccgcgccgcupccccugaggaaagagcccgaacuucucccgcucuaccucagccugcpacugcucggcucggcuucuaggcg\n", + "acaacacaacaaaauggcugccgcgccgcupccccugaggaaagagcccgaacuucucccgcucuaccucagccugcpacugcucggcucggcuucuaggcg\n", + "agcauuagaaagcguuccgcccacaguuucucuguucucaacggcucaguuuuaacaggauaaauuuuaaguuaag\n", + "aaccggcacaacacaacaaaauggcugccgcgccgcupccccugaggaaagagcccgaacuucucccgcucuaccucagccugcpacugcucggcucggcuucuaggcg\n", + "acaugcgccccucucaagugcuggcagaccacugugcaugcagacaacgcacccaaapaagaaucapaacaguaacgcaacccugccagcaugccaaugu\n", + "gcgcgcgcgucccggaagcagaagccuguguggccuucccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "agaagccuguguggccuucccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "uguguggccuucccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "gcugcgcgcgcgucccggaagcagaagccuguguggccuucccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "gcgcgcgucccggaagcagaagccuguguggccuucccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "ggccuucccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "cccggcggcugauucgapcuuguuuggucagaappcgucagagaagcugccccuuagccaacc\n", + "cccucuucacugugagcucagagcagcaggacaaagugcucpacaaggacauapcugagaguagcc\n", + "cccccugcccpacaugcccacgauggccaggcccuguccacagaccupugucuacacaugugaggccagcaaccggcuuggcacggcagucagcagaggcgcucggcugucuguggcug\n", + "cuuuuuuagcgccaucugcucgcggcgccgccuccugcuccucccgcugcugcugccgcugccgcccugagucacugccugcgcagcuccggccgccuggcuccccauacuagucgccg\n", + "ucgcggcgccgccuccugcuccucccgcugcugcugccgcugccgcccugagucacugccugcgcagcuccggccgccuggcuccccauacuagucgccg\n", + "caaagaacagucugaacuugaucaagauuuggaugauguugaagaaguagaagaagaggaaacuggugaagaaacaaaacucaaag\n", + "gccaguuaggaaaacuucaugagauuggauuguccuauuaaaaaagcauaauacauuuucauaaaauccuucuuucgaugcccuuuuuuuuuuaaagcacgucagcuaacuguucag\n", + "cgauuugaaauuauuaaugcaauuuaugaaccuacggaagaagaaugugaauggaaaccagaugaagaagaugagauuucg\n", + "gaggaauugaaagaaaaggccaagauugaagaugagaaaaaagaugaagaaaaagaagaccccaaaggaauuccugaauuuugguuaacuguuuuuaagaauguugacuugcucagugau\n", + "uuuuuuagcgccaucugcucgcggcgccgccuccugcuccucccgcugcugcugccgcugccgcccugagucacugccugcgcagcuccggccgccuggcuccccauacuagucgccg\n", + "gccgccuccugcuccucccgcugcugcugccgcugccgcccugagucacugccugcgcagcuccggccgccuggcuccccauacuagucgccg\n", + "gcgcagucccagcauuucuggaggccaaggcaggaagaucgcuugauuccaggaguuugaaaccagccuggacaacaua\n", + "gugccaggucucaucuccaggccuuuccucuaggccaggcaguguggaaggaagcauuugcupacgcggu\n", + "gauucaaacagaaagaaaugacuauggcagugaaacagacuuauauggacuugugucuaacauuuuggaagaacaagauaagucacagccauauuuugcugaagg\n", + "uccgauuggcpapapccgaacpcgagguupcugccgugcugcucggcggcgcugag\n", + "agauuuugaugaugagaagauccuuauucagcaccaaaaagcaaagcauuuuaaaugccauauaugucacaagaaauuguauacaggaccuggcuuagcuauucauugc\n", + "cugupacguggugguagccguupuupaaagugapauuuuuggccucguuucuccugcuucuuuucuccucccuuuuacuuugccgguagaacacaguu\n", + "augaaguaugcucagugugccagcaapcugauaaucagcagaaggacapugcuucguuagucagaagagccapcuucccggcugccaggcuacagaacucgccucgccacuccugagac\n", + "pccgcucggcacaggccpacaugaacgccuggaagucuggcupagcggacccaugaucgaaggaccaaaggagccgcuugaucgcuggaccuggcccugcgaccccaguc\n", + "ggacaugaacgccuggaagucuggcupagcggacccaugaucgaaggaccaaaggagccgcuugaucgcuggaccuggcccugcgaccccaguc\n", + "upaaaacguguuuucaauucaaauuaaacaaggaguaacaggcaccgcuccucaguccagaggccuggcccugccaagaaggcgcucuccggaaucaacaccupcuuggaag\n", + "aaaacguguuuucaauucaaauuaaacaaggaguaacaggcaccgcuccucaguccagaggccuggcccugccaagaaggcgcucuccggaaucaacaccupcuuggaag\n", + "aguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "gaagccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "uauaacaagaggauugccugauccagccaagaugcagagcacuucuaaucaucuguggcuuuuaucugauauuuuaggccaaggagcuacugcaaaugucuuucguggaagacauaag\n", + "ggccapcuugcgaagccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "guggccuccggccapcuugcgaagccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "uguggaaaucuaaaaugagaauuucagaaguauaagaauuaauuaaaagauugugaagucgagcaugguggcucacgccuguaaucccagcacuuucggaggccaaggcag\n", + "aaaacuggugauuuauuugcuaucaaaguauuuaauaacauaagcuuccuucguccaguggauguucaa\n", + "ggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "acguggccuccggccapcuugcgaagccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "ggccuccggccapcuugcgaagccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "gccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "gcgaagccggaaguguccugagucucgaggaggccgcpagcccgccggcgguggcgcggcggagacccggcugg\n", + "gcugcucucgguuuaguccaagaucagcgauaucacgcgucccccggagcaucgcgugcaggagcc\n", + "uggcguguccccagaaggucauacuccaccauguugucucaucuugcacauccccaagaaguugcuucucccugacgucugcguuuaauuaagugcaauagguguggaccaucaggaa\n", + "gucuuapaaaagccagagcuuccagauggaggugaugaugaugacauuauagcagacauaaguaacaggaaa\n", + "cugcugcucucgguuuaguccaagaucagcgauaucacgcgucccccggagcaucgcgugcaggagcc\n", + "ugcugcucucgguuuaguccaagaucagcgauaucacgcgucccccggagcaucgcgugcaggagcc\n", + "acuauuucuauugaucuggaagaagcuuguaccaggcaacccauuuaggagaaguuggaugaagapagapag\n", + "acagaaguggcgccucugagaaaagaagguuggaauuaucguaauuuguuucuaggcugagauaccagc\n", + "aagcacucuucuagcccagagaagucuguuccaggacpcucuuucaggagcagcuaaagucapccauguccaccaugugauagaaagacaag\n", + "guagugapaaguugcagaccuauguaacuuuggaaaugaguagagucugucaaacuaaagguaaaagacaccguauauaaacacuguacuccagcugauaaaauuguuuaccaugag\n", + "aaaacaccauucagcugcuuuaaguuucugacuguccaguuaagaacuguuucaagccaaauaugaacagaagauggacggaggaaacacaguaaaagagagacgacucuguggcucacagagagcag\n", + "gcuaagagcacaguuuugucuugguuuccaguuugugcuccacuacuuaucagcugugugaucuuggccaagugcuuaauuuuuuugaaccccaguucccccaucuggaaacuaccucau\n", + "aaaccaguucacgccggagccccgugapaagcgucuccguupuccggccgcucugcpacucugaggaaaagcucgcaccag\n", + "guaaagucaaaaagccugagccgaugguaacgagugguacuguuuccguuucuuuuccaucuauugcaacuuucucaagcauuuucagcucugaacuuuaauuccag\n", + "aguuucapucucgccggcagccccagccggcpcgcggagcpcagcpcccggaucgcaggcuccucupccccggaguupaagcggcguccpagcccccggaggagg\n", + "cgcaaaggaccugacgacgugcugcgucguuacuuuugaaacgcuuggcpaagugcuguuggagccgcugugguugcuguccgcggaguggaagcgcgugcuuuuguuugugucccuggcc\n", + "cugacgacgugcugcgucguuacuuuugaaacgcuuggcpaagugcuguuggagccgcugugguugcuguccgcggaguggaagcgcgugcuuuuguuugugucccuggcc\n", + "gucguuacuuuugaaacgcuuggcpaagugcuguuggagccgcugugguugcuguccgcggaguggaagcgcgugcuuuuguuugugucccuggcc\n", + "acuccuuccuuuccgcuccucaucaucuggaaagacccgcccagcggugcugucgcucgcgcuggaagaagcggaagaag\n", + "cugaaccuuagccggccgaucgaggagcapcccccuggacgucaucauccacaagcugacugacgucauccuugaagccgaccagaaugauagccagucccuggagcuggugcacagguuccag\n", + "gaguacaucgaugcccacccugagaccaucguccuggacccgcucccugccaucagaacccugcuugaccgcuccaaguccuaugagcucauccggaagauugaggccuac\n", + "gauccccguuccgcguccccgccgccpaggaggugcccacucgcucgcggcgcgcgccggccgccagacucggccugupcgauuuccuccggacccaggcuccccgcccgaggaggaag\n", + "guccccgccgccpaggaggugcccacucgcucgcggcgcgcgccggccgccagacucggccugupcgauuuccuccggacccaggcuccccgcccgaggaggaag\n", + "gcpcapcggcgagugcgcpcgcucgccgccgcccuucucggcpcagcgcgcgaggaccaggccgaggaggaaguggcggcggcggcggcgg\n", + "agugccugccgcccacggccgcaggagucpcuucggucgcaccagagacagcggacuuuccuccgaugguugcagcagapauc\n", + "cagugccugccgcccacggccgcaggagucpcuucggucgcaccagagacagcggacuuuccuccgaugguugcagcagapauc\n", + "gcccacggccgcaggagucpcuucggucgcaccagagacagcggacuuuccuccgaugguugcagcagapauc\n", + "cggccgcaggagucpcuucggucgcaccagagacagcggacuuuccuccgaugguugcagcagapauc\n", + "ccuuucucuccucugagccacaacuaaaugauguuucuacuuuucccuuucuacuuuccuagacccuggauuuugu\n", + "auaauccugauguaaaccauugacauagccagaaaaucaccaggcugugauuuuccaaacucagcuucauaaccuauucugu\n", + "gaccggagcapccccaagcccccpccuggupacgcgcuucuucccacacugugagccucagcagcuccagccagcggacccgacggcugagag\n", + "uuuugauuuguguuuguauauuuaaacacuuugugcgacuuucagcuacucupcaguugaaaaguagaaagucauac\n", + "cgcuuuggcaaacccagcuugcagccaaugaacccgccuuccagauuggugugaagacagaagugag\n", + "uccuauuuuguaacggauuaugauccaaccauugaagauucuuacacaaagcagugugugauagaugacagagcagcccggcuagaua\n", + "gcaguccuauuuuguaacggauuaugauccaaccauugaagauucuuacacaaagcagugugugauagaugacagagcagcccggcuagaua\n", + "aucucagaugcaugcagcuccugcupcgguuucauucucugccagccauucauucacauuaaaagcaauggcccauuaaggaaauaaguggaugaugcuccuccaucaccc\n", + "gugguauucaggugaugaauguggauuccguuuugaguuggagaaauuucuuuuugucaguuuggauuuaauuuuaagaaauaaugag\n", + "aucucagaugcaugcagcuccugcupcgguuucauucucugccagccauucauucacauuaaaagcaauggcccauuaaggaaauaaguggaugaugcuccuccaucacccaug\n", + "gagguagcgaggucapucaagaguggaacacccucacuggcccpccggcgcpapcugugug\n", + "gccgagguagcgaggucapucaagaguggaacacccucacuggcccpccggcgcpapcugugug\n", + "gguuccugcupugccgagguagcgaggucapucaagaguggaacacccucacuggcccpccggcgcpapcugugug\n", + "agcccuccuaccugcgcacguggugccgccgcugcugccucccgcucgcccugaacccagugccugcagcc\n", + "gccacaucccggcagcccuccuaccugcgcacguggugccgccgcugcugccucccgcucgcccugaacccagugccugcagcc\n", + "ccuuauuuagugucucugacaaaaccggccuuguggaauuugcaagaaaccugaccgcucuugguuugaaucuggucgcuuccggapacugcaaaagcucucapaugcuggucuggcagucag\n", + "gcacguaaaaaaauuugaagaapaauuucgcggcauucuuggccuggcuuccuggcguagccagcaaguucggagguguuaaccgcugcuguc\n", + "acauaauuaccaauuaggcaguagcagaggcpugccgaagcacpucupugacuaggaagagccgagacugcgaaggagaacgcagcaagcccaggcggcgguggaaaggugaup\n", + "cgcagcaagcccaggcggcgguggaaaggugaupuaucuggauuccauagguuuuuccuuuuccccuugcuag\n", + "agcuggucggcccgcggcggugcugcgcggauccggcgucpcccggcauggcpccpccaagccpccggacccggaccuaa\n", + "cugcgcgcgcagcuggucggcccgcggcggugcugcgcggauccggcgucpcccggcauggcpccpccaagccpccggacccggaccuaa\n", + "acggagcagcuacucapacaaagcucuugguuccuuccuuauccgccucagugaccgagccacuggcuacaucuuguccuacag\n", + "uuccuccgugucacaaagcaguaccugccccacguggcgcgccucugucugaucagcaccuuccuggaggacggcauccgu\n", + "acuuccuguggaggccgcagcpugcpcgccgacpcgagagccagcgagcgagcgagcgagccgagccgagccucccgccgucgcc\n", + "cagcpugcpcgccgacpcgagagccagcgagcgagcgagcgagccgagccgagccucccgccgucgcc\n", + "gagacggacucuugcuauguugcccaggcuggucuugaacuccuggccucaagcaauccuccugccucagccucccaaagcacpauuacaaac\n", + "aaggugcacauuccuccuuguucauuuuuaagcagcuuccaaagcugcuguugaugaugccugaugcugcuuugaaggcagaaaaccaacagugagaucaagaauu\n", + "guucucuaaugaucuugguucaccauggcuacaaauauggapcugguucagcacagagupacccagcagguggcugag\n", + "agguucucuaaugaucuugguucaccauggcuacaaauauggapcugguucagcacagagupacccagcagguggcugag\n", + "ggacgccguccggacauucggcgcgcuugccacgaucuuggacpucucpccucgaccuuugaauuccccgcuccggcuccaag\n", + "ggccguuggcugapupagccacggcccgaagaccucugcpagacgccagccugcgucugcc\n", + "gugcapuguuggaacccuuugaagaaguguguagcuaauagcccauacauaauucagaagaagucuuca\n", + "aaaacuaugucaggaauggagguuugcuaacccagaaaauucgaaggaacacauuaaacugguggaugcagcagauguaagcgcu\n", + "gugcapuguuggaacccuuugaagaaguguguagcuaauagcccauacauaauucagaagaagucuucaauggaagacccccpauaaauggacagucu\n", + "caccuugaauaacucuaguuuaugugguugcaaguaauggaacuuaccaugagcuggcauaagaaaacaaaaggaaagucuuaagaaagapcaucupaauucag\n", + "pcggcgaucggcgcccpaagcggcugapcgccgcgacucucagcgagcgccgcccgagccccagcccgcccpcagccuccgaggccuapcgccgccgccag\n", + "cccauuggcacugcuguucaauauguuacgacauuuggagcaaccacagcagcagcucucaccagaaauuaaag\n", + "auuuuuauuguuagguauauugaccaaaguuuaacgagaagaacugugaucagcupaggauugcugcaagga\n", + "agacucugcuapuuagcagagcagccgguaacguugcuggaccpacgcacgcucagcugaggaggacccccaaag\n", + "cccaugcucuagapacguugccccaauccugaaggacuucggcacucgagaccuguggaugccgcguugcuguggccugcpugauc\n", + "gucccuagcaacacccugcagcguuugaaaucugapaaaagacuguagucagcccuuagugg\n", + "acacacaugagauuccaucacccaggcagcauuccugagccuupacugguuuccaaugauucuuaggcuucugucauucuuugcugccuaucu\n", + "gcugagagugccacuugcuuacugccagaacucuguaugcauacaacccaaaauggacucugccagugauuagauuugugag\n", + "cugcccaggagugaguagcugcuuucgguccgccggacacaccggacagauagacgugcggacggcccaccaccccagcccgccaacuagucagccugcgccuggcgccuccccucuccag\n", + "acucauuugugcacuuacucapacacagccugccucuguucugaaaggacaggaacuucucaaugauccg\n", + "acggccggagcuguuugugcupagcugguggcgcggugcapcucuuaagaacgaacggcuupcgcgg\n", + "uguggcauaccuuguguuuaguucaagaacuauaaucuagauguaacaccugaaaauaaacucuuuuauugauauucuacaggcagaagaa\n", + "gaauucccagcgcuuuggcuucucugaguupuuguguauapucuucgaacaguuccggaaccagccagcagccuuuaauucuupcggaccacggccgguucug\n", + "cuuuggcuucucugaguupuuguguauapucuucgaacaguuccggaaccagccagcagccuuuaauucuupcggaccacggccgguucug\n", + "uucpcugccggccaaggcggcggcugguggugguuucuggcuucgcuguuccauucccuugucuugag\n", + "guaugacgaagguucuggaggcagcpaugaaggcagagaugaggcccacaagcpaguggaaccucuucuaucagaagcag\n", + "ggcugcagccgcccuccgcgcucgccugccagcucccucgccgcgcguccguccuccguccucccpccagccagccagccagccagccpccggcggcpcaccaggccgucccg\n", + "pcugcagccgcccuccgcgcucgccugccagcucccucgccgcgcguccguccuccguccucccpccagccagccagccagccagccpccggcggcpcaccaggccgucccg\n", + "uuuuacucagucccuguucaagauggagcugcucccauucaaacacuucugacauguuuacuacugccuggcacagag\n", + "guauggcgugagucccgagaacauuauccucuauggucagagcauupacuguccccacgguagacuuggccucgagguaugaaugcgcagcgguaauucuccauuccccucug\n", + "gacaggaaaggccaugugaggacauapagaaagcagccaccauuggcaagccaagagagagcccucaccaggaacgauuggaccagcaccuugaucuuggauuuucuagccuccagaacu\n", + "uacpuggcuggcaagauggccgaauaggaagagcuccagucuacagcucccgcagagaucaacgcagaag\n", + "cgcccgcgcgcugcagccccaucuccuagcggcagcccaggcgcggapagcgaguccgccccgagguagguccaggacpcgcacagcagcagccgaggcuggccpagagg\n", + "aucuugcuggcacuccgugcacuuaaugauuccuaagaacucacaugaacugagcaaaugagauagaaac\n", + "gagagugcgaccgagauguuccacucgcuggcguccpccgcuggugaucuccgguagcacucpccggcggacagugapcgcg\n", + "agagugcgaccgagauguuccacucgcuggcguccpccgcuggugaucuccgguagcacucpccggcggacagugapcgcg\n", + "ccuuccucugccaggacaaguuugucgucugcucugagcuaucaagccccuuaggagaccuaggacccagcupucccaucccuuuggaguagcugcuucagacuag\n", + "aucccugacagccuuccucugccaggacaaguuugucgucugcucugagcuaucaagccccuuaggagaccuaggacccagcupucccaucccuuuggaguagcugcuucagacuag\n", + "gaaaggccuuggaaagcagucguugcgccagacagcccapaagagcggcagccugaggaccuapccaccugcuguucccupauucauguccuucupaggapaggacccaggaca\n", + "ggaggagcgccuggcagagcpaucuucapcagcpcaaccccuuggcccaggaagccuggaacgcaaggaccggapcgupcupacgccccuaccuuggucuuucagg\n", + "gacuugaauggaaggagcccgagcccgcggagcgcagcugagacupagcgcguucggccugupcgccgcucggcgccpcgcagcag\n", + "aaaccuuccacacupaaggcagcggcgaggcaggapcucauggugagcaaggaggccggcugaucugcaggcgcacagcauuccgag\n", + "gauggucuuaacccuucaauuacgagcpcggcgcugcguuuccapcagaggaaacgaggcgccgcguuggcgcuuggacggcpaaccggcuccggagcgagaacgcgc\n", + "caacugacagucccaaapcuggagaugccaccccggcaaaguucgcccuagucauuugcuucac\n", + "agcpcggcgcugcguuuccapcagaggaaacgaggcgccgcguuggcgcuuggacggcpaaccggcuccggagcgagaacgcgc\n", + "gucguguguguuupcccgcgcpuugcgcgcccuccgccuucgcgccuccugcccccgaggcccuacugcugccccugugccccucgccccgccpcgucgcpccaac\n", + "ccuucgcgccuccugcccccgaggcccuacugcugccccugugccccucgccccgccpcgucgcpccaac\n", + "gcgcucggcuggcggcugcagcagcagapagacccgcggcaaccccggcaacccapcucggcgucgcugccacc\n", + "gcaucucugccggccuugccacaaccgugagaaggccaapccupcaaguacaucugccagcggugccaccuggucaucgacgagcagccccuc\n", + "gcauucugaacuucagcacaaggcaaacgcagaaccapcuuggaauuucgccgcuaugcagcugcaccccugccacccaggagaucugaggcuccucagagcupaggaccgg\n", + "augaggucaccagaggccacagaggcugagccacucaggaggccagucacagguccaccaguguccggccaguguuugucccugcagcccuuucuggaaccuagcugg\n", + "gaaaagaaagupagagacaggaacapuccggagcagccccagcagcagcauugagguggag\n", + "gcccugccugccgcaccucuccuuucuucuguagcucgcguugaagccgcacguccggccccgaucccggcacc\n", + "caccaccagcggcgagupugacagagcccccgucuccgcgcgucuucgccgcccugcgccgugacccgcuguggcacupccacgaguggaggcugcgccccuccag\n", + "ggaucaguuucauucacggaugugacuguggacuuuacccaggaggaaupaacaacuggaccccucucagaggauccuauac\n", + "cuucccccaccaccagcggcgagupugacagagcccccgucuccgcgcgucuucgccgcccugcgccgugacccgcuguggcacupccacgaguggaggcugcgccccuccag\n", + "gcccuucccccaccaccagcggcgagupugacagagcccccgucuccgcgcgucuucgccgcccugcgccgugacccgcuguggcacupccacgaguggaggcugcgccccuccag\n", + "cgccgcccugcgccgugacccgcuguggcacupccacgaguggaggcugcgccccuccagguacgagapcuuccag\n", + "agcuggagcuaccgagcggugccaggccaggugugugcguccgucggucuuuccgugcccacgccggagaccagccccggaggccgccupccuaucccugugccaggcacc\n", + "gguugaaaaauauaggccaguaaagcugaaugaaauugucpaaugaagacaccgugagcaggcuagag\n", + "acucacuuuuccccuucgucuuucucucccuuucugucuuucugugucuccuccaagaaugaaau\n", + "gcggcggcggcagcggcagcggcagcggcgcugaguuuugucucccpccgucupcgcgcgcpugucccag\n", + "gaccuggaguugaugucacguccggcggcggcggcagcggcagcggcagcggcgcugaguuuugucucccpccgucupcgcgcgcpugucccag\n", + "gaugucacguccggcggcggcggcagcggcagcggcagcggcgcugaguuuugucucccpccgucupcgcgcgcpugucccag\n", + "gcaugcgcccgcccggcgcccgcccggcgaccuggaguugaugucacguccggcggcggcggcagcggcagcggcagcggcgcugaguuuugucucccpccgucupcgcgcgcpugucccag\n", + "aacuuaucucacuggaauuuggauucagaaguaccuguuucugaaaauaaaaaccucccagcuggaapauggagcagcaggug\n", + "cpcgacagagapaggaggcgcgcpacpacgcccaggaggacccacucgcpucccgcuccgcuccggcagcagc\n", + "pacaaacuuuucccaaacccgauccgagcccuuggaccaaacucgccugcgccgagagccguccgcguagagcgcuccgucuccggcgag\n", + "ucgcucucccccucgapacaaacuuuucccaaacccgauccgagcccuuggaccaaacucgccugcgccgagagccguccgcguagagcgcuccgucuccggcgag\n", + "gcacucpcgacagagapaggaggcgcgcpacpacgcccaggaggacccacucgcpucccgcuccgcuccggcagcagc\n", + "gagcccuuggaccaaacucgccugcgccgagagccguccgcguagagcgcuccgucuccggcgag\n", + "ggccagaagcucauagaacuuucugaapagcaggucaucagccuuagcaugagccccggagcaucagugucugcuggccguugugug\n", + "pupuggccuuccaucuuguguucuagugaaucagaacagcccacuucacugauggugucuuuuuaacucaaagcaucccagcu\n", + "gucuaggcugagguucucauccaguaaaauuucuccagcacuaagugugacugaagcacaagacaagauucuuuauugucuccaggaaggcaaugug\n", + "acggagucuuacucuguuguucaggcuggagugcagcggcaugacucagcucacugcaaacuuugccucccagguugaaguaauucuugugccucagccuccugaguagcugagauuacag\n", + "ggagccggagccggagccgacpcgguggccgcacupaccccggaaucccgcgcgcugcccacgauucgcuucugag\n", + "uuuccacuugcugcucaggagguauugagaucaaugaacacuaaccugaggagcauauuuuuaccaaauuaaagagcuacagugaaauauguguuccagguuccugguuuuaagcuaaau\n", + "gcaggacaacgccugccacgcgucggaacucggccgcpacauccacpcgcgagugacacgcpapagagcaguguucugcuggagccg\n", + "acgcgucggaacucggccgcpacauccacpcgcgagugacacgcpapagagcaguguucugcuggagccg\n", + "gcgucggaacucggccgcpacauccacpcgcgagugacacgcpapagagcaguguucugcuggagccg\n", + "cgucggaacucggccgcpacauccacpcgcgagugacacgcpapagagcaguguucugcuggagccg\n", + "gugacgcaggacaacgccugccacgcgucggaacucggccgcpacauccacpcgcgagugacacgcpapagagcaguguucugcuggagccg\n", + "gcacccpcgcugcuggcggccaagcuggaupucgccagugaguuucggugcggcaccgcuggcccaggcccpcgcggcuggac\n", + "gguugucuccucacagacuaugagcuccuugaaagapaaucgugucuuacucaucuuuguauccccagugucuagcaguuccugauacaua\n", + "guuuuuggcuacugauguuacaaacaauaaaauauuggagcauagaguugaagaacagacucaaaccag\n", + "gcuggagugcaguaaugcgaucuuggcucauugcaacuucugccuccupuuaaapauucucaugccucagucccccacggaacupacuacag\n", + "pcgcggcugugucagcugagugacagucacpaccgcgaccaacucugucuggcuuccuagaggagcaggap\n", + "agcgagcccagcuccggucccagccccggccgucccggcgucgcuucggagcgcggcggcagcugacugcgccuucacgauccgcupacccgcgagccccgccgccguu\n", + "gucgcuccugugguugguccagcccagaaugcagccuugagccuggcuuaggccaccaccuacuccagcucucuccacccccuauuuuacugcagcucap\n", + "gguauuugcaucucucccuccaacuugccauuggcggcgcgaagugupagagcccugcgccucgcccgcccggaccagccugccccggcgccgag\n", + "guuggaagcggagugauuccccaccccugcuccaucuagcucuuuccagugcagccacugccgccgcccaggagcccucguccccugccuugucccccuacucguucccgcucccacggc\n", + "aagcggagugauuccccaccccugcuccaucuagcucuuuccagugcagccacugccgccgcccaggagcccucguccccugccuugucccccuacucguucccgcucccacggc\n", + "cauggacaugaauguguggcuuaaauuacauugcugugupcaugaaucagacgcucugcccaugaagaguucuagcaccaagucagugcaagacccgaggug\n", + "acucacggaaaugccuuggcagagucupucccuggacugagccaucagcupucacugagaccc\n", + "guuggcucuapcuggcaccaggcacuggaauuaaacauucuggacuccagapcaugaaaacucuuccugaaggagaugcagaggaagauucgaacuggaggaaaacccuaaaau\n", + "cugagcgccgcpccugcgccauugaggagcggcpaggaaacgccgcgcagcgccpcupcpcggcccpacaccgacag\n", + "auuuuucugugaccaugaaagagagaaauaaagaaugauccaugauuucuaaacaccuuuuccugaggauauaguc\n", + "cuucgccucaacagcaucaagaagcuguccaccaucgccuuggcccuupuugaaaggacccgaagugagcuucugccuuuccuuacag\n", + "auaccaucuaugaugaagaugagguccuccuggcccuggcagaacagcupaaccuucacuacccuggupaggcccagaguacgugcacugccugcug\n", + "aauuggcgaaggcuucgcccgacgccggaacugcgagcucucagcpagccgagacggugcapccggagaagcaccuucacucccagccugcgccccg\n", + "auagguggagcaauuggcgaaggcuucgcccgacgccggaacugcgagcucucagcpagccgagacggugcapccggagaagcaccuucacucccagccugcgccccg\n", + "aauuugcggacuupcaupacugagucaaccuguccccaucucugauccugugcuuagguucuguacg\n", + "agcguucucuagcccuuaggcagccgaaucccuaauuugcggacuupcaupacugagucaaccuguccccaucucugauccugugcuuagguucuguacg\n", + "gagcucucagcpagccgagacggugcapccggagaagcaccuucacucccagccugcgccccg\n", + "ucggaacgugacuggaugguagugugcuggccggucugccuccpagaaccgagcgcuuccggugcgugug\n", + "gapaggaggugagagugauuagupagaagaaaagcaggcccaggaccaagcccupacupacauccucggugacccuguggagcauugagcc\n", + "aaacagugacccagagacagguggacaaagaauucpacugaupaacugagcuupauccagacugaaacugauuccagacugaccucuagcacccaggacccagacacapcc\n", + "caccuuguccaaupaggaccuaagupagagugagaguccugcuuugagaagcuaagaugguggauggugcag\n", + "accugcpucggacccgcugccuaccgcgugcccggcguccucgucgcgcgaguugccggucccgcpccupcugcpcccacpucccpauggcgucggagccgcgcuaacuccg\n", + "cucuggcgugccaggaaugcggcacpagaguccgugcuucugcagccggccccucggagcugcgaggucacaguagac\n", + "gaauaugaagacaaggcuggaagaccuagcaagccacccucuccaaagcagaaugugaggaagaaucuugacuuugaaccacuuuccaccaccgcacucauccucgaggacagaccagc\n", + "gcuggaguacaauggcaccaucucagcucgccgcaaccuccaccuccupuucaagcgauucuccugccucagccucccgaguagcupauuacag\n", + "guuccaagucucuucuucggccucucaaacaugguaccaucccuaaugaagucaacpuccagcaugacaggauggaaguacaagugucagcaccuau\n", + "uuucuauuccaaggacaaugaaggcagcugguuccgcucccucuuuguucacaaaguggauccccggaaggaugcccacuccacccugcuguccaagaaggaaaccagcaaccucuauaagauccagu\n", + "ggaggcugugcugcccaagcuucaccuggaugaggacuacccaugcucacucgupcaacuggaacacgugguaupagcaggaccaggcag\n", + "pacagccapacaggcagacaugcagccapcuccapccuggacapcugccaggcccugugacaggaggaccccgagcccccggcccpapccauggugcugccuguccaac\n", + "aggacuggaagauaagcaagaaucugaagcuggugccucuccaaguauuaauuuguucuuacaaauguuuuacucaacgugacccuaaccucuuuggaauugcucagguguagaacag\n", + "cuuugacauuguaaaccacagacgaauuggagcuuggcauugaaaggagguguucugcaaugauuuuuuuucuuguuuagagaaguuuacuucuacaagaagaaaucugaaaa\n", + "guagaccaacuuaacacugaacccauuacuuuuccaagaccagaaaaaaauauuacaugaacaggaacuacuucuccuucagauaagaauucaag\n", + "gacuggaagauaagcaagaaucugaagcuggugccucuccaaguauuaauuuguucuuacaaauguuuuacucaacgugacccuaaccucuuuggaauugcucagguguagaacag\n", + "gauuggccuuugcuguucucucaucugugcacccaguguuugguuuauaupucucuguuuccugccauaauuuaugccauauuuggaaupacaucauguugccacag\n", + "ggcgagagagcuguagaccaacuuaacacugaacccauuacuuuuccaagaccagaaaaaaauauuacaugaacaggaacuacuucuccuucagauaagaauucaag\n", + "gcccuccucccuccccupcccugcucccugcccuccupcagccapcagccaggacggcaccaapagcugccccauggacapccccacagagacagcaccgagccucacp\n", + "agagaagaagaaggagguuccugcugugccagaaacccuuaagaaaaagcgaaggaauuucgcagagcugaagaucaagcgccugagaaagaaguuugcccaaaag\n", + "agaagaagaaggagguuccugcugugccagaaacccuuaagaaaaagcgaaggaauuucgcagagcugaagaucaagcgccugagaaagaaguuugcccaaaag\n", + "guggcgcagcuucuccgcccgagccgcgcgcggagcugccpcuccuuagcacccpcgccpcccucgcccuuccgcagccuucacuccagcccucugcucccgcacgcc\n", + "gcgcgcucucgccuccauugccpccagugcpagccggagcggagccpccggagcpcgga\n", + "gcggugcucaaapcaagagcugagcggaacaccggcccgccgucgcggcagcugcuucaccccucucucugcagcc\n", + "aaapcaagagcugagcggaacaccggcccgccgucgcggcagcugcuucaccccucucucugcagcc\n", + "aguugcuguggaagccccacpcaggaggcccccggccagcacauccugucugcuugugucugcugcagaguucupaccpcc\n", + "cgaccacgaaacuacccuacagcaaaguacaccugcagacucugugauguuuuaauugaauccauugcauuugcccauaagcauaucaaggaaaagaggcacaagaaaaacauuaag\n", + "auuguucccuaagauuauaupucauccuguagcagauupuuucaaaaauucggauguaaacauugacauccaguuuccagccauu\n", + "acuccuuuauugauguugaugcagacuuccaugcuapugccagugguggugugcagagaaaagcaaag\n", + "uggucuucuguguaaagugagcgcaggaaaugaaaaugcuugucugacaacaaagcauuuaacugcccuuggaaaacuagaaccaaagcugguuccuuuggugauugcauuuagguacupcaaag\n", + "cuuugcaguauagaucgcccugaagaaggaggucugccaccuuauguguuugcccugauggccauuuucuuucuucagcagaggaaagaaccccuuuugccuguauaucuaggaucaugg\n", + "gugguaucaucccuacucugcagauaaugauagcgaccauuuuuugaacacugugugccaggcacugugcuaagcacuuuacagacacuaucucacucaguccucccaacaacccuaugag\n", + "gaacuaaauugagccuguuuggcuccuccaaaaauggauuupuucaaacagagugaccuugacgucugu\n", + "aguugcuguggaagccccauaggcaggaggcccccpcagcacauccugucugcuugugucugcugcagaguucuguccuugcauuggugcgccucaggccaggcugcacugcupaccupcc\n", + "cugcugcagaguucuguccuugcauuggugcgccucaggccaggcugcacugcupaccupcc\n", + "gagacgugaccacccgccccgcaupccccagucccagcugcuugauccggcucagccccgagguguuugcagcagcucuuu\n", + "gcuuccupapauaguccaccuggaggcauucggagacccagugauugugcuccgcggagccupcugugccccgcguugacugccucauagauacccuacgaaccccaa\n", + "guugcuaggauacgaccaacagcugagaacgcggcgaguauggaagcugcgucuuaggagccupaaagcacuucgacgagaauaguuugguuucguacacag\n", + "ggcgaguauggaagcugcgucuuaggagccupaaagcacuucgacgagaauaguuugguuucguacacag\n", + "ggcagapaaaupccuggcccacpagagcugaggcccacguuuggccaggacapuggauggaggcupccuccgcapaagauggacag\n", + "gcuccagcccccuuuuggacaucguuggcggccggaaggcgaggccccgccaguucccguuccuggccuccauucagaaucaaggcaggcacuucugcpugcccugauccaugcccgcuucgug\n", + "ggugcuugcuuggcucgcpcagaggagccgccgcucgcuggacgccggaccpcaggacggcgcpagccggcggccaga\n", + "cagccpuggcacagcggugucguggccguguugcugaucgccupugguuguuggcgugucccugcagcgaaggauccug\n", + "cpuggcacagcggugucguggccguguugcugaucgccupugguuguuggcgugucccugcagcgaaggauccug\n", + "cggucaggacgucgaagccaaagaagaccagagccagccpuggcacagcggugucguggccguguugcugaucgccupugguuguuggcgugucccugcagcgaaggauccug\n", + "cgucgaagccaaagaagaccagagccagccpuggcacagcggugucguggccguguugcugaucgccupugguuguuggcgugucccugcagcgaaggauccugguug\n", + "ggccaccupugcagcaaugccugaaggccuccuggcaccgagacapcaggagcagaucccaccagcpaaggug\n", + "agauucgaagcuapcpcccgcpcugaggcagcggcuguggcggcgacgcupcgugagguggcggcggccgcgcccugguupuccccacugcucucpcgcc\n", + "gacuagagcaggaagagcagcggcgaggcggcggugguggcugaguccgugguggcagaggcgaaggcgacagcucuapuuggcaccggccccgagaggagg\n", + "gcagcggcgaggcggcggugguggcugaguccgugguggcagaggcgaaggcgacagcucuapuuggcaccggccccgagaggagg\n", + "aggagacuagagcaggaagagcagcggcgaggcggcggugguggcugaguccgugguggcagaggcgaaggcgacagcucuapuuggcaccggccccgagaggagg\n", + "gagcuggcccuaaagcaaggaccugagugcaaguaauuuuuuupaaguaauaacagaaaauaccagcaaggaagaagacagugaacccaaaagaauugaaaacag\n", + "gcacuugguucpccagccgccugapacpcucacgucugcuccucacacugcagcugcupccguggagcuuccccapagccapacuuuugccgcagcc\n", + "gucugcuccucacacugcagcugcupccguggagcuuccccapagccapacuuuugccgcagcc\n", + "cucgccauuccuguaauggcugcuuccuagaagguaauguacgaacucgucuccaaaggauacuuagguugcaccaguguauuuguaaaacaggagcaaauuuggaccuugccpccaaa\n", + "gucgugucacguggaaccucuuaaucucagcauccggagcuccaggaapaaaauuucaagucagauagaauucuauauauaccauuucuuug\n", + "ggagcaucgaguacagcuguccggccuccaacgagugugagaucaccaagcggagacgcaaggccugccaggccugccgcuucaccaagugccugcpupc\n", + "augccuaapuaucccugaaugauacaguuuuguuugaaagacugaaaagcccaaagcuggcccuuuupaaauagcaguaaaucauugauaugugaagguucccagcaggag\n", + "aggcgcacggcggccggcgcpccgagcggaggcaacugcugugcggccugcpcgcgcgcucccuuaucggccaacggacgcgaggcgcgcgcc\n", + "uaccpcggaggugagcgcggcgccggcuccuccugcggcggacuuupugcgacuugacgagcggugguucgacaaguggccuugcpccggaucgucccag\n", + "uggaagaguuguaaauuugcuucuggccuuccccuacggauuauaccuggccuuccccuacggauuauacucaacuuacuguuuagaaa\n", + "guuuagaauupcagaaupacugagaucuugcugagaagguauccaggaugaagaagcugaaggugauguupaaggcccuucag\n", + "auuccuggagccgccucccuguugucccaccucuaccucuccpaacccgcugugcugupacaggaggagaccuagcggacagccuuuggauaaagcag\n", + "cuuucgauuguagcauuucuccuuucaggauacaguacpauccuuucuggaauggaggucuuaugagcugcuauugaacacggcag\n", + "guccggagcuguagcagcagcagcagccgccgugccpccgccaccgcggcpcacccgcgucccpcgcccacggacc\n", + "uuucccpauuuggagcaggcacgcgcggcccpcguccggagcuguagcagcagcagcagccgccgugccpccgccaccgcggcpcacccgcgucccpcgcccacggacc\n", + "ggcggccccuccucggcgagccaugcgugccacpcagcugaguagcugccpcgccgcugccaagucuccacuccgcuuuugucuugcccuccagugaaupaag\n", + "agcucggccupcacuauacccugucauccaguucccugccucggagauaaagauuccagcuac\n", + "aacccupapcacggccpauuaggaggapagcgcccacaccupaggcaggugcggaggcggccggcccpaccucga\n", + "aucugcgauuuccuucugguuggcuguccugcgupugccaaguuccacacaugauuuaaugaauaagaag\n", + "aaaauggccuuacagccupacaaaccgaagcacuguccagaccgagaacacgacuggaagcuaguagga\n", + "aaugugagugcgcuuggaaaagagaccuccugcuccgcpcucpcaagagcccgcaggcuaccuuccccpcapcgcucaacccaaccggcuccapcacug\n", + "cuccugcuccgcpcucpcaagagcccgcaggcuaccuuccccpcapcgcucaacccaaccggcuccapcacug\n", + "ggcaagagcccgcaggcuaccuuccccpcapcgcucaacccaaccggcuccapcacug\n", + "gucagccaguuccugaggaucauccugauaaacuccacaaupucacuaacapccacuucuugcucaug\n", + "ugacuucacuguaggaagaggaaaugcagaaaaacaaacgucuugaagacugaaagccuguuauucaaagagguuagcaguagacuguuggaaguaag\n", + "uggagacugcpcuuggccaaggaaggcgcacauccucpcpcggccgugacgcggcpauuaacuuugcaugaauaau\n", + "gaguguucggagaugauaguccaccuguagagaaagacagccauaaggaaaccgcacuauaaacagcagguggccaagcugguccuuucag\n", + "augaauaaugugagugcgcuuggaaaagagaccuccugcuccgcpcucpcaagagcccgcaggcuaccuuccccpcapcgcucaacccaaccggcuccapcacug\n", + "ggaccccgccccugccgguggcugcgguagcugcugcgcgcugaggcgccugcucagugupacgcggagagcgapcggcggcggcgcccgcuggcgcucaagc\n", + "aaacccuaaugaugaaaaauauagauccauccggauuggaaacacagccuuuucuacuagacucuugccugucagaggagcuguugaauguuuauuugaa\n", + "gcuuccuucccaucucgcucuupucaugccuggccagcagaaagcagcuccauapaggagagccacgcaggaucucacagcugcagucuaauaguaacacagag\n", + "auuguuuuugucuuccaaaccauuaucucuuugaccgaaauacugucugagaaguuccgcapacaaagucag\n", + "cucpcgguuguucgugccgccgccgccgccaggcccgcgccaccggagccccgcggagccgccgccgccgccpacggagcccag\n", + "gaugcaggcguagaggcagcugugcacgcgagguggcgucuccuaggapuupcggcaccgucugcag\n", + "aucaaguuugacuuggagaucgcgguggagcagcagcupcgcagccgcugcccuuccccggc\n", + "aaaaggcgaggcuggccccgccccuugcaccgcccacguggccagcgccaccugccucauugugcccaggaguucuccaaacccgcgcugcgga\n", + "cccuugcaccgcccacguggccagcgccaccugccucauugugcccaggaguucuccaaacccgcgcugcgga\n", + "guuucaagugauccucccgccucagccugcccaggugcugagauuacauguaugagccacugcaccuggaaaggagccagaaaugugaagugcuagcugaaggaugagcagcagcuagccaggcaaag\n", + "acuuaagcugaggaucguuggaucucuggcpugcagaacugagcccaggccacaguacccuauucacgcucugugcuugugccaag\n", + "cuuaagcugaggaucguuggaucucuggcpugcagaacugagcccaggccacaguacccuauucacgcucugugcuugugccaag\n", + "ggagagugugaggugccaaagacuaguaaugccccguaucccccuaggaagccpaagccaagcuccgcpaccgcuuc\n", + "cuugucgacggcggcuucuaggagcuagucgaaggagcgagguugaggcpcagcgacccgucag\n", + "gugugaggugccaaagacuaguaaugccccguaucccccuaggaagccpaagccaagcuccgcpaccgcuuc\n", + "gacccggaucugcgacccccuguggacagagguugaccguaccccggagaggagcuuucucacggapcacugguugcagaggcuggaagugaaauaaagacgcgcucuuguuucagaguucgu\n", + "ccccugcugagauaggaaggcagagccaccuccucuccucucccaccugcagauuaagcuuuucuaaaaagccuaggcaucuucuuauauucagauacccuaucgucgucaguc\n", + "gccugaguucauuucuccuugagcaggaacaguucauggacgaacucugaggaccauucugaggacaagaggcauccagugucaugaguggaacaug\n", + "cugcccaugguguccgcggcpucucucupauggcaagaugcgapugcuccuggugcugcucggccuucucuauucuuccacca\n", + "uucauuucuccuugagcaggaacaguucauggacgaacucugaggaccauucugaggacaagaggcauccagugucaugaguggaacaug\n", + "gcagccggagugacgcguggccgccggcacccggagcuccupcacacggcauuggcapccgcuucggcagagug\n", + "gccuccgaggagcugcugcgugagcacuacgccgagcugcgugaacgcccguucuacggccgccuugucaaguau\n", + "auuccuguccucuggaacacapacucccagaggcacugucagccaaacupcccuaacugcccuguucuugcugguaccuucuggagagg\n", + "ccccucaggaccucuuuuugccuucacuccucugacucaguuuccugcuuacpaucuccugugguguagaccugaauccucaaagagccagaaucuuccaugccuuggagaga\n", + "aggcucggcagucacugaacuupagcugaagaauacuggacpcuucggagaggaaggaugguccaggcgcaccccapuugcg\n", + "pacaugguuacauuaaagcuaacucccgucaucucaauuaucuccuuggaaguaguuuucacaaauauaaaaacgcccuacgguggcuguuuucg\n", + "gugaucauggaggaagcacuuuacucccaccaaaugucacaaaugaauuuccagaauaupacc\n", + "agucacugaacuupagcugaagaauacuggacpcuucggagaggaaggaugguccaggcgcaccccapuugcg\n", + "aacaaagagcacgcggcgcuggccgccggcacucgcgcccugaggcugcggccccggagcgcccggcggcgguuucggcgcgcggccpcuggcgauggaag\n", + "ggcagucccpagcucaacaaagagcacgcggcgcuggccgccggcacucgcgcccugaggcugcggccccggagcgcccggcggcgguuucggcgcgcggccpcuggcgauggaag\n", + "gcgcaguucucccgcccguuucagcggcgcagcuucuguaguupcuacuggapucgcucagaaaccucauacuucucpucapaagguuupagg\n", + "aauucauuuuuaauccuuuaauaguccacaguaauauuguccuaaagapuacauuggauuuuaauuuugcuuucaau\n", + "uccuuuaauaguccacaguaauauuguccuaaagapuacauuggauuuuaauuuugcuuucaau\n", + "ggcgcucuuupagcagugagagagaggcggaggccagagaguccpupcgcpagccpcggcccuuggccgcauucccgcccgucccgcagcggcgcgcggagccag\n", + "pcugagagugucuucuacuuuacucupcaaaugaaggccupagagccupcugauucc\n", + "ggucgguguacccgagagaacugcaaguaccuucacccuccuccacacuuaaaaacgcagcuggagauuaaupcggaacaaucugauucaacagaagacugccgcagcc\n", + "gugcucagagagagagagacuaagacggauaacgcgucaucucgccuucccaaauuuuccccccucgcuagaccpuccaaaaccuccauccggagccggcaggagaggagaacg\n", + "gcucagagagagagagacuaagacggauaacgcgucaucucgccuucccaaauuuuccccccucgcuagaccpuccaaaaccuccauccggagccggcaggagaggagaacg\n", + "pcacagccacccggagcggcgcpugccpagcupcgacgcgccccuccugccccggcugcgcuguugcccpcggccgaccuccgugcgugagcgccggcaggcaccuugcgcgcgcgg\n", + "agauugcuauucuaucucaugagugucacauaaggagguuccuucucuaccuucccagcacugaagaggcauuuuuug\n", + "cccguguccucugucucuugcuucggcgccuggauggcuugccgcccacacaagagcaccuuaaaaccagaacugcuuaaccuauuucugagacuccaaaaagcuguucgcucuc\n", + "ggcaguguguaagacgcucacpcgcgcggacuaucpcggcuaggcucucugaggaggcugccacagug\n", + "gugugugugaccauggaacpagaccggapauccaugguauucaaccgupccuguuaccuccaguacgagcc\n", + "gcaguguguaagacgcucacpcgcgcggacuaucpcggcuaggcucucugaggaggcugccacagug\n", + "cagaacgacacuggcaacugcuagaggaaaagaggcaaguuuauccaaaaguguuauggaaauccccagaagaaggacaauggaaagguccgguggauuugcugacgupacgapu\n", + "aguguguaagacgcucacpcgcgcggacuaucpcggcuaggcucucugaggaggcugccacagug\n", + "accccagcagaacgacacuggcaacugcuagaggaaaagaggcaaguuuauccaaaaguguuauggaaauccccagaagaaggacaauggaaagguccgguggauuugcugacgupacgapu\n", + "aacgcagacgcggagccgagcgcgcccgcaggcucuuugcucagagcucagcccuacauagaucggcuucugcc\n", + "agacgcggagccgagcgcgcccgcaggcucuuugcucagagcucagcccuacauagaucggcuucugcc\n", + "gcagacgcggagccgagcgcgcccgcaggcucuuugcucagagcucagcccuacauagaucggcuucugcc\n", + "aguaugauguuaucuggacupcuguaaaaaucugugaacacuguugcucugaguuaggaacaga\n", + "gauugcugucacgucuaauguggcugcugccucgugucacaucugaaacucaucuguaccucacuuagaaag\n", + "guuugaaucuucagacaaacuucupaggacucggucccugccucgcagcagauguucccugucacucaguag\n", + "gucucuucucacagguuugaaucuucagacaaacuucupaggacucggucccugccucgcagcagauguucccugucacucaguag\n", + "uuucuuucuauaacacaagccugaacauauugcucuccugauuaacaacuuucagugguucugauuagacaagacuuuucguugcagucgacagaaaccuaaupaccauugaagaauuccaaacag\n", + "ggucuuuauaagcuucuucugaaggucucagacauucagccacggaacucaaguggaauuuguuuggauaacgugacugauuucaaagcccggaccccuuagacgugcccauuuggugcugcaa\n", + "cuucauucccugacgauguacaaggucucuucucacagguuugaaucuucagacaaacuucupaggacucggucccugccucgcagcagauguucccugucacucaguag\n", + "gcucaagauaaagaccuuaaagauaacuuugugugucucucccuuucuagguauuugcauaggaaucagaggaguuaaucuu\n", + "gucucagacauucagccacggaacucaaguggaauuuguuuggauaacgugacugauuucaaagcccggaccccuuagacgugcccauuuggugcugcaa\n", + "gucucuucucacagguuugaaucuucagacaaacuucupaggacucggucccugccucgcagcagauguucccugucacuca\n", + "gucacupacccugguuuucacugucaucacugcugugcupuuccuuccaguuuggauaugacauuggugugaucaaugcaccucaacag\n", + "aggcaggagcuagucaggugcaugugccacacucacacaagaccuggaauugacaggacucccaacuaguaca\n", + "ccccgcgccccgaagagucggccagccccgaacugccggaguapupaaccaaacuuuuuccugccccpacagacac\n", + "gcaguacugaagguggcgccucggcagcpcuagaggccacuggcacugagcuugcaaccagauccagagacacugaagaagagagaaag\n", + "ggagaggccuccagguucacacaacuggaacccaucuccaggaacaaacagcuggaacccaucucccguugaapaaacugccagauuuuuguaagauucuuccuccugg\n", + "gcuuaucugucuupccucuuuugucacauauugcucaucugugagcugaggcccugacucacugaguauuuuupagcagaagaaggagacauuucucuccgaaa\n", + "agugagccapaacaapacggaagacaggauccaggcuguaucuacggagagacacagaapag\n", + "auucucugcccuccaccacgcugcuuuppcagccuggagcucauagccuugcugcuagaggcucaggccacuguugacaucaaggacagcaaug\n", + "agcccgugcuccgguuccgguuccgguuccggcuggcgucugcaccugcgaccaccgugagcaguc\n", + "aaucaaggcggacgugaagcaucuacaaaggaggaauagucaaagcagcagcggcggcggcggcggcggcagcagcagcagcagcaggag\n", + "gacuuuaaagaauacugucagaaguucuaucaggcagagcuggaggaguuguccuuugcugaagacacugaagagugcaggaagcauauaaaugacupuggcagagaagacugaag\n", + "guaagauuucagagguacuggaugcupacagucgauccccugacaaagcugguccuugugaaugccauuuauuucaapaaaguggaaugagcaauuugacagaaaguacacaapa\n", + "gccuuccuccucguccuuuagccpagccugucuuugcuugccuuugccuuugaggcucuguggcugupcugaguggcauc\n", + "uucuuucuaccacacucccgaggaagcucccauggacaaagccggauaauccgaaaggcguaccuggaagacuuuuacacccgg\n", + "aggaauuuguccagcuugagccapugcacgcaggaaucugucuggaaaaaggcaguucucacugaggagguuugaggcgcgcgcucupcagg\n", + "aagccuccccagcuuucugaggaugauaucuggcuaaaaagcgapagacaacuauagugccacccuccuggagccugcugccagcucucuuuccccagaucacaaaaac\n", + "ccccpugcccaucaguuuccuupugacuacagcguguguuuuuucuuuccucuuuccccugccugugugcccuucuccagg\n", + "gugcacucggcuccpagaggcgagcagcgccggugagccccgcagcagcgcacccggccgcggagccccgcg\n", + "guucupaauacagugaagaccuugacuuuguggagcuuauuguauggaggagaagcaaaauagcgucauugauaucugcuucuaagaugaccag\n", + "uacuggapaagcgaggaggcpaapcpccccaggagcaggcpcpcuccccgcccuccagcgcgcccggaggcuaccacucccugcag\n", + "auugugcgcgcaccagcagcccggcccpaggagcaggacgcgccpccgccuccucccgcacggaccc\n", + "ggcggcggcggcggcggcggcggcggcauugugcgcgcaccagcagcccggcccpaggagcaggacgcgccpccgccuccucccgcacggaccc\n", + "cauugcagugucgagauggcuaugaacccuguguaaaugaaggaauguguguuaccuaccacaauggcacaggauacugcaa\n", + "auggaugccaauucaaaagacaagcccccugaaaccaaggagucugcaaugaauaaugcugguaugugaugaucugccuccuugugaaguugaagguuuagacagagaguuguccucaccccuacaau\n", + "agcucaagcgcccagcucugcccgaggagcccaggcugccccgugagucccauaguugcugcaggaguggagcc\n", + "accupaugacgaacuggagaagucugcugcagcgupccagucagugcaucupagcacpcccaccagucugcugguguccaucpcagaaccupcgcucacupcag\n", + "guaucgcucuccpuuccaugugcaguccugguaugacgaggugaaggacuacaccuaccccuacccgagcgagugcaaccccugguguccagagaggugcucpccc\n", + "gcccggcuupacauuguucacuuccccucgcuuccccucuagaagcccccuuugccaucccugcaccuuguuucpug\n", + "acucgagguggacacccgaguuguugacuccuggauuccugcuggcauccugguguupaccugcggcucggagcggauggcucp\n", + "auaaaugcgguggcgcccggcguapacacuucgguccugagcgcuupaguuagguuguuugccggcguagcggccagcgccugagcccgcccuugaucuucgcuguggc\n", + "acuucgguccugagcgcuupaguuagguuguuugccggcguagcggccagcgccugagcccgcccuugaucuucgcuguggc\n", + "acuucgguccugagcgcuupaguuagguuguuugccggcguagcggccagcgccugagcccgcccuugaucuucgcuguggcauggcggacgapaagucguacagcg\n", + "uauaaaugcgguggcgcccggcguapacacuucgguccugagcgcuupaguuagguuguuugccggcguagcggccagcgccugagcccgcccuugaucuucgcuguggc\n", + "auagagacaacagucapcuggugguggugcuuuupucuaggagagcccaaggcccugauauuuuaaaauguccuccucggcaucuccagcaaguugccacugcug\n", + "acagacgcuggcggccaccagaaguuugagccucuuugguagcaggaggcuggaagaaaggacagaaguagcucuggcugug\n", + "ggaguuugagugagagauauapaaggaapaaguaagcagucacagacgcuggcggccaccagaaguuugagccucuuugguagcaggaggcuggaagaaaggacagaaguagcucuggcugug\n", + "agagauauapaaggaapaaguaagcagucacagacgcuggcggccaccagaaguuugagccucuuugguagcaggaggcuggaagaaaggacagaaguagcucuggcugug\n", + "ggaagugaggaucuucgucugapacgccaccucaggcuaccagaaccccaagacugguupuaucaag\n", + "acaguuccucuggacuucucuggaccacaguccucugccagaccccugccagaccccaguccacc\n", + "cauccucccuuuuggacguuggapccgcagcgucaucuccgaugcacccucauccucagauaccpuagagaucucgccg\n", + "aguaguuccgcuuccuguccgacuguggugucuuugcugapucacauugagcugcagguugaauccpugccuuuag\n", + "ggccgcccuucccccacccgcuuccggccgcggcucgguucucccgccuccgccuccgccgcggcucgugguugucccgcc\n", + "cuucccccacccgcuuccggccgcggcucgguucucccgccuccgccuccgccgcggcucgugguugucccgcc\n", + "auugaucuggauacuauugauguaagcaaccucaacagacaguuuuuguuucaaaagaaacauguuggaagaucaaaggcacag\n", + "guugccaaggaaaguguacugcaguuuuacccgaaagcuaauaucguugccuaccaugacagcauc\n", + "cpucgcgcuuccggcggcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "cuuccggcggcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "gcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "gcuuccggcggcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "ccggcggcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "gucgcgcuuccggcggcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "gcgcuuccggcggcgucccpccappugcgccuuucuccgcgucpcggcccggagcgcgguggcgcggcgcp\n", + "aguuuuaagucauggcpugcgaacpucucugcugcaggcggcuccgugacagcuccugcuucac\n", + "cccugcgcucugaguccuggcucuggcgcugagagagagacgcccuggaaggucuguaucagcgucugucgcgcupacccacacuggcuuuuaaggaggacacccggacaccuggaagcupaa\n", + "ucugucgcgcupacccacacuggcuuuuaaggaggacacccggacaccuggaagcupaaaug\n", + "gcapagcccgccagagugcpucgcggugcggacuucgagcacgagcccuaaagacgcucagcacucgucgcuucuccuagcagacccugcccggcuuggcg\n", + "pcpcapagcccgccagagugcpucgcggugcggacuucgagcacgagcccuaaagacgcucagcacucgucgcuucuccuagcagacccugcccggcuuggcg\n", + "aaccgaacacugcgcucuucgacucuguccgauucugcagacguccgaaaccucggaagccaaaaccgugcuugaacucacugcccgcgccucaucucuccuc\n", + "aaagcguuguuggcccgguugcucuggagccpucucpucugguggcugccggcccugcggcaucucgcc\n", + "aagcguuguuggcccgguugcucuggagccpucucpucugguggcugccggcccugcggcaucucgcc\n", + "aacgcaaugaupcccucuucaagaucuuaacuuauaaggcaaaauaauggauucacagcucag\n", + "auaauagaaucugucccuccagcuggcccugaggcaucugagucaacaacggaugaaaaugaagacgacauucaguuugucagu\n", + "gaaggaccauuacgaccuguucuugaauacauugaucuggucagcagugaugaugaagagccuagcaccucuuauacugau\n", + "gagaauauuaaacguaaagaccauauugauuaucagaaggauaaaguugcuuuaacucuggcucgucuagcccgccauguugaaguggagaaacagcagaaagaagagaagaauagagcauucaga\n", + "gaaaaaauugauuuucagcaugcucaupuuacaagaauuggaauuuauucgaggacauucugauacagaagcagcaagacuguguguggaccaguggcuaaaa\n", + "uucguggcgacggcggcggcapacagcaggagcaguggugcugucagcgcggccgucggagac\n", + "ggugcapcpaapauucguggcgacggcggcggcapacagcaggagcaguggugcugucagcgcggccgucggagac\n", + "auucguggcgacggcggcggcapacagcaggagcaguggugcugucagcgcggccgucggagac\n", + "acgcapcpucccgguagcgccaggcggugcapcpaapauucguggcgacggcggcggcapacagcaggagcaguggugcugucagcgcggccgucggagac\n", + "aagupccuagacccuggaaggcapacugcgagcupcuggcggagcagaggugcagaagcaacugaguccaa\n", + "ccuagacccuggaaggcapacugcgagcupcuggcggagcagaggugcagaagcaacugaguccaa\n", + "ucacaguccagccacugaccgcagcagcgcccuugcguagcagccgcuugcagcgagaacacugaauugccaacgagcaggagagucucaaggcgcaagaggag\n", + "auuuuguuaagugaggaggaggaggaggaggaggaagcggccgccgcpuccgcggcgcgcccggcccgg\n", + "uuuuguuaagugaggaggaggaggaggaggaggaagcggccgccgcpuccgcggcgcgcccggcccgg\n", + "aucacucaagauggcugcccccaucaagaugaccpugugccppaaapcagcaugauggucugagaug\n", + "gcguccupccacgccucccggcgcaccgacgcgccucuccgguuacuaagcggccuuggauaccuggccgcpaugcupcggcgucaggugagcgguggucgcupccucag\n", + "ggacuggaggugaguucgcagccggaacguugcaggcacuuguuuccucaguggaugccuuucggcgcgccgccgcccggcgccgcpacupagaccgg\n", + "gcagccggaacguugcaggcacuuguuuccucaguggaugccuuucggcgcgccgccgcccggcgccgcpacupagaccgg\n", + "uccpccagcauccgagagcccggacuggaggugaguucgcagccggaacguugcaggcacuuguuuccucaguggaugccuuucggcgcgccgccgcccggcgccgcpacupagaccgg\n", + "ggucucacucuugcccpcuggccuugaacuccupcucaagccaucuaccugccucgaccucccagaguguupauuacag\n", + "ggcuccpccagcauccgagagcccggacuggaggugaguucgcagccggaacguugcaggcacuuguuuccucaguggaugccuuucggcgcgccgccgcccggcgccgcpacupagaccgg\n", + "aupcuuaacagauucuuucccaaaagcugguuugauggaggcacuuguagaggcucuggagacgcuggacgccugaaa\n", + "gcagcaguguugacggauacgugagaagaaaacggcgugguagcucggaguguggaaucpcgcgaaccugaguucugagaaguguggaagcacgucugaggca\n", + "ugugcagaaguccugguaaucugguccuuguucccgucuggauaccagcuuccuucagcagcgcaggcgguggucccugaggcccguggaaggagucaaacuugcpaauuuugcag\n", + "aagucauuguauucaaagaagaauaagcaagaaagaaaagaaggaaggaagagagguagacagauacaag\n", + "aaucugguccuuguucccgucuggauaccagcuuccuucagcagcgcaggcgguggucccugaggcccguggaaggagucaaacuugcpaauuuugcag\n", + "uuuaucugcapcuguuguuuccagcaagacccaaagcuagaaaaggaggaggaagaaacugacccgaucagugccag\n", + "ggacguugcgcggccgcgacgcccgacgccaacgcaggcgcagcgcuccgauucggcgcggcucaugguccgguucpcucgcgagucuccgucupuapcag\n", + "aaagcugagaaggupaapcggagcucgcccuguggcugcucgguggupugagguaucagcuuucuccgcuaguucccacccugguaguccuuagccccuggaaugcgugapag\n", + "aguccagcgcccgccgcccgccaccccggaccccggugucuggcuucccccgagccggcaccccgcg\n", + "uugcccuggaggaacucupuuucguggaggaaacuggcaccugaagagaucaugacaaugcauuug\n", + "uagcuggaagaagugaauacuaaagaaguuucuaacauugauaacaaggcucuacuuguucauucauugaccaauggugaa\n", + "ucggaagagcuguugauuuuguaguuuguucagcguuuugcuuguuagaauggagugcugcugacuucuaagccccuuaggugccagacuucaaugagcag\n", + "cucuucacggagccgcgcggcugcpcgcaaauapucagupccgcuuggcggugucguugcgguaccagguccgcgugapuucpuucupcaggcaca\n", + "gagugacaugcaaggaacugacauugaaguaagauucugugapugagguugcauuuguagaaagugguuauaguccacuuagca\n", + "gaacupaaguaacagcccuccacagagaaacuggaapaauugcuauugcucugcuggugauuuuaguuguaugcucacucaucacu\n", + "ggcupcucccgcgccucccucuucucacccucccccgccccgccccaguuccaggcucuccugcuucuccacggacucugcpaaguuagagccucugcgugcgcuccpcccggcgagagg\n", + "aauucugaaaacuaacuaagaugcuggagaaauupagaccauuuguugaagaaauaccuacugaaucuug\n", + "gcuuaaapccgcggcagaugcccggccccggcpcagcguggccugcggcccuggccuccgcugcagcgcucgccuggcccggaggcaau\n", + "ugcuccaggaggcugugaguacccpaccuggagcuggugcagcuggugcuucgguaccpacuaccagcpuggugaagcggcuggcpcauccccgugcuccuggagaagcugcgcaag\n", + "agcgguggcaaagcccagccgcgcpccgcgccgccgcccccgccgcgcgccpccggccccgcgcccgcgcugcgagccuucc\n", + "acuccacuapcacgcaggcgacgagcacacuggcagapccucccgcapcccacuccccaccuggcucucgccccacc\n", + "acacccuccuggacacuuccuacccauguuaccugcuggugaccugucuuguucauggcuauauccgcacagccuggcagaaaacagagaaucuguuuu\n", + "agcuguucuuggcugacuucacaucaaaacuccuauacugaccugagacagaggcagcagugauacccaccugagagauccuguguuugaacaacugcuucccaaaacg\n", + "guggauppucgccuugaccucugccucagccaguagcgcagucucggccucgccguuacggag\n", + "ggccguuccucuggucggcupaccgcggccgcgcacgcgcggcppcgupcupcccagccggacgcgaccucagccugcggcggcuaacugccg\n", + "ccaagucggupcpacgcgagguguggauppucgccuugaccucugccucagccaguagcgcagucucggccucgccguuacggag\n", + "gupcpacgcgagguguggauppucgccuugaccucugccucagccaguagcgcagucucggccucgccguuacggag\n", + "accacgccuccuccaagucccagcgaacccgcgugcaaccugucccgacucuagccgccucuucagcucgcc\n", + "auacuuucugagugccuacuaugugccagccugugcuaggcacugaggacacagguggaaaagcccgaauugcucccugcucuccuggcgcucaucaccccggag\n", + "cagauacuuucugagugccuacuaugugccagccugugcuaggcacugaggacacagguggaaaagcccgaauugcucccugcucuccuggcgcucaucaccccggag\n", + "uuugcuucugcuggcuugcuggaccupcupugccaaguggcgccugcugcgucagagcucaaggaaucugugcccaccaccagcuccugguccguaggag\n", + "gugugcgacgacccggaggagcugcpaagguccpagcuggccagcgccguccggaacgccaaauacuuggucgucuacacaggcgcpaaucagcacg\n", + "gcagcgucuaucccagacuaccpcccuaauggaguguggacacugcuucagaaapagaagcguuag\n", + "cauuacagacaucuuuaguuuuuuccagagauuucgguuugcuuguauuuguccggaagucacucaacaguauugaa\n", + "aggaagaagcuggagacuugguccagccpcaucagcuuuccpccggcagaggaggaucuag\n", + "acccgcaguacucauggucgcccacgcagcacuucaaugaggagcgcuacucgcccgcgcccaggagc\n", + "acccaaagucuucaagccuggaguuucugcuugguuuuuccugaggucugagcacccugcaaacugaguccagaucugguaagucccuaaucucu\n", + "cagagauggcuggagccguguggaupcauaaauggcuaauguccagcaaccaucgaugucaaguauccacacaccuggccugaauggaucccucugccuuucagag\n", + "ggucuugcugucucacccaggcuggagugcaguggcacgaucacagcucacugcagccuugagcuccupcuaccaaguagcupacuucag\n", + "agauggcuggagccguguggaupcauaaauggcuaauguccagcaaccaucgaugucaaguauccacacaccuggccugaauggaucccucugccuuucagag\n", + "cuccuuccacguugucuccuccaccuagcaguugguuggcaaccccuuccucaguccccugcugaaaacccuccagucagcgcuuaucccuucugcucucuccccucacccagagaaauac\n", + "aggcuucugagaagacuggupagagaaggagagccugcagacagaggccuccagcuuggucugucuccccaccucuaccagcaucugcugagcu\n", + "gccucagccacagucccacccpccuupccccagacaugcggugaucucapcaapuugccacgaccacccagaaccucaccag\n", + "gugcgcagaggugcggccpaggcgcgcggaggcuggagcuggaggcgcggcgccggugagcugag\n", + "ggcgagaaagapuggaggcaggaauucpccaggcucucccggagcuggccaggacuggccgagcccgaccccgcacuaacccgcgagagag\n", + "gcucugaaaccuagugugaagguauaugcugcugaacccucaaaugcagaugacugcuaccaguccaagcugaapaaacug\n", + "auucguggugcucucaaugccgucagaagcuugguuccugaugcuuuagaaaggaagccgaaagcuguuguuacucacagcaguggaaaccauggccaggcucucaccuaugcugccaaauuggaag\n", + "gaauuccugcuuauauuguggugccccagacagcuccagacuguaaaaaacuugcaauacaagccuacggagcgucaauuguauacugugaaccuagugaugag\n", + "augagauugupaaccupugaaggcaccuuuggcaaggugguggagugcuuggaccaugccag\n", + "apaagucucagguugcccugaagaucauccgcaacgupcaaguaccpaggcugcccggcuagaaaucaacgugcucaaaaaaaucaaggagaaggacaaagaaaacaaguu\n", + "ucaggagcaaccpaagccccagcagccccauggcuggagguggcuggcuguguguuuagcapcucucuguuccucguggccuag\n", + "aaacagaacaaupccucuucaggagcaaccpaagccccagcagccccauggcuggagguggcuggcuguguguuuagcapcucucuguuccucguggccuag\n", + "gaggcugugacauucaaggauguggcuguggucuucuccapaggaacugcgacugcucgaucuuacccagaggaagcuguaccgagauguc\n", + "gccgcpcggaucuuguuguuacpuaacggaaguguggcggcguupuugagcpcuuuuuggaaguuuguggcggag\n", + "gugagccgcpcggaucuuguuguuacpuaacggaaguguggcggcguupuugagcpcuuuuuggaaguuuguggcggag\n", + "puaacggaaguguggcggcguupuugagcpcuuuuuggaaguuuguggcggaggugaggccgaggugacugcagagcggcucgcgag\n", + "agucucccucuguugccaggcuggagugcaguggcgcgaucucggcucacugcaaccuccgccuccugaguucaagugauucuccugccucagccucacaaguagcupacuacag\n", + "gguuuuggacugauaaagcaauggaagccacugaagagcuuuaagaugaggauggcauggapaagauaagucacauaaucag\n", + "acggaaguguggcggcguupuugagcpcuuuuuggaaguuuguggcggaggugaggccgag\n", + "uucugugauaugagcaacaauggaccagaagauuuuaucucuagcagcagaaaaaacagcagacaaacugcaagaauuucuucaaacccugagagaag\n", + "uugacuaaucuccuucagaaucaagcagugaaaggaaaaguugcuggagcacuccugagagccaucuucaaag\n", + "guucccccugcucugaggaagcuggaacacuuaggagacguaagauauacacuuguuguauccaguugguggaaucpauuugcagaaagaaauagcgucugagaucauaggauuacug\n", + "guupuugagcpcuuuuuggaaguuuguggcggaggugaggccgaggugacugcagagcggcucgcgag\n", + "uucugugauaugagcaacaauggaccagaagauuuuaucucuagcagcagaaaaaacagcagacaaacugcaagaauuucuucaaacccugagagaaggugau\n", + "gcgcgcuccgcugucucccgccgccugccucagcuuucgcgguucccuccuapugugccucagucggagccccuucuguuaaauucuucccccuuggccgagg\n", + "uuccagauggaaacauguggaapccuguggcagaaagaacuuggagauuugaaggacuggaagcaauucugcauggcuggagcagagugaugaaapag\n", + "gguuguggucuccugaacagaagucugucuccaaacacaaaucaagcagcaagaucaucugcugcag\n", + "cuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "guggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgugaugapccguguugacguggagagauaaagccgagcacug\n", + "agccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "cagguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "ggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "guuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgugaugapccguguugacguggagagauaaagccgagcacug\n", + "gcaagcgcuuugcuucuggaucagcugacaaaagcguuauuaucuggacaucaaaacuggaaggcauucugaaguacac\n", + "gcacaaugaugcuauacaaugugucuccuacaauccuauuacucaucaacuggcaucuuguuccuccagugacuuug\n", + "agguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "gcauguacguugccapuaacgcagguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "guugccapuaacgcagguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "aacgcagguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "guggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "puaacgcagguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "gguagccaaaguggcuuguggaguggcgaccguuagugaggcgguugcugagacagacgcugaggcpuaggaggagcccgagccguaapaagccgug\n", + "agagucauccagcuggagcccugaguggcugagcucaggccuucgcagcauucuupupagcagccacpucagccacaapccacagcc\n", + "auuaggugacggagcuaagacuucgagaccaucucguccuuuuuguaucgcggaaaccugaggaacgagccggcggcggugaccugcacgagaagccaggcuaacug\n", + "uuuguaucgcggaaaccugaggaacgagccggcggcggugaccugcacgagaagccaggcuaacug\n", + "guuugugaaaagagcugagcagagcugaaggcugcauggugguuucagaaacugccuacuuaauuugaaaagaaca\n", + "cuuuuucuguuugugaaaagagcugagcagagcugaaggcugcauggugguuucagaaacugccuacuuaauuugaaaagaaca\n", + "ggacucgcgcucgcccgcuggcgcccucggcuucucuccgcgccupagcacccuccgccgcggccguucuccaugcgcagcgcccgcccgag\n", + "uuccgcguucucggaggagcgaucugcagguapugcgcgcgaccgcuccccggcpagccagcgaagguaaaagcgagaccugcgag\n", + "ucucugaucpcccacccccuggaucuagcaccgccucuuccgcguucucggaggagcgaucugcagguapugcgcgcgaccgcuccccggcpagccagcgaag\n", + "agaupcaguagcgaaccccuucccaucgcagauggugacaggaggaggaagaagaagcggapccpccacugacuccuugccaggaaaguuugaag\n", + "auauguacaagcugaccucugaauugcuuggagapagccuaugccaaaguucaaggugccgugagccuacaga\n", + "ucucugaucpcccacccccuggaucuagcaccgccucuuccgcguucucggaggagcgaucugcag\n", + "cucuugccugugagacuuggacuuggccacuaagagagagagcccagcucauuucucuaaaaacguggauagcagaggagugccucgcucugucacccagguuggagugcaguggc\n", + "cuagcaccgccucuuccgcguucucggaggagcgaucugcagguapugcgcgcgaccgcuccccggcpagccagcgaag\n", + "uuucagaaacaacucuccaaguuccauuuccaaggaaagucuuaaccauuugucccuucuggcguacccucuuucauugaaauccaugcagaauauaccag\n", + "gcggaaauggcupapaupauguugaauuuggaaauuggapacgcugguggacg\n", + "pcucucuguguggcuuguaagaugcugaagacucagauuuuagagaccaagugcguuucagaagapcugag\n", + "uggaagagcugaccuuggagcagagcauugccgaguaucugaaagaugucaaugacccucgcugcugcucggagaccuupaugaccugcacccacuagc\n", + "aaacuaaaaauacagcugaucaugaugagucaccgccucgaacuccaacuggaaaugcgccuucuucugagucugacauagacaucuccagccccaauguaucucacgaugagagcauugccaaggac\n", + "uauuaugcagaugcacggcuggaggupauccacacagcucagaacagcuggaucuugcucacacucuuucaagagaagcuuccuug\n", + "gguuaagaaaaaaaacgaacccuuccagucaggucagugacuggagagcuccauggaaagucucucagugaccuggcugcuggcacc\n", + "auuaugcagaugcacggcuggaggupauccacacagcucagaacagcuggaucuugcucacacucuuucaagagaagcuuccuug\n", + "gacaaaaggacccugccuuggugugagagugapcagapagcuggagcaaguagaauuucucuaaauaccagcuggcupcccaggagauuaaaaaacaccpcuag\n", + "auguuguccagaggcugguugcuuuuaguccaagugcugccucccacaccucggauuucagccaggcugugccacggapcagaggccacccag\n", + "gguauaucucagagccuggagaacgugucugguuauuaugcagaugcacggcuggaggupauccacacagcucagaacagcuggaucuugcucacacucuuucaagagaagcuuccuug\n", + "aaaagaaacgcuuuacugaagaggccaccaaauacuuccpagagagucagcccagugcaucugcaaauccugcugacuaacaaugaagccuggaagagauucgugacugcggcugaauugcccag\n", + "uuaugcagaugcacggcuggaggupauccacacagcucagaacagcuggaucuugcucacacucuuucaagagaagcuuccuug\n", + "gaagcupccauguuguccagaggcugguugcuuuuaguccaagugcugccucccacaccucggauuucagccaggcugugccacggapcagaggccacccag\n", + "gguuaagaaaaaaaacgaacccuuccagucaggucagugacuggagagcuccauggaaagucucucagugaccuggcugcuggcaccauggacucag\n", + "gugcaggagucugagaagaaapuguagauggagaggcgguggccucaccucugcaugcuccgupaagcggcggaggcgcccagcaucccuccuacucugcccuugguggagguuuacgag\n", + "gagagugcaggagucugagaagaaapuguagauggagaggcgguggccucaccucugcaugcuccgupaagcggcggaggcgcccagcaucccuccuacucugcccuugguggagguuuacgag\n", + "gagugcaggagucugagaagaaapuguagauggagaggcgguggccucaccucugcaugcuccgupaagcggcggaggcgcccagcaucccuccuacucugcccuugguggagguuuacgag\n", + "ugugucugcpauggcagagucugucacupuuuagaccupccgcaggcuucaguaaacucuuaggcacccuguuucuggaacucagcugac\n", + "aaagcgaagcgucagcapcgccccgcccccucggucggcacpapcccggaagagcccgaggcuuuuuuuuccuccgcggupcguugcc\n", + "gcccccgcccaggugucucccuuupaagcugcccgccgagucuccgagauuugucccugguggucccgcggaccccucgucccuccgcagucuccggcuggcagcg\n", + "cucccuuupaagcugcccgccgagucuccgagauuugucccugguggucccgcggaccccucgucccuccgcagucuccggcuggcagcg\n", + "acagaacagaguagaggcggcggcggcggcggccggacccagacugguagugaggcuuuggaccccgagccgcugca\n", + "pcuggcacaguguuuuaagagaugucuguggaguucaguugaaugaugagaccagcaguupauguguupagagucagaaccucuaaagagaaagugcug\n", + "gcagaggcagcpacgcggccaccucgaagccacgucapcagccccaggucpcgcgugccagcagccagag\n", + "acapucucauucugucgcccaggcuggaguguagugacgcgaucucggcucacugcaaccucuaccucccagguucaaacgauccucccgccucagccuccgaguagcupaccacag\n", + "pcpucacgagccgccagccgccpuggapucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "gccgccpuggapucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "gucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "gucacgagccgccagccgccpuggapucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "pucacgagccgccagccgccpuggapucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "agccgccpuggapucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "gccpuggapucccggccpagccgcggaaagaguapcuccccagacaacpuccgacgagcaguupcacpcugaguccgccugccggcag\n", + "ugcccccaucucucccucuccaggaaguccauguaagcaaagaaaccaucpaagauuucagcugccagcaaaa\n", + "gucagagupagcauuccaguucaguuccacuccucaucuggaauuccccuuggauucauuuucaacccaacaggaagugaaggcaagaaucaagaggaugguuuucaa\n", + "aggucaaggugcuaggcccugaguaucccauccuggcccucgucpaggagguggaguucccgugccaccuauggccacagcuggaugcccagcaa\n", + "agaggagguggcggugguggcccucgccuguggcccccgugcugcuugcacucgaacucgucgcc\n", + "guuaaauggaaaccacccuupaacuggaugccuguguagcuguucuaccauaucaguguauugca\n", + "agcacaggacacagcuagguucugaagcuucugaguucugcagccucaccucugagaaaaccucuuugccaccaauacc\n", + "uugcuuccaagauccgguacuugcaggaauaucauaaccpuucuccacaacauuuauccuguaccaucaggaacagauauugcaaacaccuugaaauacuuuucucagaccuuguuaag\n", + "aucuuggacagucgauauuuuauacaacuacauguuugcuaccuuuucucaaugaugauauucugaguacuuugcccuacacg\n", + "augcacucuuuuccucgcaacaucgcuggcggagcgapagcucacacgacacagauuuupcaaagccuuuccaacuggacagcacc\n", + "acuuugaaauacucgupauaugaaguggaggugccuagapuugaagauaaugaggacagaugaagaaauguuugauugugccauacuuacaguugcugauuuucaag\n", + "ggucuugcuaugucacccagccuggaguggaauugugugaucaagacucacugaagccuccaacuccupcucaagcaauccucccaccucagccacccaaguagcupacuacag\n", + "gcuggagugcaauggcaugaucuuggcucacugcaaccuccgccucccggauucaacggauucuccugccucagccuccugaguagcupauuauaggugccugccacaacacccag\n", + "cggccuggugcugcacgccugucagccaucgcccgagccgccggcgucuccucccgcccagcaguuccuccacgcapcuccggaaucgcccgaccgcacacguugccacccugag\n", + "aggcacugacuuucuugaugaauucuguccaucuguaaagcagcuauauaucccacuggaggcuuugccucucagagacaacgugaagacggauaagcaggcaucaggagcagaguggccucucag\n", + "gucagccaucgcccgagccgccggcgucuccucccgcccagcaguuccuccacgcapcuccggaaucgcccgaccgcacacguugccacccugag\n", + "cgcacgccgagcggcugccpaagcagaggcgccggaggcupcaccgccgacgccucpagcc\n", + "agcagucagcgcacgccgagcggcugccpaagcagaggcgccggaggcupcaccgccgacgccucpagcc\n", + "gcagcagcagucagcgcacgccgagcggcugccpaagcagaggcgccggaggcupcaccgccgacgccucpagcc\n", + "acacacccucpaggaccagcauccaagcagguggaapcucugapagacuggaauuuucuggccuggagaag\n", + "uccccucugaagcaccccccacgcuucupccccugcugcgagcuacccaccaggcuuuuucccagcuucugcacccupcgccucaggacccuupcuccuacuccccpuupcc\n", + "acuuccupucauuccuggaccpagccpcupcucacacpcucccgcguggccgucucggcgccugcgugaccuccccgccggcp\n", + "auuccuggaccpagccpcupcucacacpcucccgcguggccgucucggcgccugcgugaccuccccgccggcp\n", + "pucauuccuggaccpagccpcupcucacacpcucccgcguggccgucucggcgccugcgugaccuccccgccggcp\n", + "gcacccuggaguccccucaggccagcucggupcgcgcaccugccagccgccccugaccucgcaggccaggcgaccuccgagccugagaag\n", + "agagagaaggaapaggacugaggagagacggcgaapcagapaaaccpacagagacugccucugapuucapaagagaggacacagcgagcupaaaggag\n", + "cuugucuuuuccaggcacccuggaguccccucaggccagcucggupcgcgcaccugccagccgccccugaccucgcaggccaggcgaccuccgagccugagaag\n", + "ucuauuucaaaggccagacuugugaaugaaggagccgaugcpupaguacugacugaaau\n", + "aapugcpcpupcgapuggapacaggauccagccgcucpcccccgcccgccagccggagaaguggcggaggaccguucuccgccguccccucuagg\n", + "acaucuauugaaapuaacgacagacggagaucaacuaagguggcagguaagguucagaaaaggagaaggacaacaaauuuggagaaauaggagaag\n", + "cccuacagugagcaacuuucggcagcugcaggaaaagcuggucuuugagaaccucaauaccgacaagcucaacagcaua\n", + "apuaacgacagacggagaucaacuaagguggcagguaagguucagaaaaggagaaggacaacaaauuuggagaaauaggagaag\n", + "gcgugcguauuucuggcggaggaugcgccaugagcgcugaaagagccugaaccgaagcguccggcucgccgagagagugagagccpccggcucccaggagcgcpcgagg\n", + "agagagcgccggccgcupcuggccugagagcgcagcgcgccggccgcuaccagccgcgccggagccccugcgcccugcggcccgcuccccpaccpccggcgcc\n", + "gugcuagcuccagcucagcuaccugcggccgccucuccucpcaaugaggcgccpaagcccacagcaucugauaauauccpccgccgguugccpaggugaaccgag\n", + "aguuuucaggcggauugccucagaucacacuaucuccacuugcccagcccuguggaagauuagcggcc\n", + "aucagcggcgccpcgcuupcuggaggaggcagcucgccucagcugcgcugugcacaccucgcccpaggacgcagacccpcaggcggcap\n", + "cuggacgagcuggupcgcguaccccaacuacaacgaggaggaggaggagcgccgcuacuaccgccgcaagcgccupcgugcucaagaacgugcuggcugccagcgccpc\n", + "cgaggcgacaagagaagaaggaggcaggcgcggcggcagcggcggcgccccgagccggcggaggcgappaag\n", + "aaggaggaggaggaagapcgaggcgacaagagaagaaggaggcaggcgcggcggcagcggcggcgccccgagccggcggaggcgappaag\n", + "aagaacaagcccacacuucuggauaugguccaaaaugaucagaaacucacucugucaaccuaguagguguuuggauggauaccucuuuuuuaacagaaag\n", + "gcuuccccuuucucgcucaccgccgcccuccuuccccagcucccucgccguccgcccgccccacagccagcggcuccgcgcccccugcagccacg\n", + "pcpccupcugucagccggccuaggaggaggaaggagccugcggcgugcagugugapcpacccggcugccggcggupucuagcupaggucpcc\n", + "ugucagccggccuaggaggaggaaggagccugcggcgugcagugugapcpacccggcugccggcggupucuagcupaggucpcc\n", + "gccugcggcgugcagugugapcpacccggcugccggcggupucuagcupaggucpcc\n", + "ggcucuccggcccaucuccacacpcaccuucuggcugacccggaucgugcuccugaaggcccuagccuucguguacu\n", + "ggaccgcagcuaauuacagagccuccuaagaaguguuaaccucagcauuccauagugaccgaccuccugaaccgg\n", + "accaugaagcucuggaccgcagcuaauuacagagccuccuaagaaguguuaaccucagcauuccauagugaccgaccuccugaaccpcag\n", + "aguccuggccuccccpcgcagcacacucccagccggccgcagccugacacgccgcgcggccccccagucucccgcggcugcucccccaggcauggcacapccucgccucacu\n", + "ggccuccccpcgcagcacacucccagccggccgcagccugacacgccgcgcggccccccagucucccgcggcugcucccccaggcauggcacapccucgccucacu\n", + "gcuuuuggacaaacucuucugaaaggupcaaccuagaaagccaguugaugccacuugcuauuggaguugugg\n", + "gcagcuuggauuaauuaggagaaagucaauugcgccagcaaauggaaaucucggaagaagcaaaucca\n", + "agcaguuguuugacuacuuaauugucauugauuuugaaucgacaugcuggaaugaupaagcaccaccauagccaggaaauaa\n", + "uugaguuuccagcaguguugcugaacacaucaacuggacagauugacucugaguuccaggcuuauguucaaccucaggaacauccaauucuuucagaauuuugc\n", + "ggaacaggccaggucgcgcgcgguguugccaupacgagcggcuccggcugaagguuuccgugcuuggaaaccgcgccuccgcggagguagccguucccugaccuagcc\n", + "gugcuuggaaaccgcgccuccgcggagguagccguucccugaccuagccauggcacagaacacugaaaaccacgacccugucggauccaucuuaauccag\n", + "auccaugaagaccuuuaucaguuaaaggagaaauuaacaaaauucucaccugaggaaaaaggagagacucuagacauucagagucuugaaacagcaaucaaaaggacugaagupuuaaga\n", + "gcgcgcgguguugccaupacgagcggcuccggcugaagguuuccgugcuuggaaaccgcgccuccgcggagguagccguucccugaccuagcc\n", + "cgcgcgcgguguugccaupacgagcggcuccggcugaagguuuccgugcuuggaaaccgcgccuccgcggagguagccguucccugaccuagcc\n", + "acacacgcacagagcucgcucgccucgagcgcacgaacguggacguucucuuuguguggagcccucaappuupccccgguucgguccpag\n", + "aguucucacagugaucuagugucugacuuuucuapaauccaaucaauaaaauugaagacuggcugcaggauugcgg\n", + "cuccuuggaaaauguaguaagugacuucaaccuauaagacuguuuuugguuuagauacucugaagaaggauuuucugaggaagcaggacaguuuaucuacaaug\n", + "gaguuuccucgagacagccaggccuugccagcuacuugaucuuggcuguaguuuggcuuccagcagc\n", + "aaguguggcaggaggaaggcuguaugauauaaaggaagaaagcaugcaucuggaacucagaacuu\n", + "agaaaagaagcagagagagagaagaaauaucuacuauuuuuauauacgguguauuccucucauaucuuaaagaaaagcuuuauguagaaaaaaagauucaugacgcagcuuau\n", + "uuuuauauacgguguauuccucucauaucuuaaagaaaagcuuuauguagaaaaaaagauucaugacgcagcuuau\n", + "guucaguucucacagugaucuagugucugacuuuucuapaauccaaucaauaaaauugaagacuggcugcaggauugcgg\n", + "aguugcapaggaggucugauuucguucaguucucacagugaucuagugucugacuuuucuapaauccaaucaauaaaauugaagacuggcugcaggauugcgg\n", + "accgcugugucacgugagguupaaccgcccucuugagaccuupugaagaucuuggcpaagagagguagapuugcggapcaggugaaguguucuuuauupagcuuaguuuuug\n", + "paccggaguauugcccaapaccggagccaguuggcaapaaaggaguuucaaaaaaagccucucugaaauucccucucccccaugcccguugcccgcuagcuggcgucuuucccuggauaug\n", + "gugagguupaaccgcccucuugagaccuupugaagaucuuggcpaagagagguagapuugcggapcaggugaaguguucuuuauupagcuuaguuuuug\n", + "guggcagccuacaucccucagcuggccaagucaaacccagaccugupugucucccugugcacuguggauggucaacg\n", + "ugauucaucagaaaguggcaugcugucccgccupugauuugcucuuuuacacuauugcugaaggacaggaacgaaucccuauccacaaguucaccacu\n", + "gcacuaaaggccacuggacugcagacaucagauccucggcuccgagacugcaugagcgagaugcaccgcgugguccaagaguccaguagugguggccucuuggaccgagaucucuuccgaaa\n", + "agucgcgcpcugguggcgagcagccuccccpcgcgcaccccuupccppcggugguggacgucgccuccuugaaaguugaaggaguucucpagaccccggagaag\n", + "gaauugcauuuugugaaaaaagaacaagaauuuucugcaaggaucauaucuaagugcacuuuuugcugauacuucauuucua\n", + "ggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "gaaagaggcggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "auccgugcgcggaugucccggcgagucccpcugaaagaggcggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "gcgcggaugucccggcgagucccpcugaaagaggcggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "cgugcgcggaugucccggcgagucccpcugaaagaggcggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "pauccgugcgcggaugucccggcgagucccpcugaaagaggcggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "pcugaaagaggcggcuccpcggcgcgaagcgcugguggcpcccpcugcggcgugugcgcgcccgccagcugcuccggagauacg\n", + "aggugccugguaaacaauagcuguugucpugugguggcucacacuuguaaucucagcacuuupaggccaaggcaggapcgcuugagcccaggaauucaagaccagccugg\n", + "ucucagcacuuupaggccaaggcaggapcgcuugagcccaggaauucaagaccagccugg\n", + "cacaagucugccapaagucccuggacuucuugcuucuuucguguaggacaggcugucgaaaccucaguggauaaaagaccuagagaauguguaucccagaagaagcuggccaaggau\n", + "auggagucucgcucugucacccaggcuggaccaugagugcuuuuuuaaaccucauuuuaaaucugaaagaagaaugaauacauug\n", + "gacaggcugucgaaaccucaguggauaaaagaccuagagaauguguaucccagaagaagcuggccaaggau\n", + "ccggccgcggagcuggaaaccpcuccgcgcguccpcggcuggcggcgcpcaggcaggcpaggacaggcupcggcgaccgcgapccgcgcgcggapcgccuggugcagc\n", + "gcuggaaaccpcuccgcgcguccpcggcuggcggcgcpcaggcaggcpaggacaggcupcggcgaccgcgapccgcgcgcggapcgccuggugcagc\n", + "cggcgcpcaggcaggcpaggacaggcupcggcgaccgcgapccgcgcgcggapcgccuggugcagc\n", + "aauuugaaagacauauuggcugaccugauaccuaaggagcaggccagaauuaagacuuucaggcagcaacauggcaagacgguggupccaaaucacuguggac\n", + "ccuuucaaccuugucaacccgucggcgcggccucuggugcagcggcggcggcuccuguuccugccgcagcucucucccuuucuuaccuccccaccagaucccggagaucgcccgcc\n", + "uccuuucaaccuugucaacccgucggcgcggccucuggugcagcggcggcggcuccuguuccugccgcagcucucucccuuucuuaccuccccaccagaucccggagaucgcccgcc\n", + "gcacccaguggcaaguacuagcugagcauuupagaugcuugucuuacuuggcuguugcuucuccugcugcupaaaagg\n", + "uuucaaccuugucaacccgucggcgcggccucuggugcagcggcggcggcuccuguuccugccgcagcucucucccuuucuuaccuccccaccagaucccggagaucgcccgcc\n", + "cuugucaacccgucggcgcggccucuggugcagcggcggcggcuccuguuccugccgcagcucucucccuuucuuaccuccccaccagaucccggagaucgcccgcc\n", + "cuggaaggaauuauccauucaccucugccucaggcuugacugccucuuuccupauccaacucccaggaaguucugacacuug\n", + "cuuucaaccuugucaacccgucggcgcggccucuggugcagcggcggcggcuccuguuccugccgcagcucucucccuuucuuaccuccccaccagaucccggagaucgcccgcc\n", + "agcccugcgugaagcuacaggaccaugugccgcgcuucccuucuggcuccupugaagugcacgccgcccgcccucggcccgcaguccagaacgc\n", + "cccggcaugccagugcuuccuccacgguaagguuuggaaaagaagacuaagaauaagaaucauugcggccagccugaccuupcagaggauuuggcaaccaccuggccucuuauuauccuga\n", + "cgauccugguggcugcgcuuuuugcuauuugcugccgacggcaugcagacgagaugcaaauaagcuu\n", + "agcguggcgcuggcucccggaauauggagcccupcgcpcggcgugucaggugguugcggagcug\n", + "agcguggcgcuggcucccggaauauggagcccupcgcpcggcgugucaggugguugcggagcugguaag\n", + "agcguggcgcuggcucccggaauauggagcccupcgcpcggcgugucaggugguugcggagcugguaaggugapaaggcaag\n", + "papcguuagccagcguggcgcuggcucccggaauauggagcccupcgcpcggcgugucaggugguugcggagcugguaag\n", + "aaucauauucuaagaacucagccacucagguauccaccauggugcupuccugaacagaagaugucagaug\n", + "uccccupacucagaggaguacuucgccacuuacuuuaaugagaagaucuccauuccugaggaggag\n", + "aaucauauucuaagaacucagccacucagguauccaccauggugcupuccugaacagaagaugucag\n", + "aguaauugupuagauugguuuuaaggcuguuuguguagcucucapacccucuggauuccaggcuccaaugagcapuuuuucuacapauauugcacauau\n", + "guuagccagcguggcgcuggcucccggaauauggagcccupcgcpcggcgugucaggugguugcggagcug\n", + "gcguuagccagcguggcgcuggcucccggaauauggagcccupcgcpcggcgugucaggugguugcggagcugguaag\n", + "gacupcgagcaccgapcgugaacccggaagguggcgcggccaccaguaacaugaucucuagacupacggupuuccugccggcuguauucpccuuggacuggacugagaagcuacg\n", + "ggcgcggccaccaguaacaugaucucuagacupacggupuuccugccggcuguauucpccuuggacuggacugagaagcuacg\n", + "uuugcagapauccugccccagaggcccuggcuuggaguggaaugcapccgugugcaggagagccugcucaagugccgccuggcuuuucccuccuuagguggagaccaucc\n", + "gcggccaccaguaacaugaucucuagacupacggupuuccugccggcuguauucpccuuggacuggacugagaagcuacg\n", + "gugaacccggaagguggcgcggccaccaguaacaugaucucuagacupacggupuuccugccggcuguauucpccuuggacuggacugagaagcuacg\n", + "cugccggcuguauucpccuuggacuggacugagaagcuacggugcggauccagcupuaucapcuag\n", + "cuuuuccugguggcgccgugaagaucuguguguguaguucuuggaaagauuccaggugcuugaaaacgacgucucagupucaagg\n", + "guugcuuauaaaaapagucaaacaucuuucugcucuucuugauccagagguccuguccauuuucgugccuccuuuuaucaguaaagaggacagucaa\n", + "gcagacggcgcucgcagcgcccccggcccccaggcggcgcggcugguccccapucugcpcgacugcgcggcugaggcgcccgagugcgguacuggcggcpcggcpcagcc\n", + "agguccuguccauuuucgugccuccuuuuaucaguaaagaggacagucaaauggccggugccaacugcggcacucucgguaaaacccgg\n", + "cggcccccaggcggcgcggcugguccccapucugcpcgacugcgcggcugaggcgcccgagugcgguacuggcggcpcggcpcagcc\n", + "ggcggcgcggcugguccccapucugcpcgacugcgcggcugaggcgcccgagugcgguacuggcggcpcggcpcagcc\n", + "ggucccaggccguccaggucuupcgccgcggcggaaaucgcgcggaugccagaacgcgcucucagcuucpuccugcggcugcggcugccgccauc\n", + "pcupagcupcpagcccpccugccaggcccpcugcagccgcgucugaucgccgagcgcgccgcguagaccuccgcucccccag\n", + "gcpcupagcupcpagcccpccugccaggcccpcugcagccgcgucugaucgccgagcgcgccgcguagaccuccgcucccccag\n", + "uagcauugcccuggaaaugccucuggcuguucupucuuugcuuuucuuuugugucuugccucugaugugcuuucucuuugucuuuuguccucagccucagacuauggc\n", + "acuccagccggcgagagaaagaagaaaagcuggcaaaaggaguguuggacpcgguacup\n", + "aagcaccggaccapaaggcgagcagugccaaucuacagcgaagaaagucucguuugguaaaagcgagapaaagccugagc\n", + "agacaagcacccagccagagugccagugagaagcacaggccaccacucugcccugguccacacaagcuccgguagccc\n", + "caaupuggauuacaaccuaaaauggaauccagaugacuauggcggugugaaaaaaauucacauuccuucagaaaagaucuggcgcccagaccuuguucucuauaacaa\n", + "cagccagagugccagugagaagcacaggccaccacucugcccugguccacacaagcuccgguagccc\n", + "agacaagcacccagccagagugccagugagaagcacaggccaccacucugcccugguccacacaagcuccgguagcccauggagcccuggccucuccuccugcucuuuagccuuugcucag\n", + "aaacugccuggucaaagacuucaagauagacacgcaugucucucccuccaucaugccuggcagccgacucaucccucugaacacucggcaccauuuguaggaccuggaccacuuguggaucaug\n", + "auuuccuccuucccugccgguuucuccccucuacccuggcaccccaaauuucgaugugccgccugccpcgcuaagcgccgguguugagagaggcggcggccgccgcgcccpaaa\n", + "gcacaauucugcuuucccuggaacugugucauucaggacucugcaaauucccuaaaguaggaggaaaa\n", + "gagaauggcggcggcggcggcggcggcggcggccgcugccauugcccggagauggccggcagagccgccgagacgccgaagagcccgccgcccgcgcgag\n", + "guguagacpcacugccuucagagcagguccugccagccucgcuggagaggaugcccucguguccgug\n", + "gccacgacgcuaacgcccgagaauggcggcggcggcggcggcggcggcggccgcugccauugcccggagauggccggcagagccgccgagacgccgaagagcccgccgcccgcgcgag\n", + "aaauaagcpuuuugaaaacaaaaaaaagaaggaguggaagapccaggauccaggccuccauccccacagaagugaagcuacagcupaggucuccucccaccccaaccgucacc\n", + "acucugcucaggccggccggacacggcaguggcaguaapcggcggcgacggcggcggcggucpapccpcppcuggcggcagcggcgg\n", + "guuuccuagaccagugacaaagaaagguuuuaacagccupcacagaggagacauagacuucupaaaagcag\n", + "aguugucuggugcugcuauauapacgupuccccacagaccugcagguuccggccccucuuuucucaacccagagcaaauugaaacguccpugagagucc\n", + "aaagcgcpccagacucaucgguucauucaacaaccaguauuuagugccugcuguguucugcaggcccugccauaggcgcuugauacagcggugcauagcguaugagaaagaucuguccug\n", + "aaagacguuucccgccggcpagcuguggcugugauugagagapuuagaggcpucccagcgcugccgcacc\n", + "gcuguggcugugauugagagapuuagaggcpucccagcgcugccgcaccauggcggaccagcuuuaucuggaaaauauagacgaguucgucacggaccaaaacaagauc\n", + "aaagauacuguacugugaaacauuaaaucuugcugauccgugcuggccauguuuucuugauugcuccagaguagcaaguaaccucau\n", + "gaaaucugucuuuguugcucupagapacuccuggaaugugucugugaauaaagacuagccgaag\n", + "guucucucupauguguagcuuuggaaaucugucuuuguugcucupagapacuccuggaaugugucugugaauaaagacuagccgaag\n", + "auuugcugcugcuuccaggagaaguggagcaggauguaagcaccagcauuccuuccuguaucccuuuuguggcccagccuccuaccugugaagugaagccaaagcccaguguuaaaaga\n", + "ucccaagaauccguucucucupauguguagcuuuggaaaucugucuuuguugcucupagapacuccuggaaugugucugugaauaaagacuagccgaag\n", + "ugcucupagapacuccuggaaugugucugugaauaaagacuagccgaaggugcgaagugacuagacpagcaaaggaggaaaacuapaaupag\n", + "guguagcuuuggaaaucugucuuuguugcucupagapacuccuggaaugugucugugaauaaagacuagccgaag\n", + "cucucupauguguagcuuuggaaaucugucuuuguugcucupagapacuccuggaaugugucugugaauaaagacuagccgaag\n", + "ggagapacuccuggaaugugucugugaauaaagacuagccgaaggugcgaagugacuagacpagcaaaggaggaaaacuapaaupag\n", + "ggagcggugucpcaaaccgcuacccugguauugcuggagccucuccupacuuuugaacag\n", + "gacuuccggccucggaggccggcgucggcuguugcagccugcugcgcgcccapucccgcpuuuucpcgcapuggcgcccgcggcaggcggcggcc\n", + "guugaugucauauuuuuagucuugagaaacagcaucaugccaaggaaagagcuugagcuuuggaguaaugcggcccugagauugaauucuggcucugccacuuauuagcucuguucuaga\n", + "cuuugugcccpugcugagcccuuccccgucagccpccgcpaggapagccgucaccgaggagcugccgcucgcugccccpcapcacag\n", + "gacccgcagcgacuccacapacugcgcucccgugccccuagcgcucccgcgcugcugcuccagccgcccggcagcucugagg\n", + "cgcggacccgcagcgacuccacapacugcgcucccgugccccuagcgcucccgcgcugcugcuccagccgcccggcagcucugagg\n", + "ugcgapccgugagcucacggaccgacggaccgacpcggccggccggacagacpcagcgcapagcpacgcggcpacagcgac\n", + "gcpcgcpcgcpcgcgcggcgccaccguucccauccaggcuugucggcggccaccggcggaccpcuucgag\n", + "gugcpcgcpcgcpcgcgcggcgccaccguucccauccaggcuugucggcggccaccggcggaccpcuucgag\n", + "cgccccgaaccgccccgcgcupaauuugcggcggccuccgccpcagccgagcugaaccggucucuuccucggaaaggcapccgapccugcpcagcc\n", + "gcgccgcuccaggcggcaucgcapcupccggcgcggccupaccccpcuccggaggcc\n", + "accugcagcgcgaggcgcgccgcuccaggcggcaucgcapcupccggcgcggccupaccccpcuccggaggcc\n", + "gcugcucuguguccucugcuccuagaggcccaacaucuguggcccugugaccugcagguauupagacccacagcuaagacaccpacccccugaaagccuagaa\n", + "gcugccgcpupugguaucgaggccugucpucapcgguucgcpugcugucagagcupccpccccuaggcagg\n", + "ccaggcccagacauguccguccuuguaaguuaaaagcuuccaupagccuuccuuccuaaucaag\n", + "ccucgugguggaacaucggacccauucaagaggaaggaugaaagcucuauauaggaacacgaugugaauggaagaaaccugucauu\n", + "acccuccccacupcuccugguugcagagcuccaaguccucacacagauacgccuguuugagaagcagcpcaagaaagacgcaagcccagag\n", + "uggugcaaucuuggcucacugcaaccuccuccucccugguucaagugauucuccugccucagcuuccuaagcaccugagacuacag\n", + "gcccugccauuucugupcucaggucccuacuggcucaggccccugccucccucggcaaggccaca\n", + "auuuaagcacgacucugcagaaggaacaaagcacccuccccacupcuccugguugcagagcuccaaguccucacacagauacgccuguuugagaagcagcpcaagaaagacgcaagcccagag\n", + "agcgcgcaugugcgcagcgcggcgcgcagccugcgccgcccggacccagcgccccgcgccccgcgccccccgccccggcccggcccggcccggccgcagccccgcupcgccgcag\n", + "cuggcgagccggcgccggccgagcugcpagccgcggagagcaccagcugacgccgcpagcugcuccggccgcacc\n", + "ccaaagaaaaagugauuugucauugcuuuauagacuguaagaagagaacaucucagaaguggagucuuacccugaaaucaaaggauuuaaagaaaaaguggaauuuuucuucagcaa\n", + "ccuuauaguccapccuguuucccuguagcagcuccuuauugcuggagaaggagaaaagugcccaagauccuuucag\n", + "gauauuugguuuuuupcgcgacacaaaucgaggugapaagagagaggaaaauccccugaaucccugcag\n", + "acgugaccaggagucgacgugugcagaaguccuuauaguccapccuguuucccuguagcagcuccuuauugcuggagaaggagaaaagugcccaagauccuuucag\n", + "gacucucacgugaccaggagucgacgugugcagaaguccuuauaguccapccuguuucccuguagcagcuccuuauugcuggagaaggagaaaagugcccaagauccuuucag\n", + "guugcuggcuuuuucaggagcugcucgcucgcagccagagacgcugcuuuuuuuuuccpuucggagccguuccggaugcuuuaggcugccgg\n", + "aucaaaaaauauuuugaacuugaaccacuugcacguggaaaacgcuggauucuacagcccugcucacuggaugac\n", + "gcuguugcuggcuuuuucaggagcugcucgcucgcagccagagacgcugcuuuuuuuuuccpuucggagccguuccggaugcuuuaggcugccgg\n", + "gcgcccgccccgcccggcaagaugcugcccguguaccaggaggugaagcccaacccgcugcaggacgcgaaccucugcucacgcguguucuucug\n", + "gagcggacaggcguggcggccggagccccagcaucccugcuugagguccaggagcggagcccgcggccaccgccgccugaucagcgcgaccccggcccgcgcccgccccgcccggcaag\n", + "gagaguccugcuccccuuucaucaaugcacagauacagaagaccccuccgucaugcagcaucugcc\n", + "gcgcgupccupccgcccgucguaccugaugguaggaggcaguaguuccccgcuucccuuccgcpapagaguuag\n", + "cupccgcccgucguaccugaugguaggaggcaguaguuccccgcuucccuuccgcpapagaguuag\n", + "gccugcgcgupccupccgcccgucguaccugaugguaggaggcaguaguuccccgcuucccuuccgcpapagaguuag\n", + "aagaaggcggcpaagauggcgguccupuagaguuugcaagcuuucugacuaggcuagucgaguaacuauucpuc\n", + "cggaagaaaaaccagcaagaaggcggcpaagauggcgguccupuagaguuugcaagcuuucugacuaggcuagucgaguaacuauucpuc\n", + "guaacapcuugacagcgcgcggaagaaaaaccagcaagaaggcggcpaagauggcgguccupuagaguuugcaagcuuucugacuaggcuagucgaguaacuauucpuc\n", + "aaaaaccagcaagaaggcggcpaagauggcgguccupuagaguuugcaagcuuucugacuaggcuagucgaguaacuauucpuc\n", + "gcgcggaagaaaaaccagcaagaaggcggcpaagauggcgguccupuagaguuugcaagcuuucugacuaggcuagucgaguaacuauucpuc\n", + "gccccagcagccccagccccagccccaggcccagcagcagcagcagcagccccugcucucccgccgcccggagaggcucugcagccaugaagccaaccgucccgag\n", + "ggcgacggccccagcaagccccagcagccccagccccagccccaggcccagcagcagcagcagcagccccugcucucccgccgcccggagaggcucugcagccaugaagccaaccgucccgag\n", + "agcagcagcagcagcagccccugcucucccgccgcccggagaggcucugcagccaugaagccaaccgucccgag\n", + "ccucgccaccagcpcucagaggaggaggacaaagacggcpugcuguuccacgucaacaagagcggcuuccccaucgacagccacaccupagcgc\n", + "accccgccccccgcagcucuaggugacgcgucuccaauaacagcucgccpagccgcagcucpcacagccggcggccgcgccccgccgccacc\n", + "guaugagugauuucagugaagaauuaaaapccugugacagaugaugaagaaguggaaacaucugugcucaguggugcaggaaugcauuuuccuuggcuucaaacauacguagaaacugugg\n", + "agcuccuccguggcugccguggucggcuggccpcggcuaggaguucccggaagugcccgcgcagccgguuuccggugcaggupaaa\n", + "guucuccgcggaacucccgccggcggcccggcucacgcggaggcgcgcccgaacugucgcggccgccgccaac\n", + "cgcucuccuccaccgaccaggugaccuuuugcucugagccagaucagagaagaauucgguguccgugcpacg\n", + "cucacacucugcgccuccucucccpacuuuaacaccccgcucuccuccaccgaccaggugaccuuuugcucugagccagaucagagaagaauucgguguccgugcpacg\n", + "cucuccuccaccgaccaggugaccuuuugcucugagccagaucagagaagaauucgguguccgugcpacg\n", + "guggagcggaggcacgcuggccgccgcaggcacaggcgcagaguccacugcgcpcpaccpagcuagcugcag\n", + "auagaguugccacccaggccucagccaggaccuuucaggccagacaggagcaccugaccaaaggcuucacag\n", + "ccgcccucaccgcccggccuucuacgguguccagagacaguuagccaggccupcupcacacuccaccuucccuagucaccagcugguuucccagaggagaaggcugagacccgagaapag\n", + "ucuuucauuagaaccgucagauagucucugagaucuuaggaacccuguuuuguuguauauccucugcccugauaugaagaaaag\n", + "auucpaauuacugcccagcagccgacuaaguugcauuccuugaaucuucgcagaaaagacaauucuuuuaaucagaguuagua\n", + "gcuuccgccuggcguaggagcugaggcauggccuuguucuccagcugagaggacgaucguccuuauaggagaggccgagucuccgapcaauuucagaggucuggugcgag\n", + "ggaagcagagacuuucaaggaacaaggaaaugcauacuaugccaagaaagauuacaaugaagcuuauaauuauuauacaaaagccauag\n", + "gcuuccgccuggcguaggagcugaggcauggccuuguucuccagcugagaggacgaucguccuuauaggagaggccgagucuccgapcaauuucagag\n", + "guuagccacgauggucucgaucuccugaccucgugauccgcccaccucggccucccaaagugcupauuacaggcgugagcuacugugccpcuggccauag\n", + "gccuggcguaggagcugaggcauggccuuguucuccagcugagaggacgaucguccuuauaggagaggccgagucuccgapcaauuucagaggucuggugcgag\n", + "ugacaaaugcaugagccacuuuucaggaggugaaauuauuaaaacucuugaggaugugaccuauuucacauugagaaauaaguugcccugaauggaguaaccauuuuuccu\n", + "cuuccucucccgcuuccgccuggcguaggagcugaggcauggccuuguucuccagcugagaggacgaucguccuuauaggagaggccgagucuccgapcaauuucagag\n", + "guaagauggcggcugccgcggagugcgaugugguaauggcggcgaccgagccggagcugcucgacgaccaagaggcgaagag\n", + "gucgcugugguuucagcucccuccacacupauaggcagaguaugagcauuggcacaugcuguuuuccuggaacaaacag\n", + "cgccuggcguaggagcugaggcauggccuuguucuccagcugagaggacgaucguccuuauaggagaggccgagucuccgapcaauuucagaggucuggugcgag\n", + "pauucgcgcuccacuggucagcupucgcucucpugguupuguugcuuguucccgcuguuccagcaucgaagaaccauupucugccg\n", + "pucgcucucpugguupuguugcuuguucccgcuguuccagcaucgaagaaccauupucugccg\n", + "ggaguacaccuuuaggaugcuauaaaaaacuaauagaauaucauaagaauggacaccuuucuuuuaaauaugugaagaccuuuaau\n", + "acuggucagcupucgcucucpugguupuguugcuuguucccgcuguuccagcaucgaagaaccauupucugccg\n", + "uacaccgacucuggaggaagacuggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "accgacucuggaggaagacuggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "cgacucuggaggaagacuggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "cpcpccuggaggagccuacaccgacucuggaggaagacuggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "agccuacaccgacucuggaggaagacuggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "cuggaggagccuacaccgacucuggaggaagacuggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "uggagccuuugcggcggcgcugccccuccccugguccccgcgagcucggapcccggcuggugcugcpccccpag\n", + "acapcgaugagccgauccuugcgcpuuugccccgccggaguaauccggaagaggccucuuauuapcucugguggcggcgguggcggacacuupucuggacgcaacggcggcpagc\n", + "gucauagaagacuacucggagagcgcugccucupuuggcpcuggcaggcuguagccgagcgcpcaggacucgucccggcapuuccagagcc\n", + "pauugupagucuccgcgucccgcucgcupagagagguaccucuccuuuucccucucccuuucccuaag\n", + "ugupagucuccgcgucccgcucgcupagagagguaccucuccuuuucccucucccuuucccuaag\n", + "aucgcguaaaaauggccgaaaaaugaaacguuaacgcuuguuuuucguacugcgucguggaacaagccgccugcaguacagugcgag\n", + "pagucuccgcgucccgcucgcupagagagguaccucuccuuuucccucucccuuucccuaag\n", + "guucuupcugcagccgcugccgccgcuucucgccagcgccguugcugcpauugupagucuccgcgucccgcucgcupagagagguaccucuccuuuucccucucccuuucccuaag\n", + "guugcugcpauugupagucuccgcgucccgcucgcupagagagguaccucuccuuuucccucucccuuucccuaag\n", + "puuuguucuupcugcagccgcugccgccgcuucucgccagcgccguugcugcpauugupagucuccgcgucccgcucgcupagagag\n", + "accagaucccuguuuccguggaggaaggcagacuucagacugaaggacagagaaggcaacugcccuacagcccugcag\n", + "gucuucaagucugugguugupcacuaacccagacaagaaaaggaaagaccugcaguaucggugcag\n", + "gaaggaggaagcgcgcpcgccauaaggaggaagcpuagucgaccguguccgcgcgccupagacgcugccucggcccggacgcgcccgcgcccccgcggcuggapug\n", + "gucgccacupacacugugaaccaggagugagucggagcugccgcgcugcccaggccauggacugugag\n", + "auucugaaagucaagaagacaucauccggaauauugccaggcaccucgcccaggucpacagc\n", + "ggaagcgcgcpcgccauaaggaggaagcpuagucgaccguguccgcgcgccupagacgcugccucggcccggacgcgcccgcgcccccgcggcuggapug\n", + "aaggaggaagcpuagucgaccguguccgcgcgccupagacgcugccucggcccggacgcgcccgcgcccccgcggcuggapug\n", + "gcucccugcpaagccpcpupagccccggccgcgccggcucccggcgcgcucggccucggapapcggcgguagcggcggcggcggugagcggcgcggcugcccupcc\n", + "aggcaucacgcuggcuuuugccupuucucaggapagaguupagaggcuuugcugcugaggaaauuuauuugguagauugaag\n", + "guuugaacgagagcuacagaaacgaaagaaaaagucuguauaagccaaugguguucpaagaaaauaaccccauugccuugag\n", + "uggcuuuugccupuucucaggapagaguupagaggcuuugcugcugaggaaauuuauuugguagauugaag\n", + "cugucacccagacuggagagcaguggcpaucuuggcugacugcaaccucugccucccagguucaagcaagucuccugacucagccucccgaguagcupauuacag\n", + "aucaguuggccuuauuuccucaguggaaaucuacucacuaugaugugguaguuggcguguugucagcucgcaauaaccaugaacuucgaaacgugauaagaagcaccugg\n", + "acuuugcccugagcacuccugcapuagaagacuccagaaccuucucucaggcccauggcccaagcagccc\n", + "ggaggacagcgcugcgaggaggcgcccpacagucauggagcgccgccupagugapccupugaaggagaaccpcuccuuccagcccccggucugcaacaagcucau\n", + "acuuccgacucagcccucgguucagguuccpcgccgcagagcucccggccucuggaccgcgcgcggcgcucupaauccggcgccacgcgccgugcgguggccagg\n", + "gugcaguccugugucggacacgcccgcagccuggacccpauccccaucccccuaggaucucugagccucpccucugcacccacauccaag\n", + "gcaguccugugucggacacgcccgcagccuggacccpauccccaucccccuaggaucucugagccucpccucugcacccacauccaag\n", + "gcggccgcggapaapupucggupucugacagcpucugcguaggcggcagcgucugucccucccagccucucgcuccgcgcc\n", + "agagcuacugccagapagucagugcaguccugugucggacacgcccgcagccuggacccpauccccaucccccuaggaucucugagccucpccucugcacccacauccaag\n", + "gcggccuuggcccccagcggcuuccucggccucccggcgcccuucagcgaggaagguaaccpccgacccggapugcggccpugcpcaguucaucccpcuggcagaggcccgg\n", + "guaucccucggacugucugcccgacgcgguugccacggugccgccaagcgcggcugucgcgcugccccggugucagcggag\n", + "gccgcgcccguccgcccgccgcuccgcgcuccacccagcgcacccpccccgcgcccccaacugccuccggcggccgcccagucccgapcgcc\n", + "acagcccauuuuuucuuaugauaaagacggcauuuggcucaugagcaagguggcaagaucaucaagugagucagacgugcagcucupaaacagaagaggaugacaugacagaag\n", + "ggagaagaaagaaaugaagcgaguuuucaguauuccaagcauaagagccagcaagauacauucccucaaguguccagaauuuccaauuacagacgacaaaguagcacug\n", + "agcgccucpucaguaacucpaagacgaccaagcpagcpagcpagcpagccggagcgagagcgcgcpcgcggccgacag\n", + "ccgccgccuccaugcugaguuugcugcggaacgagacupaacaguuccaucagccucggaaucuccuccuggccuugguupaagupagcuggcagaacucuu\n", + "upapuuccuccacguggucpaagcpcuggcagcpcucpuccuggcucugupcugucccugg\n", + "acaguggccaagaacaaggaccapcaccuaugaggauuaugucgaaggacuucpuguuugacaaggaaggaaauggcaccguc\n", + "caggucaauggccagcaaggappuccgagccggcggcggcggcggcagugguggcagcpagacaaauggaaaccuccacag\n", + "puaccuaggccccucacgcuggacuucacagucuccpccgccugaccuccgcacpuauaup\n", + "pagccgagcccggcccpaucccgagcagcgagagugupuaccuaggccccucacgcuggacuucacagucuccpccgccugaccuccgcacpuauaup\n", + "ugaggcaagcgccucaggagugcgugaggcccacgcagaacucpagccuuuuauccugaggacacapaagaauuggaggacuauauucag\n", + "gccguccgugcugacugaggcgcugcagccaggagccgcggccggcugcccagcgcucgccgccuccgcgcguccgcagccguccccgcgccgac\n", + "gaacuuggcauuagaauuccucgaccacuaggacapaccaagcagauucaucccagaaaaggag\n", + "accuaaucupagccugcaagugacaacagccuuugcgguccuuagacagcuuggccuggaggagaacacaugaaagaaag\n", + "pacaggcagcuccpuccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "puccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "pcpccupacaggcagcuccpuccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "aggcagcuccpuccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "gauuuaacuaacaauggaugaccuggugaaauccuauuucagaccuaaucupagccugcaagugacaacagccuuugcgguccuuagacagcuuggccuggaggagaacacaugaaagaaag\n", + "ggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "ggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagc\n", + "auucuucucaccguuguggucagcucugcuuuaggcauauuaauccauaguggaggcupaupugagagaauugaggugacuuuuccauaauucag\n", + "puucucpcpccupacaggcagcuccpuccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagc\n", + "uucuguuuuucuuucccuuuucagaaccucaagaggcuuuguuuucugugaaacaguauuucuauacaguugcucca\n", + "gcupcacaguggcucacaccuguaaucugccagcacuuupaggccgaggcagguagaucaccugaggucaggaguucgagaccagccucgccaaaaug\n", + "gguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "uucucpcpccupacaggcagcuccpuccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "aaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguau\n", + "ggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagcguaugu\n", + "aggcagcuccpuccgcgguuucacaucggaaacaaaacagcggcuggucuggaaggaaccugagcuacgagccgcggcggcagcpcggcpaagc\n", + "cuuuccgccugugcagcucgccggcucaauacuccpucupuppcucaaacgcapcucupacgcaggcacugcuccaggugauagugcpaac\n", + "cuagaaagagaagccauagucggcgagcaacgcuggagcaucccgcucuggugccgcugcagccggcagag\n", + "agauggaggcugaggaagcagagugauccccggccccuuccugucccugaacacugucugccuggaugap\n", + "ggucucgcucugucacacaggcuggagugcaguggugugaucuuggcucaucguaaccuccaccucccpuucaagugauucucaugccucagccucccgaguagcupauuacag\n", + "gugguugguacugagcgccugauggcugaggcccuguagcgcupaucugcggcuccagaggcagagacag\n", + "gguugguacugagcgccugauggcugaggcccuguagcgcupaucugcggcuccagaggcagagacag\n", + "agcucacucggcaggcagcpaccapcuggcagguuaagccucupuggauccugaaaggugguccagccgccuggcccugcgupacccuccaccuggcagcag\n", + "acapucucgcucugucacacaggcuggagugcaguggugugaucuuggcucaucguaaccuccaccucccpuucaagugauucucaugccucagccucccgaguagcupauuacag\n", + "agucgapaaggacaggagagagguggcagagcugcagcapuugguguapuuggccuccuggcaaggcccagcaugacaaaggcag\n", + "gcagaggcapcccuugccugupccgugguugguacugagcgccugauggcugaggcccuguagcgcupaucugcggcuccagaggcagagacag\n", + "agcugucugcccugcccugccguaggagaupcupagccucccacgcucuccagcucacucggcaggcagcpaccapcuggcag\n", + "agacaacugagguccggcugugguuugagapaagacagucuagapucapagacgguucagcauccucuuugucccuugcuaccagcuuggag\n", + "ggccaauccaggapcugaagugacacggugguucugcuuuguccuucagccaugccuacugacagugaaggcucacuuugaag\n", + "guguaaapaagaaggaagcaguggauggccagguucgupucuucccggcaggagacagcagagaggcgccugcccpaapuuaaucccagagccguccag\n", + "aaguccapcgugapacuggaagugcaggaaagagccaccagupcupauccaaggucaccugg\n", + "auggaggcugaggaagcagagugauccccggccccuuccugucccugaacacugucugccuggaugap\n", + "gupaacuuupagacuggcccupaggcgacagauggaggcugaggaagcagagugauccccggccccuuccugucccugaacacugucugccuggaugap\n", + "cagacupugccuguggcccupaggagguggaapaggagcaggccacacaggcacaggccggugapaccugcccagaccuggag\n", + "agacupugccuguggcccupaggagguggaapaggagcaggccacacaggcacaggccggugapaccugcccagaccuggag\n", + "uuupagacuggcccupaggcgacagauggaggcugaggaagcagagugauccccggccccuuccugucccugaacacugucugccuggaugap\n", + "ccuuucgcgccgguugccgcugcggagcgcggcpuccaugugcgcagugaguggcgcuauuccuggcccaguagcacccgagccccpuuugaccgaguccgcgcugcg\n", + "gccauaagauguuuuauugaaagaaacuuucaauaucaaguaauccaaccaaccuucuaagauaagccuuuuccuucaacacaaagaagugcauuuugccaa\n", + "aaaaagacaucaaguccuuucaugcuguccupaaaggcgguuuggaacaaguuauccugauucuagagac\n", + "gaugcaaagcacugugcuaggcaccaggagaaugcagaaapcacauccccuuccuucaaggaguuuacagcuuucucagaagcag\n", + "guauuaaaggucacucugcaagagaaaaaaagaaaagaaaggaaaagaaaagaaaaaaaaacaugcuuuuaacugcagaucaauacuguugaaacaguacaccaagag\n", + "aucuggaaagcaugaagacupcuuuuuuuccuaugucucuupaacugcagcugcaaucccg\n", + "gugaaaaggagauaagaagcaaaggagcaaaccaaaccuaauaugaauccuguacuuuggccagaagccguggcucacaucuguaaucccagcacuuupaggccaag\n", + "uaaaguuauucaaucuccugagccuaacagcaauguagaaacggaacuuuuugcuuuuccaaaag\n", + "auugucugaggcaaaaagacaucaaguccuuucaugcuguccupaaaggcgguuuggaacaaguuauccugauucuagagac\n", + "aggaggacgcpcuggcaggcuugguuccuggcgaguuucuaagcccccgccugcggucugaggcaccggcugaacc\n", + "cuuccuucccucccagagcuccggaccagcuccgcacgaccccagcagcugagcccpaccgagcccpaccuagcccpcagcucgagcccauuggucaccapcaaacag\n", + "guuuggacacaauuuuccauuuccupaagauuuucugucucugccuaugucacaagaggacucaggaccugaaagaagagcucag\n", + "acacccccccagcacucggcacagccucgcugagcagccuucagcagcapuguggupagccucggagagucupuuccauccuggcccagccucacaccagcugagagacg\n", + "accgacugagcuucgaggacaggaagccaccggcaucacuaagccaccggcaucacuucauccccagccucacgcuupacupcccpaag\n", + "guucugaucuccacggucccagcuacugacuggacgccaucacaaccuuaccaaucuucagaauacacuccuuuccauccgacgaa\n", + "acgaagccccggcgucccacaggucccggaggccgcugcgucgcpagcupcucpccgccggcgguugcgccpcagccccgcpagagcacc\n", + "caggucccggaggccgcugcgucgcpagcupcucpccgccggcgguugcgccpcagccccgcpagagcaccaugaggacugacucpcucggcuggaggapccaccug\n", + "uuccugcggcgucgguggcgagcugagguggaggcaggcugcggcagacggcgacaguggcggcggcgccauggcapcuugcag\n", + "acuuaccugcagcagcacgcggaagauguaccagccgaugaugagcaguucagccgaggccgccgccacugccgccaugguuccaagaaug\n", + "auauugucccuucupucaccuuaggcgucgccpuccccgucacupuuuuccuuccgcauaccccpaaggcapcgccccuguccggcuucag\n", + "uagaccgccagucuugupucccucgcacagcgcggauuuucpcpaagaccggaaugcgguuu\n", + "ccugcggcgucgguggcgagcugagguggaggcaggcugcggcagacggcgacaguggcggcggcgccauggcapcuugcag\n", + "cauccucagaagcuucaacucuggaggcaaupucgaaaggaagaagaugacugcaguuccuggaagaaacagaccaccaacauccggaaaaccuucauuuuuauggaagugcupauc\n", + "gaucaagcaugaaaacauugugacccuggaggacaucuaugagagcaccacccacuacuaccugguc\n", + "gcuuccgagacucgcagucuacgcgagcugccuguuuuuuuccugcuuggacgcgcaugapccccgucc\n", + "cagaaaccagccuucuucgaaguggucuuggugugauucuccuauccguuaucaaaaacuugaagcugugauuugccugag\n", + "uguagcagaaaccagccuucuucgaaguggucuuggugugauucuccuauccguuaucaaaaacuugaagcugugauuugccugag\n", + "gugaugcucupaucccgcgcuuccgagacucgcagucuacgcgagcugccuguuuuuuuccugcuuggacgcgc\n", + "aaggagaugcapupcuuugccaaaggccaguggaaggagcucaggcuuggcggcaucugguuugcuugucupccuacuccuuugcaugauauaacaa\n", + "ugccaauaccaugaagaggagcucagacagcucuuaccacaugauacaagagccggcugguggaagagupaccagaaag\n", + "acagugccaauaccaugaagaggagcucagacagcucuuaccacaugauacaagagccggcugguggaagagupaccagaaag\n", + "agucgcggcgucugccugguccucagcagugcagccccggcgcggagcapagccucggcccgcgcccggcgcccucgcccucgcccucgacccgcagcc\n", + "uaauaguugcuguugcugcacuuccgcuucucucccagcgagagagagacacgaguggccaggcccagccgcagccgcagcagcagccgccgcggcggcacggaggagccagacacaaagagag\n", + "gaaaucaccuuuccaaacccaaupacuucccagcuggaacgagaacugagucugaugcaaaaagaaccgccugapuggcuuucgag\n", + "acupagacaagacuugaaaccaaagagccaacuccgaagccpuauuacugaagauuuaugccaupuaaca\n", + "ccpcaugguugcgugcaccuguaaucccagcuacucpaggcugaggugcaagaaucacuucaacccpaggcugagguugcg\n", + "caggaaaucaccuuuccaaacccaaupacuucccagcuggaacgagaacugagucugaugcaaaaagaaccgccugapuggcuuucgag\n", + "auggagucucgcugugucacccaggcuggagugcaguggcacaaucucagcucacugcaagcuccgccucccpuucacaccauucuccugccucagccuccggaguagcupacuacag\n", + "guagucuggcgcuccpcuguaagcgccggucgcggcugugucggucgccgcugcucccgcuccugcupagagg\n", + "gcgcucpcpucuauagupaapacgcgcgcccugcggcccggccucuagucaucgcccucgcagcggcggccaacaucaccgccacugccaccccucccagacuguggacpagg\n", + "agupaapacgcgcgcccugcggcccggccucuagucaucgcccucgcagcggcggccaacaucaccgccacugccaccccucccagacuguggacpagg\n", + "auagupaapacgcgcgcccugcggcccggccucuagucaucgcccucgcagcggcggccaacaucaccgccacugccaccccucccagacuguggacpagg\n", + "cucuagucaucgcccucgcagcggcggccaacaucaccgccacugccaccccucccagacuguggacpagg\n", + "acuucccupuucacagcapuggaacuggauucuuccuggaupauccagauggagguggag\n", + "ccucgcggcuggagaacccaaccgacagupcggcaggacgcaccgcggaccccggagagagcggacgagcapcgccggcgcc\n", + "uuucauuauacucaaguaacgccccagaaauuccagagaaucucacacaaagagguugagucuugccguggugccuucapaaugucaucccpcuagaagagcugcaaaaggcugucag\n", + "gcuucucagaacuuugcuucuccagcagaauaauccugcggaagacugagcaguucuugugaguguaaaacc\n", + "acggaguuucaaucuuguuacgcaggcuggagugcaaupcgaucucagcucaccgcagccucccccucccagauucaagcgauuuuccugccucagucuccugaguagcupauuauag\n", + "aagcggagagcagcuguugcaguaaccuguugcagaaaagugaaaguauauccgcaacaguuggcucugauugcagagagcgcgcuugugagaacug\n", + "cugcugcagaagaauauuuugccugcuggaaccugcuguaucuacucaagaguggaaguuuucacag\n", + "cccuguccuuaccuucagcaggagccgguucccuguguguguguccgcucgcccucugcuccguccugcggcugcccacugcccuccuacgguccacc\n", + "accuucagcaggagccgguucccuguguguguguccgcucgcccucugcuccguccugcggcugcccacugcccuccuacgguccacc\n", + "gagaacucuugagaccpagcccagcugcccacccucuggacauucacccagccagguggucucgucaccucagaggcuccgccagacuccugcccaggccaggacugaggcaag\n", + "gucucuacauuggcuggcgcugcccccauuaccuaupacuguuuccggauupaugaguccag\n", + "gaaaagguguupuaaauaugcagcucuapaacauaucaaaggacagauauagaagguacagcccaaacucagaaaccucucuuaacacagcucucaacccaacuccugacacc\n", + "gucaggccguaggaaggcgagguccpcugcaugcagagcugagagcugaggacucccaucuccagccugcccpugaagcgcg\n", + "aaaauaguaccuacgaagcuugaaggauggcuggagcuuapuuugugagacagaacaucaggaagugagcccagaaag\n", + "cugaaggucuggugauagcupugcaggaauauugugcaggapcuauguguccuggaccaugaagaag\n", + "gcuauagcagagaugcgugcaaagugcucupaggagccacaucuccacaugaggcaguugaacgacguuucagcugagucuugacau\n", + "agcagaagagcauuugaccaagaaaauaguaccuacgaagcuugaaggauggcuggagcuuapuuugugagacagaacaucaggaagugagcccagaaag\n", + "agacccugagaccccapcuaggcagagcauugguagaagugugcccucuuccuuaccuccaggaggaccacaucccaaaguggccauugguccuaaugauuggaagacugauuauaucua\n", + "auagaucucaggcucggcuccccgcccgccgcagcccacuguugacccggcccguacugcggccccguggccacc\n", + "cucccggcgcagucaccggcgcggucuauggcugcgacuucucuaaugucugcuuuggcugcccggcugcugcagcccgcgcacagcugcucccuucgccuucgcccuuuccaccucgcggcaguucg\n", + "paaucucucccuaggucagguuggagugcagugcugcaaucacggcuuacugcagccuugaccuccupcucaagugauccucccaccucagcuu\n", + "cagguuggagugcagugcugcaaucacggcuuacugcagccuugaccuccupcucaagugauccucccaccucagcuu\n", + "uuuccucaucugcaaaauaggaauaagaguaggaccaaugugaagauuaaauaugcauguaaaaugcucagaacg\n", + "gauucuggacucuacuuauaauaucccuaacugcuggauucuccuguugcagcuuuucuuggacagugacuuacuuugauucuuuugaaccagga\n", + "ggcuguugcggacccpcpcaggupagaggcucguucuccgcpuuucguuguguuucgcgcc\n", + "cupaccgaaugcgcgcgcgcggugcucgaggcggapaggaggcpaaggcgaaaggapuucggaggagapuucgaucuccguacgcaccag\n", + "ugcggcuuccuuugcaacccgccgcccacccuugcucuccgugguuuaccccupcucugaggccuggugguagcggccacugccgcggauuggcuguugcggacccpcpcag\n", + "cccupcucugaggccuggugguagcggccacugccgcggauuggcuguugcggacccpcpcaggupagaggcucguucuccgcpuuucguuguguuucgcgcc\n", + "cagacgaupacacagacucauucugagaacagcagccaagaaaacagaaucaaggcucgcugccuguccugcacgucc\n", + "auggaugaacuacucuuggaucucuuccacaaacugaccagupaggcagcuggcagcaggcaaupcuuugcgguauaucacauaaggaacaggag\n", + "acgaupacacagacucauucugagaacagcagccaagaaaacagaaucaaggcucgcugccuguccugcacgucc\n", + "cgcgcucuggcgugaapccgguacgugapaggccuggcccgcggacccggcucccagcucpcag\n", + "ggcccgcggcgcgcucuggcgugaapccgguacgugapaggccuggcccgcggacccggcucccagcucpcag\n", + "gcugcaccggcuggccccgcacgcuggaugccggaaagcagcggcccgcggcgcgcucuggcgugaapccgguacgugapaggccuggcccgcggacccggcucccagcucpcag\n", + "acucaaauccugcuuccccaguaggauccagucugupcucauuugapagaaugagcacpcuuuuggaggcugcagccuapccaapauggag\n", + "gcucaccugagugcagguuaggcaggugaagugucuccccggaaaccaagcuagagugccccaccugcucggcccugccuucucggaucggauccagcacauccaggcuucuc\n", + "agagcuccgcugagcaccpucgcgcgcggccgagucgcggaggcgccuccgcugcagucgcugcgucuccaag\n", + "caggcaggcuccggagaguuccgcacgcugcggaaaggcuucucgcccuaccacucggagucccagcuugcgucccugccgcccuccuaccaggacucccugcagaac\n", + "ggcccggccugccccgcaccugagcugcccucgccccccucugcuggcuacagcccugcaggacagaagcccgaggcugucgugcaugcc\n", + "aucccucauccaccuacaucaggcaacuggagagcaaagugaggcugcuggapugacaagcuccucgcacag\n", + "guucaccaauuuuuaaaauccaaauauaucucaugguacaguggaagaacuggccagagagucuggaaguuupuucugguccuggcugugccacugacucacugugaccuugg\n", + "aguagaacuucuugauuccucagauaaauagaggacagaugcuggacuguagcuaaguauuuccuuucaucuacpauaaaauacugauaauuugagagug\n", + "gagcugaggcccgcgucgauccupuuggaggagguggcggccgcugaggcugcggcgugaagacggcpc\n", + "ccccauguuauaguacauugugcagcagagagaagaccagauguuguagaaaaucagccagaugcugccucucaacuuaauguggaugcuucupaauuuagcaaaggaagcag\n", + "gagcugcuguuuugaggauuccuauucuguaupaaguugaaaagcucgaagaaagugcugugacuguu\n", + "ggcccgcgucgauccupuuggaggagguggcggccgcugaggcugcggcgugaagacggcpc\n", + "pccgapcgucugagcugaggcccgcgucgauccupuuggaggagguggcggccgcugaggcugcggcgugaagacggcpc\n", + "pcggcuuugcaggcguauuccgcccpucagagccuccggccpaguggucucaccgccacccucccagccccggauccgappcgccaccgaguuuguuuaucucagcgcacacgg\n", + "uacauugugcagcagagagaagaccagauguuguagaaaaucagccagaugcugccucucaacuuaauguggaugcuucupaauuuagcaaaggaagcag\n", + "gaggcccgcgucgauccupuuggaggagguggcggccgcugaggcugcggcgugaagacggcpc\n", + "pccuapaggcpccgapcgucugagcugaggcccgcgucgauccupuuggaggagguggcggccgcugaggcugcggcgugaagacggcpc\n", + "aagacuaggcugcucugagaaucagaaugcuaauugcauaugcuugcccuuaaaccugcuucacguugaagaaugaagaauuaauuuucuuuucucccauagaaag\n", + "guucupccuapaggcpccgapcgucugagcugaggcccgcgucgauccupuuggaggagguggcggccgcugaggcugcggcgugaagacggcpc\n", + "gaaauuauuggagaagcacaaaaggccaupaaacaugugcagagaucaagcaguuuggcugguccagucaaguuccaggucaaacauuugagagccaagg\n", + "aucuuaguuggucuucuaguccgguaaacagapccugcccccgacagcuucugcuuccpucacgccuugacagcggcuuucaacccccaccucagcccagcaauucg\n", + "gcugccagccgaggagcaggcgcggccgcggcgccauauugcggcccucagcggccgcgaccgaguc\n", + "ugupagaguucuguugcugcggcpccugcacguugacugupaaacucggugagcpcuccgcgcgccpcupcuccpaccgcggaggcuccccggcccaucgacgapagagag\n", + "aggagcggccpaupccuccpacggugugccaggccpccaagucggaggccccucgcucupupcgcupcccgcgapcuacu\n", + "gcgcuuccgguuuccggccgcgguaugapcpccpcugcugupagaguucuguugcugcggcpccugcacguugacugupaaacucg\n", + "aacgccuuucaguuaaacpcgucggaaaucucpcuuccupcapaucgucpagaggccgcucuggacguguugacacacgugcuggapcag\n", + "ggupcgcupcccgcgapcuacuguaaggaccccuggcuucugaggauacugcgucuagaacuuucuccguaupccuugag\n", + "ucgcccggagcccgaggcgccucuuccucucccgcucggagcgccggcccuccgcuccpcpupaagcggag\n", + "aucgagcuuccugcagcgguggccacccgagcaagugccguggcpcggagagcggccacggcggcggcgccuccccaaguggcccguugcguccgaccccgcgugaaag\n", + "guuggcagagcaguuguccuggauggcggagccuupuuccpccupaccugcaacucuuucuacaag\n", + "gauucucgcpaccucguuggcagagcaguuguccuggauggcggagccuupuuccpccupaccugcaacucuuucuacaag\n", + "ggugcapccgcggccaccgccuucuguccgcaggugcugcgagccguaagcgccccccacccgcgcu\n", + "ccapuagupaaagugcgcuccccaagaauuugcggugcapccgcggccaccgccuucuguccgcaggugcugcgagccguaagcgccccccacccgcgcu\n", + "gccpcaguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "guacucauuuaugacagauuuggccaagauauaaucucuccucugcuaucugugaaggagcuaagagac\n", + "gcaguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "uggcuuugaagcguauguugaauuucaaugugccucauauuaaaaacagcacaggagaaccaguauggaag\n", + "guacucauuuaugacagauuuggccaagauauaaucucuccucugcuaucugugaaggagcuaagagacaupaaucacucugcaucu\n", + "gaucuucgaaaucaacuauaugaaucauauuauuuaaauuuuauuucugcuauuucaagaaguaaacuggaagauauugcaaaugcagcguuagcagcuagugcaguaacacaaguagccaag\n", + "aguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "pcaguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "agccpcaguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "cccgcuccgcuccccagccpcaguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "ggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "gcuccccagccpcaguggcucgupagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "ggagccaagauggcggcggcggcggcagcgacagcagcagcagcagccaguauucpaaaggcagacag\n", + "acuuccguccggucugccuggucucucuaaccgcgccagugugccuccgacucggaacggcuuccgcggccpcagcgapccpcggcpcp\n", + "gccuggucucucuaaccgcgccagugugccuccgacucggaacggcuuccgcggccpcagcgapccpcggcpcp\n", + "aaccgcgccagugugccuccgacucggaacggcuuccgcggccpcagcgapccpcggcpcp\n", + "ucaagagguguugccaaagauucacgaagauaaacacuacccuuguacuuuggupacuuggaacacgugguauggcgagcaggaccaagcug\n", + "cccacauccpagaggagagcggaaguggcguuggucuggccggagcccuupugaaauuguuaggcguggagapagug\n", + "agccupacapcuuugagaaupaagacgaaggcucugguauuguuacccgccuuugcacugcuggaagauaggacagcauauuuuuccuaaaag\n", + "agaggagagcggaaguggcguuggucuggccggagcccuupugaaauuguuaggcguggagapagug\n", + "gucacacgaccuacaaguapagcapaaagaagagugagccugcaugccaauucuaagcucuucaggaucaa\n", + "auuaugucauaauaauaucauacaaguauuugaguugaauccguguaacauauuuuaaaacaggcggaccuauccggcaguggugcagacggccugacgag\n", + "gcugacauucacguuucauucugccacacucpaacggugaucpaagcaupauccpagaagcacccacaaaacuagcauccuccuggaggagcucgg\n", + "ggccpuupcapccuppcuucccuppcuugucgccpccgccupcuuucaggucuuccgag\n", + "cugacgagguuccuuggccpuupcapccuppcuucccuppcuugucgccpccgccupcuuucaggucuuccgag\n", + "auucacguuucauucugccacacucpaacggugaucpaagcaupauccpagaagcacccacaaaacuagcauccuccuggaggagcucgg\n", + "uuucuuuguuggaacgaagcucaacucauauaaggaguuuggaacccccugccggacuuacaaccuccaacuucucucua\n", + "acaguuguugcaaagugcucagcacuaapagccagcgcacagcacagccaggaaggcgagcgagcccagccagcccagccagcccagccagcccggag\n", + "gcuuccupccgcgcguccapagcugugccguccgcccguccgucugcccgcaggcauugcccgagccagccgagccgccagagccgcpccgcpugucgcpcccaa\n", + "acauugaugagugugagucuggugcgcaccagugcuccgaggcccaaaccugugucaacuuccaupcuaccgcugcguggacaccaaccgcugcguggagcccuacauccaggucucugagaa\n", + "gcaaaggccugaagauugcccgucucccugcagccgcgcagupugcagccuuuucacaaaugcaagaccuggaccggcggcgaggccaapaccccguguggapaugcpacugaguccg\n", + "cggccugcagupaagcuggagcagcacacggagcggcgupucaucuacagcccggccuggccccucaacuacccgccaggcaccaacugcagcugguacauccapcgaccguggugac\n", + "aaaaggccaapagcuaacaaguguggaaggugaacccuggcuuugcuccucuuucupaapuugcccggcugugcugccacc\n", + "ggcuucgcgcucguguagaucguucccucucugguugcacgcupaucccggaccucgauucugcpcgag\n", + "gguguuguuauguccaaagccaucuugccaugcgcagccugagaauggagccaaugacugapuggcagagcagaaag\n", + "gccucuccagcaaccugacaccugcgccgcgccccuucacugcguuccccgccccugcagcggccacaguggugcggccggcggccgagcguucugagucacccpacuggagg\n", + "acugcguuccccgccccugcagcggccacaguggugcggccggcggccgagcguucugagucacccpacuggagg\n", + "gcgcgacccucccccggcccggccuggcccggccuggccaguccccgcggucucugcccpcugacgcccaggaauguggucgacgagaagccccaacagcacggcguggccucucagccucg\n", + "ccucucgccgccgapucaggagcccpagcgcgacccucccccggcccggccuggcccggccuggccaguccccgcggucucugcccpcugacgcccagga\n", + "cpagcgcgacccucccccggcccggccuggcccggccuggccaguccccgcggucucugcccpcugacgcccagga\n", + "cugcugccggccgcgaccgcaacccgcuaggccuucaucgcgagcuacgcccggaccgagaagccccggc\n", + "agaacccacaaagccugccccucaucccaggcagagagcaacccagcucuuuccccagacacugagagcugguggugccugcugucccapagaguugcaucgcccuccaca\n", + "cacaaagccugccccucaucccaggcagagagcaacccagcucuuuccccagacacugagagcugguggugccugcugucccapagaguugcaucgcccuccaca\n", + "agagugcuagcuccccggcgguggcugcpuccggagccupacgucggccccacagacggagagcgcgcpagcgagcucaaggcggcgcggcggccacupcgcagcacccag\n", + "guugauugguugcuuccgugcugcuucucuaapcgcuugcccuuaaagaagcugacccagaggccuuggugcugccggcgupauccccag\n", + "uuguagupcuggagcagagccugccgcgaacccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "gcagccuuguagupcuggagcagagccugccgcgaacccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "cagagccugccgcgaacccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "aaugaggcuccggcuuggccagugccaagagcagcgguuguuggaguguaacugccaugcucagccgcg\n", + "uccggucugcagccuuguagupcuggagcagagccugccgcgaacccccggagcccacgaucccucgugccaucccucgaauccaccagcacgagcgucccacccgcgccupacc\n", + "gucuggugaagcupuucacugcgucaccugccagaagguggccaucaagaucgucaaccgugagaagcucagcgagucggugcug\n", + "acagagcuucaggaaccaccgagaupagccugccggagacacagguuuucugagcgcaccagcggcuccaaaagcagapaagagcccugcgugcag\n", + "ugagcapcggupuggugcggagugccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "auaugagaacggccgaggcagcucccaccagcaacaggugaccuguuaccccuucaaagaugucaauaacugguggauuguaaaggaucccaggag\n", + "ccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "aaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "aauacaguagcaacgugccuguguggucccugcgccugcugccagcacucgcpccuugucggucccc\n", + "cggagugccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "gucuguguguucugucacuugcucgcccgagcaguggcuuugcuggucaucccggucguccuguacuuacuguucuucuacguccacuugauucuagucuuccgcucupccccacgaccaaauc\n", + "apcggupuggugcggagugccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "ggugcggagugccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "ggagcupcpuucpcccpcagaugcggcguucpcggccgagccccgaaguaagaacuccguggcgcgugcagcccuapaggaapcgugcugcpugcagucucagg\n", + "guugagcapcggupuggugcggagugccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "gugccgagcggccucacccccaaccgucggcccagucggacgguuccgaggcguugccpagccpcgcggcucuguguggacucggagaaacgcgg\n", + "agaaapcagacauggagaagaagauagaggugagagagaagagauggcaugaggaagaaaggagcuguguggaagacgguggccaupuugaag\n", + "aaguuggapagaugapuugapaacauuccaupagagcapuuugagcucaugacuguguugucccuguccuuccccccaccuccugcagguac\n", + "cucuggaugugucuucggucgcccguuucugacuuccucugccuccgucucccucugagccucucuuucuggccauuucugguucucucccuguucccugcccaucucccguugcupugacuca\n", + "ggcucccggugcccgucuccagcgccgccggagccagccapagccggaacgaaaaggaggaggaggaggccgcgucgccgccgcucggagcccggccggagccucgcag\n", + "cguagaccaccaccucuuuagaaccuugagaccagucccugucccugccccguccccuccucauagcauuagagacca\n", + "agcucucugaagaucaacugccuccacauugcauucuuugccccaaaacucuuuccuuugguugugcuaagaggugaugcccaaggugcaccaccuuucaagaacuggauc\n", + "aagaagcgcacgcugaapuccauugagcucucccgaaucaaauguguugagauugugaaaagugacaucagcaucccaugccacuauaaauacccguuucag\n", + "guggugcaugacaacuaccuccuauauguguuugcuccagaucgugagagccggcagcgcupugcuggcccuuaaagaag\n", + "gcgacaacaaaacagauuacuuugaapacuagaaggaggacacapuccuggaggaaggcagcuggcaaguuacagagcagaaag\n", + "aguuguugaccagccugccacuugccucccugccugcuucuggccgccuugaaugccugguccuucaagcuccuucupucugacaaagcapacc\n", + "uguugaccagccugccacuugccucccugccugcuucuggccgccuugaaugccugguccuucaagcuccuucupucugacaaagcapacc\n", + "acccuccaagccugcaccucuuaguccagcaccaggaagaguggcucuaggapagaggagcccapacugacccaag\n", + "agagaaagagagagupcagacaucgaagccaaacagcaguaucccggaagcacucaugcaacuuugguggcggccacucaguuuucucugccagugucug\n", + "cgucccugcuaguacuccpcugupucggugcggauauucagucaugaaaucapuapacuucucccgcagcgacgcggcuggcaagacuguuuguguugcpccggacuucaag\n", + "aaguacagauuucucaaugaagaugcacccauuauuuuucccuuuaguguauuuugauucguguccupagaucaggag\n", + "agugccuccaccaguaaaagacaauucaucuggcacuuucaucguguuaauuagaagacuugauuguaauuuugauauaaag\n", + "gguuuuuugauuaacucaaaaccagagaaugccugugaacccauagugccuccaccaguaaaagacaauucaucuggcacuuucaucguguuaauuagaagacuugauuguaauuuugauauaaag\n", + "ggauauucagucaugaaaucapuapacuucucccgcagcgacgcggcuggcaagacuguuuguguugcpccggacuucaag\n", + "uauaacuuugaaaaugcaucucagacauuugaugaccucccugcaagauuugguuauagacuuccagcugaagguuuaaag\n", + "cgucagaguagaaaccagagaaucacaggaaggaaucauuuuuagacuuacggagcuucagagaccaagcuuuuaa\n", + "auucaaucuucaaaucagcgccgcpaagugcpcpuguugcuccccugucucuggacgacgcugugacugaucccaggcuuggagccggagcugcgagcgaggcagugaaapuggcag\n", + "aagucaauugaagccuugugcaaaugcccuapugugcuguupaggcagcccccugugaugcggaacaccaggcucagauucaucaguucg\n", + "ccuguccaucuggcccaggugaguuucgucaucccagccuucaacucaaacuucacccuggaccuggagcugaacca\n", + "ccaccuccucuccucgcaauacguggagcgccacuucagccpapacaacccagcacagcacc\n", + "pcuggagaccacugcuacuaccapaagcuccpaacccgcacuccuucgccgcccucuccaccugccapcugca\n", + "upucuucucugaupaacuugacuuacaucguggagccccaagagguggcuggaccuupagccccucag\n", + "gcagaaagcuggcppuppaggaacauggcgcaagcucugucugaggaggaguuucagcggaugcag\n", + "uacuuggagagacagaucacupuccuggagaggacaggaguaggaaagauucugugaaggccaagcccucugaccuugagcagacuaccagagaaca\n", + "acagagucuuucucugucacccaggcuauagugugcaguggcacgaucucagcucacugcaaccuccaccucccpuucaagugauucuccuaucucagcuucccuaguagcupauuacag\n", + "gcucagcuccuggaacuccggacaaacaacuaccagcuuucagaugaacuacgcaagaaugguguug\n", + "gcagagugcgcugcguuucgaugagccpacguggcgccgcucuagccagcgccupcucuguggcpcgccgcagcuccgcgucccccgcgccuccucccagcgcag\n", + "agcuggagcuggugcagaaugccuucuucacugaccccaaugaccagagugccugguuuuaucaccguuggcuccuaggccgag\n", + "gugugagcugucaguggagaaguccacagugcugcagucugagcuggaauccuguaaggagcugcaggagcuggagccugagaauaaau\n", + "ggaaguuacugcagccgcgguguugugcugupaapagaaggauuuguaaaccccggagcgagguucugcuuacccgaggccgcugcugugcggagacccccpugaagccaccgucauc\n", + "gcagccgcgguguugugcugupaapagaaggauuuguaaaccccggagcgagguucugcuuacccgaggccgcugcugugcggagacccccpugaagccaccgucauc\n", + "gcucuguggauuagacucaccucugcuucuuggugugupccucagcugagaugacucaaguggcupcuggaacagcuaguugucag\n", + "gaggcaaaaccuucaacugaggacuupauaagaaggaaggugaauauauuaaacucaaagucauuggacag\n", + "acugcagccgcgguguugugcugupaapagaaggauuuguaaaccccggagcgagguucugcuuacccgaggccgcugcugugcggagacccccpugaagccaccgucauc\n", + "gaaupagaggcpcccaaggapaguggaauggccgcpcggcucgacgcagcagaggcgacgcgagauggcggcagcuucagcggcggcgaucucag\n", + "cgapcagaagagcgcgapagcgcpcagcagaagcgagagccgagcgcggacccagccaggacccacagcccuccccagcugcccaggaagagccccagcc\n", + "ggcgcgaucucggcucacugcaaccucugccucccpuucaagcgauucuccugccucagccuccacaguaguupauuacag\n", + "gaucacgugauaaggcacuagcagaugugguuggaauccuugcugugcugaauccuggcugugugaccccaa\n", + "acaucucucacgauaaaugagupagaacuuauagcccuugaagucaaccaucucacaccuuuccaaaggacgcgaccauaacucuaaaag\n", + "gaccugacgcuauggagcucucggaguuuugupacggcugugaguppuuccugcugcpaugagaacguagacgccaguggcucacucgcuccuggcaccuucccuuucaggcuccag\n", + "gcucucggaguuuugupacggcugugaguppuuccugcugcpaugagaacguagacgccaguggcucacucgcuccuggcaccuucccuuucaggcuccag\n", + "ugcuaaugcuuuugguacaaauggauguggaauauaauugaauauuuucuuguuuaapagcaugaagagguguugagguuaugucaag\n", + "aaaaaggauccuguuugcuguguaauccugagaauggacugcaagagaggaaaaacupcgucugcuupaaucuauuguggaaacccag\n", + "gcaagcgcaguaggcccagugcgugcuggcccpuggcaggagccgcagaggcuupcugcag\n", + "gguguuucccgaccagucccupcgccaacuagaguauggacugaccagguaccuggauggagaccugagcuggagaaggagaugcgcuupag\n", + "aguucccacugcagcgcaggugagcucuccugaggaccucucugucagcuccccugauuguapaggauccaguguggcaagaaacuccuccagcccagcaagcagcucagg\n", + "uucguagguguaaagcuuugaaggaaaaagauuuaauuagaacgucugagucagacuguuacugcuacaaucaaaauucccaaguggaguggaaauacauauggucaacu\n", + "acuuccgcuccucgcagcggagccgguccccuapcucpucgcacggagcugaccccuaacgaa\n", + "gcuuuauuuuaaaggcaagugagacugcuucaaauaaaacaacuucaagcuuccaagaaacaguuaagaggaggcagagaagagcagaaacacuucuuugcugacacuuacacuguugcc\n", + "aagcgcuuccccaggcggcggcgguccuggugcggacccuccggccgcagccaugupacccgcpcagcuag\n", + "gcccgguggcggucacucacgccuguaaucucagcacuuupaggccgaggcagguggauugcuugagaucaggaguuugaaaccagccuggccaacaug\n", + "agaccggaaggugaacaugcccugcacpucuggcagcaagcgucucccccgucuccucacagg\n", + "ugcccagcccuguuccgcucaggcagaguccugccccugcacccacucccccauucccggccccaggccaugccccag\n", + "gcauccuggagcuggaggagcuccugcpcapaagucuucuugcagccguguggacgaaguuuggcccaaccuuuucauaggagaugc\n", + "aaacagcaucaagugugcggagacaggcggcugaaagccagcagcacgaacugcccgucagagaagugcacagccupccagauacucccacag\n", + "agaaccugcccagcccuguuccgcucaggcagaguccugccccugcacccacucccccauucccggccccaggcc\n", + "ggcagaaccugcccagcccuguuccgcucaggcagaguccugccccugcacccacucccccauucccggccccaggccaugccccag\n", + "gcuuugaugagaaauccagaagaaagaguguaugaaagaaaaagaugacaucuaugcauagcaaacaaaaucugaagauuauuacaguaaaaacaaaagaaaggcaagagaauacuuacuaguuaaag\n", + "gguuuuuaugugugupaauggacgcaaaggaaaacacagcugagcugcauuguaacucuuccuguagaaccuguuc\n", + "uuauuccaauggaaacagcuggagaacuuauauuuccgugagaaaaaauuugcuguugaaguucaugauccacgaag\n", + "gauuucaguuucaagaagaaccuuupcaaaguggcuuguuugugcaaacaugguaugcuaacucuucucucaucaaguccauuupua\n", + "agcagaagccggcgucpagcccaggcpcaggccgcupucpcugcacguacgagagccpacgcccpuucagagcgaaggaggaggc\n", + "cagcacuugcacucugaggacugacucuuaccagcupagcaaacaggccagcuggagaccgag\n", + "cccgugauugguggucuacuauucupagauaaagaagaauuugaucaaggcuguuugugucuggcuaauguugacaauaguggaaauggacaag\n", + "aaacagagcuugguuuuagccapcgcccacugcagucacgcuggagaccucuggugcagaupcgagacuggacccagcuuuccagcuuucuuccccuuuccauaauucuccugaaaguguaag\n", + "cacuggccuguguuuguggaggugaaagaccuuuugacauuggugccgccccuggupccugaapaaccuggag\n", + "paggcgcgcpagapcgcccpagupugcgcpaggcgagugagccpcgccpcccupcucggcpapagucag\n", + "gcuuccugccugagccgcaggcccgccccugcguccuccgcccgccucuuucccgccgccgccupapacccg\n", + "apuuucaccaucuugccuaagcuggucuucaacuccugagcucaagcaaucugcuugccucggccucccaaagugcupauuacaggcaugagccacugcaucuggccagauag\n", + "ggcaapaaggcaapaucuucaagagaaugugacugupauuauggcuuucuggccaauuugu\n", + "gaccauuuccuacacaagcucauucagaggaggaugaagaccauuuuggaggaagaaaagcacccuuauuaagaauugcagcaaguaagccaacaaggucuuuucag\n", + "acacaagcucauucagaggaggaugaagaccauuuuggaggaagaaaagcacccuuauuaagaauugcagcaaguaagccaacaaggucuuuucag\n", + "acccggcgacaggaggcaugapcccccggccgaaaugacagugcuggcgccagccuggagcccaaca\n", + "cacccgcuccccugcagaccuaucuccuccugcugcugcugcugagcucpacucagupacccaggacugcuccuuccaacacagccccaucuccuccgacuucgcugucaaaauccgugagcug\n", + "aaaaauuuccuuucacuuucggucucuggcugucacccggcuuggccccuuccacacccaacupcaagccug\n", + "pcaugapuccgagacuuguucuucugucccuuccaagacccggcgacaggaggcaugapcccccggccgaa\n", + "gacccggcgacaggaggcaugapcccccggccgaaaugacagugcuggcgccagccuggagcccaaca\n", + "ccuuucacuuucggucucuggcugucacccggcuuggccccuuccacacccaacupcaagccug\n", + "gucugauuaccugcuccgcgaggccgcggacacgugcggagagccgacugacacucgcagcccccucpaggcccgacgcgacupccccucag\n", + "cuccacccaggaaccuagucggcaccgcgcapaaucccagcagcpuucuggccccagcacgcguugcggcagccuggcgagcguccuugcggccuccaagugccggup\n", + "ggucuccucuucacuacucuguguccugugcuccuacaggcccagccucuguggcccugugaccugcagguauupagauccacagcuaagacaccaggaccccuggaagccuagaa\n", + "gccuuggugagccguuggcgugguggucccggagugauccuggcagccggupaagacaaggagg\n", + "gcgcgccuuggugagccguuggcgugguggucccggagugauccuggcagccggupaagacaaggagg\n", + "cauuauaaugucaugaugacaacauuuugugagagaagucuguauaaaaagcaauugcucuuuuguuuccaaaacagguauuacaaguggauaaaua\n", + "guuggacaggcucuuucucuaagagupuauucacugcapugacuuucugauucucuggaaacaaccauguguuccuuaucccuauugcggaacaccccggacaaccgcagcac\n", + "uaauapuguagguaaaguuacugaacagccacaucucacuuucaggaaaguaguggaagagauugugucuugagaagacaggcauuuuagag\n", + "gacucccagcuggccgapcpaapcaggcapaagcggcccgcccuucguccugccccuucgcccuacucugucaccuccgcuggaaggaguggaacccagacuugcuggucugaucc\n", + "gcugugaagcuucauggagguaucgauauccuagucuccaaugcugcugucaacccuuucuuuggaagccua\n", + "gcagagcccagcagaucccugcggcguucgcgapupacpaagcpcupaagucpccgag\n", + "cuuuccuuuccucggcguccggcpcucccgcggcggccaggccugcgccgcccgccaacapacgcgccgcggcg\n", + "cuccauuuguaaaggucuuaauaacaagaacagugacuucggcuccggagcuucaagauaguggccugcuuggccugcccaucucggaucucuccaggaggacccagccacccaag\n", + "ugccguguucacugccugguaucuuaguguggaccgaagccuaaggacccugaaaacagcugcagaugaag\n", + "cucuuuggccaagcccugccucuguacagccucgaguggacagccagaggcugcagcuggagcccagagcccaag\n", + "gacupccpucugcapcucagcugagcccaugagcucccagagcuaaccccugaacacccaggcpcaaapcugaugucgguaguccccauccuggapcag\n", + "ccccacuccaucucuuuggcuccgcaugcuccucccuguggcaggcucugcgcaucugcuccuggc\n", + "ugguuccucuggagauuaaauguacuucacagaaccucagcgagcggacuccaguuauauuccgugcucuugucggcacgcauuucacuucuag\n", + "apcaaggaguuggugcacaccuacaapcugcaucaggucccaggacugcuacuccggcguuauauccaccacc\n", + "ggugaaugupuccagacccaccccuccucagcuuccuauaaaagcupaccagguacugcugauacacacacc\n", + "aggagapaagagagagaaggagapaaucccaguucuugcagccacupaaucaagaggcccaacuccgucuuggucuucaagcaaacaaacaaacaacaaupccgupaag\n", + "cccgaagcggaagugcuuguupccaggcuuuguaacggucuccugagcagcgagcagaaaaucuguuaucgagagaga\n", + "agugcuuguupccaggcuuuguaacggucuccugagcagcgagcagaaaaucuguuaucgagagagagugag\n", + "pauuggaagaccuapagguccccuucauucugagaaaagaapucucuugaagacuaaaaag\n", + "guuguaguggaggagguggaaugaagagugagaaagcugucuaggugccuguccaauuapcaguaggaagaauccugauggccaggcag\n", + "guaguggaggagguggaaugaagagugagaaagcugucuaggugccuguccaauuapcaguaggaagaauccug\n", + "gucgcuaggaaacgagcgagcccgacgccapcggagcucuggccuccucgccgaguupaggcaggugcgacag\n", + "agucgcuaggaaacgagcgagcccgacgccapcggagcucuggccuccucgccgaguupaggcaggugcgacag\n", + "aguuuuguuucuuuuccaggcacccagcaacggcggccuccaggccucaggcccccucaccauccuagaggucaagaucagcucuggcuag\n", + "gcucccgcuggugucccuggagcaupaggcugcugagcgugaguggcggugucuggcaggagcugcguggcapapcgucc\n", + "uccugcagccgccgccgcugcaguggucgucccugcccuccccggccccpugcaccccgcaag\n", + "cccuuccucgugcucggcguugagcuccugcagccgccgccgcugcaguggucgucccugcccuccccggccccpugcaccccgcaag\n", + "agaaagcapcugcauggugupaugcugcugcuacucauuccugcucauuccaguguucuggaaaaugag\n", + "guggacgucugauuuaugaagcuccccauccaccuaucugaguaccugacuucucaggacugacaccuacagcaucag\n", + "guacacagcuucuccuagcaugacuucgaucugaucagcaaacaagaaaauuugucucccguaguucupcguguucaccaccuacaaccacagagcuguc\n", + "ggaacagcuccugcccaggucugupcacucagcauggauuucagucucccugugagugaupaaagaacuaacagag\n", + "agacuacagugucuugcuuucugcaggaagcagcaaugccguuuguuuccuaagaggaauuuuuuauuuagaaaaggaagcuuucuauccaggaa\n", + "cucaaaaccaguuaguuccagagaaguucagagacacuugaaguuugucuagauaguuuucuacagaugucuuugcaag\n", + "acauuucccagaagccccuupcaguguugccuggaccccaapcccuuuacauugcguucuuaacgguucagucaccuuaaccguuauuauucacuugcpcgagaaguccgagcuag\n", + "gaaauggaaacauugcuuugcuuuuccugaauuguccagugaccuaucccaggccuuccuuuccagugaacaauggacc\n", + "aguguugccuggaccccaapcccuuuacauugcguucuuaacgguucagucaccuuaaccguuauuauucacuugcpcgagaaguccgagcuag\n", + "auuucccagaagccccuupcaguguugccuggaccccaapcccuuuacauugcguucuuaacgguucagucaccuuaaccguuauuauucacuugcpcgagaaguccgagcuag\n", + "guugccuggaccccaapcccuuuacauugcguucuuaacgguucagucaccuuaaccguuauuauucacuugcpcgagaaguccgagcuag\n", + "pcagagcucggccgcugcggaggacaaggaacucucccucucccacuagucugacuucuuccaaa\n", + "gagugaggacgcaugcgcgagaggacccgccpuucagcgucucugcuccccagucugugugguuucccccug\n", + "acuucugcgcugacccapcuggagcgaaucccagaccagcucggcuaccugguacugagugaaggugcagugcuggcg\n", + "ucaucupaccuggagaaugaugagcaggcagccagugccaucucugagcuggucagcacagccugcgguuuccggcugcaccgcggc\n", + "acuguaguaguagcuggaaagagaaaucugugacuccaauuagccaguuccugcagaccuugugaggacuagaggaaga\n", + "aguugaaaacuuacagaguccugaggcuuucagacugaaaaaggcuuucuucugucacugacaaucgccacc\n", + "ggapccuuuugguugaauggaacugaauaucgcugcuuuuguuuuuagaguugaaaacuuacagaguccugaggcuuucagacugaaaaaggcuuucuucugucacugacaaucgccacc\n", + "gauuauuuuggagucuguucagagccagugaucaaagacaauguaguugugguuuaugagguauuggaagag\n", + "aggagupcgcgcgapucpcpucucaggaugcagccpcggccucucapcugcggacgcggcpagag\n", + "ggugaacgugguguucguagaccgcucaggccagcggaucccagugaguggcagagucpacaauguucuucaccuggcccagcgccacpuggaccuggaag\n", + "pccugugaagccucccuggccugcuccaccugccauguguaugugagugaagaccaccuggaucuccugccuccucccgaggagag\n", + "gcucggcgcagccgcucaccgaaccguguuuuccaggcucgcgcccggcuggagaggaggacgcpcggcccggagcggcccpacgu\n", + "cuccuucagcccaggcaaggccupcccupcagccuccaggugcagugcccucccgupccgcacccuugccacugccccapc\n", + "gaagaucgguagauugaguggcuagagaggucggagguaaguggcuauagaagucpcggacccggaacccagaggacgcgacacc\n", + "aagaucgguagauugaguggcuagagaggucggagguaaguggcuauagaagucpcggacccggaacccagaggacgcgacacc\n", + "gcagagcugcagagcpaucucuucgagcugucuguguccpcagccggcgcgcaacugagccagaggacagcgcauccuuucggcgcpccggcapccccugcggucggcaag\n", + "gagagcauugaugaggucaggaagccuccuguupuagaggagcaacuaagagacugaacuuggcccccacccugaggcucacaa\n", + "gcuugaauugcaccugaguuccaaaggagaaguugacauucuuccagaacauaugcccagugucuucaacuugagauggagcupaugccaagucugcaaau\n", + "gcuauaagacaccucuccccacccccagcccuggccgcuuggcuggaggcucugcgaggacagcupagaapagcugug\n", + "gcucuuuaapucacccagagacucuggagaaguuugacaaguucaagcaccugaagucagaggacgag\n", + "aaaccccagcuguupccaggacacccagugagcccauacuugcucuuuuugucuucuucagacugcgcc\n", + "gagaacccgaguguguguaugcgugugcgugugugagcgcgagcgagcgagagagaggagcgagagagugugagcgagaaagaauaaaaggaaagaagauuuucucu\n", + "agagaaaccgapagagaacccgaguguguguaugcgugugcgugugugagcgcgagcgagcgagagagaggagcgagagagugugagcgagaaagaauaaaaggaaagaagauuuucucu\n", + "gcugcgccuuccucaccuacugcgagcgugagucagcgcugaaggcccagagcgcgcugcacgagcagaagacucugcccp\n", + "uuggaagcaagaauuggauaagacuucucaggcgucugcacaaucccuaauggcccccagaucugccaaggagaccuucaggauaaacccaaauguagcagcaaauuu\n", + "gugcugagaacugcucucucugaccpucuccuguuucuaccugguuuguugugaaccuguguucuccacauuuguccugacucuucag\n", + "gaggaggacacuucucagaapuuguuuugcuuuugcuuauuuccguccauuucccucucugcgcgcggaccuuccuuuuccagaug\n", + "ggcggcggccaagagcapaagguggaucucagguagcgagucupcuucpacggcpapagccggacpagg\n", + "guaagaaucaggccuuauuggagacauucaagcaaagguuggacaacuacuuuuccagaacagaaaggaaacucaugcaucagaaaag\n", + "gcucuacagucucauccaagacuugaagagcucccgacuuguaauacuacuuguguuuaccapacuguugacacugcuucgcuuccgaagaccguuapacgupauuag\n", + "guucuuucccaucuggcggccgcggcuccuguccagacccugacccucccucccaaggcucaaccgucccccaacaacccccagccuuguacugaugucggaugcgagagccugugcuuaa\n", + "cuguccagacccugacccucccucccaaggcucaaccgucccccaacaacccccagccuuguacugaugucggaugcgagagccugugcuuaa\n", + "uggcggccgcggcuccuguccagacccugacccucccucccaaggcucaaccgucccccaacaacccccagccuuguacugaugucggaugcgagagccugugcuuaa\n", + "cucuggccuugaaaggcaucgacuacgagacggugcccaucaaucucauaaaggaupccaacag\n", + "ugauucgucgagucucacugagccuuagucgucggcaggucccaggcgcgaaguuucucggccuggaggapucgcgcgaagugccagaugcaggcpaag\n", + "acucuggcaccaguuugcugaagcuccagaccgcccagcuguucugupagcaucccaggaaccggaggcagcuacc\n", + "agauuacacccacgacggugcpucucpcguucuggagauacguapugaauuuauguuuccgacgauugcaucuggap\n", + "cucuugagaucuguggccugaaaggcgcuggaagcagagccugugagugugguccccgucaccagagccccaacccaccgccgcc\n", + "gugugugugugaucgcgcauguaugcpcaucugupuaagagugupugcacgcaccpaugucugucucgccgcaaagaucp\n", + "aacaaaccccacacaccccacuccagcuccggagcacccgugcupcugcaupacuggccggapcapccapagcpuaggcagagcuucpaggagaugag\n", + "gaugcaacuuucccuuuaagaaagccaccupcgcaccgcggugcggacccagcacgccupccpcugcagcaug\n", + "cucuugagaucuguggccugaaaggcgcuggaagcagagccugugagugugguccccgucaccagagccccaacccaccgccgccaugguaggaaaaggugccaaapaugcug\n", + "gauggaccccggcgacgccgccauuuuggagucuucccuaaggauccucuaccggcuuuucgagucagugcugccgccgcugcccgcggcuuugcagagcagg\n", + "auuuuggagucuucccuaaggauccucuaccggcuuuucgagucagugcugccgccgcugcccgcggcuuugcagagcagg\n", + "aaggcuccucagccgagcgccgagcggucgaucgccguagcucccgcagccugcgaucuccagucuguggcuccuaccagccauugu\n", + "ggcaguuaacugccaccaaguggugguuguaugccauagcucuguaacaugaacaguguuuccaauaaacuguccaccgcaaaaccc\n", + "guuaaaaaaugagugagcuccaugagcugaggagcuagcagauugccpauuacaaagacaacgagacaggacccuuuccuuagcaggauuuacaaucu\n", + "uuggcaguuaacugccaccaaguggugguuguaugccauagcucuguaacaugaacaguguuuccaauaaacuguccaccgcaaaaccc\n", + "aaagcuuuuaacccgacggcucapaggacaccgguagcaggacuagaagcagcacaguggaaa\n", + "gcuccugcaaggaaugugaaucuuggagcucccagcuauucuguuccuguuucugucagcuccuucccugaaaacucagaggugcucagcaugccaugcuaaaaggcaaaauaaaaag\n", + "ggupcupucggcggcuggagcauuaccccuacugcpucccgcugcuggcagcgcuggaaacupuggacggc\n", + "cupucggcggcuggagcauuaccccuacugcpucccgcugcuggcagcgcuggaaacupuggacggc\n", + "agagccggaagacccucucuuucgcuguuugagagucucucggcucaaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgcc\n", + "uuugaggugguaucaacauccuacagaagaagaauuaagaauucuugcapaaacaacaaaaapaaaaccaaaaaagauag\n", + "gaaauauaauggucacauugaaaguaagccauuaaccauuccaaaggauauugaccuucaucuagaaacaaagucaguuacagaaguggauacuuuag\n", + "cauugcauuacuuuccagaauaccaguggcugguggauuucacaguggcugcuacaguuguguaucuaguaacugaagucuacuacaauuuu\n", + "gcuguuugagagucucucggcucaaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgccaug\n", + "ggcagagccggaagacccucucuuucgcuguuugagagucucucggcucaaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgccaug\n", + "cucuuucgcuguuugagagucucucggcucaaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgccaug\n", + "ucucuuucgcuguuugagagucucucggcucaaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgcc\n", + "uuuuaugaagccuacacaggaaaugaauaucagcuuagucuggugccuacuuguuuugucuuuugcaau\n", + "aaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgcc\n", + "guuugagagucucucggcucaaggaccpagguaagagguuupacugccccggcaacuccapugucugguccacgaccuauccuaggcgcc\n", + "gagccgcauccugucuugguggcugcugcuggccpaggaggcugaugaauacagagccguggaacaggucgugccggagauggaaacaggaaagccuguuguuuugucgucccag\n", + "aacccauuaaaagagccaguaaauccuguggaaaauggccuucagugaucuuacaucgaggacugugcaucuuuaugauaauuggaucaaagaugcug\n", + "cuucuucauuucauuaguacuuggaaucuuaaagauguacucuuugagccaguaccugcuacuuaagaagagaauacucucuuagaagcagcug\n", + "agucggcggccpacagcpccgcugugaggagcuccgcgcucgcgcugccagucgccgcccucucucccgcgcgcgcccggcgcuucggcuccgcucccugugcg\n", + "auuauaaacucauuucuguuuuauuuuacugaagaacccauuaaaagagccaguaaauccuguggaaa\n", + "aacccagucggcggccpacagcpccgcugugaggagcuccgcgcucgcgcugccagucgccgcccucucucccgcgcgcgcccggcgcuucggcuccgcucccugugcg\n", + "aaagugcuugcaauugcauagagcaaagagcaugcugaacagugauguuccaguuuaaaaggacagagcugcaaacaaag\n", + "gacuuuggacuupccggaacuacacaucagcucuccupccucuagcuugccaacuacggacacugugacuuuucagccaucacaauugu\n", + "gaggagcagcugguugauccaggagagacapaggcgcugagaugagaugagcucucucccuuauguggagaaguccuuuuaggaaucugccauguuuaaau\n", + "gaggauccuccagccggagucagcpcuccguccgagaacaacauaaugguguggaacgcggucauuuucgg\n", + "gaacauuuaaacuuacaauagaauucacugaagaauauccaaauaaaccaccuacaguuagauuugucucuaag\n", + "acucagugacuggaagcagcgcgcuacpcgcuccggaccgccggagaaagaaacgapugucuucccagagcggcaguuuucgugaaug\n", + "acacggugacagaacugaacuugcccaugucuuugguccguuuggucaucaucaccuggaguggcaggcaagaagaagucaguccgguucaccaaaacaggauccaugagcc\n", + "acucgaccgcgcggcucacpugcccugugaccccacagcggagcucgcggcggcugccacccggccccgccggcc\n", + "ccgccagcaaaccucpccaggaccggcgcucacucgaccgcgcggcucacpugcccugugaccccacagcggagcucgcggcggcugccacccggccccgccggcc\n", + "gacugagccaaggcccaggugauauagaaauaaacaagaggcuaggcgugguggcucacaccuguaaucccagcacuupaaggccaag\n", + "ggucucgcucuguugcucgagcuggagugugguagcaccaucguggcucacugcagccuugaccuccccuggaucaagcgauccuccuaccucagccucccaaguggcupaccaauag\n", + "auggaaagucguggagucaccaggccggaagugccguggaggaaacucacuccaaucugcugcaugaagagaggauucucugagacugagcaag\n", + "cuggaggcuguggcgcgcggccggcagapapagaggccacupccguguuagucugccggupacucuugcag\n", + "agucugccggupacucuugcagguacaggcgcggucpcuccucguggagagccpcuccugccggccucugacupugucguugcapccgucccc\n", + "agaaaagcuucauucuggapaaggaguuuugagugccaaggaugaaauuccacccaucacucggucucugagcugcaggacacaggcaggacaacg\n", + "pcucuuccucgcggaagupaggaggcgguugcgguuaguggaccpaccgguapugcuguugccauc\n", + "ccuuucugagaaaagucuacagcauucuuucucugcagguucucuuaacuacagugacuucaacaguuuuuuuauacuuugagucuguacggacauuuguacaugagag\n", + "uccugccuuaauuuugcuguuugcccucggaucucupuuugauuuuugcguugauuuuaaacagacauaaguauccccuuaaccuguaccuacuuuuuggauuu\n", + "uuacuuucuaugauguauauauuauucugcaagcuuucauacugacuacuacaguauuuuuugguuugacuguguauacucuacaaucuaagaaggauuucagcaaauuuggagcagg\n", + "cccggcggcggccggcugupcugcagcacgcggugcacgaggcagagcccacaagccaaagacggagupccgagcauuccggccacgccuuccgcg\n", + "ucucccaggcccccugcaggcccucgugcccuccuuacuucccccccpucucccagcgcccccugcpcccuccucccuuccucauccacuucaaccccaag\n", + "ggcugcagcacgcggugcacgaggcagagcccacaagccaaagacggagupccgagcauuccggccacgccuuccgcg\n", + "cucgaggaagagcaggagaagaaccaguuauuggcugaaagaacaaaggagcagcucuuuuuuguggaaaca\n", + "acucucgcgccagcccggcggcggccggcugupcugcagcacgcggugcacgaggcagagcccacaagccaaagacggagupccgagcauuccggccacgccuuccgcg\n", + "guuucuguggaucccuucugaaguucuaucugaaaauugcgcuuaagugaauuuucuguuagaagaacuugguugcuacuuucuugucaag\n", + "pcapacauuaggaaacagaaagcucuguuuugguucuuggagccuuucaacgugaccacaauuaucugacuuuaaaugaagacaguucugcauguccauuacag\n", + "uuucucuccaggcagcaguggauggugcapaaagaggupaaggagguccupapacacuggaugucuuaccccaagcupccuugcaguaccuguggcuggcugugcugguugagcccg\n", + "aaucgaccacggaaauuugacaccuccpcuuggaagcagcucucuccuccuuccccgcugcuuauaaaccucagcccugaggcuccagcucacucuaccccaucuccuugccgg\n", + "gcupaggagcgguuagagugugugupcggaugcgaguggccggagaccapcccaacauaaacaagcuuuggagacaaacaaccuuaugaccu\n", + "gcggcgccugcuuggcgcgacgcucuagcgguuaccgcugcpcuggcupcguagupcugcgcggcugccacggagcuagagg\n", + "cuuggcgcgacgcucuagcgguuaccgcugcpcuggcupcguagupcugcgcggcugccacggagcuagapcaa\n", + "gupauuuauuugagugcaagaucguuuucucaguggugguggaaguugccucaucgcaggcagauguupcuuuguccgaacagcuccccucugccagcuucuguagauaag\n", + "ggcaauugccgcggcacugugcaggugccupcuugacgcpugcugcucacccgcuguacaagaaggcggaucuuugcucuguaucuucucuauccguuugcaguc\n", + "acugugcaggugccupcuugacgcpugcugcucacccgcuguacaagaaggcggaucuuugcucuguaucuucucuauccguuugcaguc\n", + "auuuaagcaucuaucauggcapuaaacgaggcaguuuaucuggcaccuccauuuugcuuguugcuaccuuu\n", + "ggcaaaucggaggucuugcuugcccagccuccpagccpccgapccpacugucugapaggacugugacagccgcccggccccaggaguuuaagagccggcpaagagguggcg\n", + "aaaaacucaguauucggccaggcgcgguggcucacgccuguaauuccagcacuuupaggccgaggcpcggaucaccugaggucaggaguuugagaccaaccuggccaacaug\n", + "cacucaccacagcagugcccagauccccgacacaauggagugagcgaaggagacgagcagguugugccagcgccag\n", + "gauugugcaccugugccugcgaaaggcugaccagaagcuggugaucaucaagcagauuccaguggaacag\n", + "acaauggagugagcgaaggagacgagcagguugugccagcgccaggugcgcapucggcgcgcacgugcacgg\n", + "gccucagagaauaaauaggagacuaagaggacaggcagacaaacaggacgagccupcuccaggccuggacggaggaagaagccagcuau\n", + "gagcugagcagaggcaccaggcccugcuccauggagccuucagucuccupaagcugugccugucuggcucuggcacugaccacauccucucggccauuucugaa\n", + "uuccgaaucccugaccccgcacuggagccccacuucccacagccccggaacggagcccuugaccuccacugaccagaccuuggagcccccuggcccag\n", + "cuagcugacuugcucccucccpcugcggcugcugcaaaagccagcagcggcagcpagcuguccggaggccggcgucgaggugagacccpcagacugaggcugcgg\n", + "gaggccauggupuggaugcggcugcggaaaggcupaguccgagcccuaggacupagcagcgag\n", + "acacpagaggagaagapagacccgccgccucccucccucccuagcugacuugcucccucccpcugcggcugcugcaaaagccagcagcggcagcpagcuguccggaggccggcgucgag\n", + "ugacgccpcggacugcacpaaugcpugucuggapcuggugguggugcupcpcugaaccaucpaggaggcgccagcccaccgaag\n", + "acaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "gaugccuucgugaagaucgugaggcacgapcaccaggacccucuggagcggccuccccgccacccu\n", + "gaggugcgcaguggacacgugcgagguggacgapaaggacccuggcuccuacugcauucgagcgauag\n", + "uuucggcgucggccuaggugcgcugcgagcgcgcgcggaccgcgcacaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "cggccuaggugcgcugcgagcgcgcgcggaccgcgcacaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "ggcgucggccuaggugcgcugcgagcgcgcgcggaccgcgcacaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "gcgucggccuaggugcgcugcgagcgcgcgcggaccgcgcacaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "ugcgcugcgagcgcgcgcggaccgcgcacaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "ugcuuucggcgucggccuaggugcgcugcgagcgcgcgcggaccgcgcacaggcggcggagccgguaupcccgccugacccupcgccgcgccgcacgagcaccagccuagagccag\n", + "agucucagccgacacugcgcgcgccuccaggcaccggcguuagcpucgccgacccgcaauccccgccgcggcugcuugccuaccggagugugcgccggcaccugccgccggagac\n", + "gugguauaaguugaaauccaaaccaggaaagaaggacaaggagcgaggagaaauugagguugacauccaguuu\n", + "cuugaccucugacccgccgaccacgcuugauccccggccgcpccaggaagucggaguuugagccccggaggcagagcggcugcc\n", + "cucugacccgccgaccacgcuugauccccggccgcpccaggaagucggaguuugagccccggaggcagagcggcugcc\n", + "cguguuucaagccgapacccucugacuuucaccucuguccuucagacagcaccagcaucccaucccugagccuccuguuccacucpapcuuuaggaaggaggcgaagucag\n", + "ggcggccucapccapaaaaccgucugccuggaagaggccpcaaacguggucgcgcugugccuagcccgcgugugagcgagcagccgupcagcgguggagc\n", + "uagcucagaggccccacuggacccucggcucuuccuuggacuucuuguguguucugugagcuucgcuggauucapucuupcaucagaggugagapupaag\n", + "acugcccucuccccgucucuagcucagaggccccacuggacccucggcucuuccuuggacuucuuguguguucugugagcuucgcuggauucapucuupcaucagag\n", + "acuaaccaggcagcucgcccagacuccpcagugagapapagcgccggccgcpagcp\n", + "guuccugucaapcagcagguccagagcugcuggugcucccguuccccagacccuaccccuauccccaguggagccggagugcpcgcgccccaccaccgcccucacc\n", + "gaagcggcagcgguuccugucaapcagcagguccagagcugcuggugcucccguuccccagacccuaccccuauccccaguggagccggagugcpcgcgccccaccaccgcccucaccaug\n", + "cauuuaaauucugcagcucagagauucacacagaagucuggacacaauucagaagagccacccagaaggagacaaca\n", + "ggacggaaguggaaacggaaaccuuuuuapaguccaagguacagucgccgcgugcggagcuuguuacugguuacuug\n", + "guggcccgccgguuucugagccuucugcccugcpacacggucugcacccugcccgcggccacggacc\n", + "gccaaauucagauaaucgacgccapuggcagagaaagauuggccaguaccaaugacaapaagu\n", + "ggagcaguuccggcuccgapcpcggaagaaggcpapapcggcaccgccggucggcuccagucgccuccggaggaaggaagaagaggacgccpcgcgcag\n", + "cucggugcugauuaucacaacuguuuggugaccuacuucacugaccugugaggauuccuucccuucagguacuggauucuugaucuuucugcaucaucaag\n", + "caucaugcuupcuaguggccccaucucaacauggcuacuuggaacagcuugagcugugugcugugacugaacuaaucugauuaaagugaccaagaaguccpcgcagugguucaugccu\n", + "cucggugcugauuaucacaacuguuuggugaccuacuucacugaccugugaggauuccuucccuucag\n", + "uggccpcucacgguguuugacccgucggucgugcgugagaggaaapaaggaggaggucccgaauagcggucgccgaa\n", + "cacgguguuugacccgucggucgugcgugagaggaaapaaggaggaggucccgaauagcggucgccgaa\n", + "pagcuggccpcucacgguguuugacccgucggucgugcgugagaggaaapaaggaggaggucccgaauagcggucgccgaa\n", + "gugugaagagacupagcuggccpcucacgguguuugacccgucggucgugcgugagaggaaapaaggaggaggucccgaauagcggucgccgaa\n", + "pagcuggccpcucacgguguuugacccgucggucgugcgugagaggaaapaaggaggaggucccgaauagcggucgccgaa\n", + "cuggaagcaaacagaggaggcaapuuguuucggacacacuagagaguaagucagagaaucuucguguugaggcagcauugcaaaauugaagaugaagaaaggaaggaag\n", + "gagucugagaaaacucuuuggugcuucugccuuuaguuuuaggacacauuuaugcagaugagcuuauaagagaccguucccuccgccuucuuccucagaggaaguuucuug\n", + "guauuaaaaagugucagcaaacugcauugaauaacagacauccuaagapauauuuuccaccucuaua\n", + "aggacacauuuaugcagaugagcuuauaagagaccguucccuccgccuucuuccucagaggaaguuucuug\n", + "guaauccuucagcucuggugguaapagaugcagugagcucccggcupagagapuuauuuugcaaaacuccccugguaccgugcccgcggaauauugcaggaggucugugag\n", + "auuugaaaaauuucuaguuucggagcuuagccacaggccggcuacgaucugcuuguucaucugagugucggcacaa\n", + "ggagcuuagccacaggccggcuacgaucugcuuguucaucugagugucggcacaagugagugucugcccgaacccagag\n", + "aaauacucaaaguccaaugaguaggauuuccucuccccuagauaguacuuggaupugcuuucc\n", + "aacupagcgcgccgcggcgguuccuguccuuacaguugcgcugcccapaccgauguugcgcgaggaaaaugcpacgcccag\n", + "ggccauuucugagcaguggagguuucaaguaauccacuaacaaccaguuccaaauucugucaucaaauccugugcugcuguuccucgug\n", + "guuaguggcpcugaagguaaacaggcuguuguguuuccucggugcuguuaguugcuguguggccgguagccaugugaugag\n", + "auugucccagugcuucgcauguuuuuggcuccauguucaauccauuugcugaacacagugaaaguauccaguaugucuuuccaccguacccuagaguuggcaucuuguuuaccagapagcg\n", + "aguggcpcugaagguaaacaggcuguuguguuuccucggugcuguuaguugcuguguggccgguagccaugugaugag\n", + "apuucccacgaacgccaaggcggccacguccugcucccccuggugaagaagcugcccupcuugucguccuapucuccagac\n", + "aguaugaagaguguaaagaccucauaaaauuuaugcugaggaaugagcgacaguucaaggaggagaagcuugcagagcagcugaagcaagcugaggagcucag\n", + "aaaaugacgaagaugaggaugaagauguucaaguugaggaggcugagaaaguacuggaaucaucugcccccag\n", + "aauaugaagagugcaaagaccucauaaaauuuaugcugaggaaugagcgacaguucaaggaggagaagcuugcagagcagcucaagcaagcugaggagcucag\n", + "aaaaugacaacgaugacgaugaagauguucaaguugagguggcugagaaagugcagaaaucaucugcccccag\n", + "aaauugaaaagaapaapaagaaaagaapaagaagaucaaagaaggaaagaagaapaagaaaagaapaagaagaucaaaacccaccaugccccag\n", + "uacuuucccaagcaccaccaggccaaaggucucucaguucagagcagaaagccguauacccagaggagcaggcagauaacagaaacuuccagaaaccucuguggagacaguggaagaggcaaaag\n", + "ucccugcaucccaugacucggagcugauggccuucaugacgaggaaguugupaccuggagcagcaggugaaggcccagacugaugagauacuguccaag\n", + "ccgaggcaacccugcagcggcaggaggaacuggagacgaugugugugcagcugcagcggcaggucapagauggag\n", + "guugcucaggccucccucaaacuagccaaugagaagugcacpuccuggucgccuaggaaaccgcgugacaacaagauggcggcgcugcpacggcuagcggcccugcgug\n", + "ggaguuccugacagcuggauucuagaaguagaacuaugagcucaccuuuggccucccuuagcaagacccgaaaagugccccugcccucggagccuaugaauccugg\n", + "ggucucacugucaccuuggcuggaguacagaggcgcaaucucagcucacugcaacuuccaccucccuggcucaagugaucucccaccuuagccucccaa\n", + "pagccggcggcgcugcpucagcggucgcguaggacccagcggacucggcagccupcgcccggcggagcugaaccgcggcccccgguggupcucagccggucgagcugcgcpag\n", + "gcpucagcggucgcguaggacccagcggacucggcagccupcgcccggcggagcugaaccgcggcccccgguggupcucagccggucgagcugcgcpag\n", + "gcggacucggcagccupcgcccggcggagcugaaccgcggcccccgguggupcucagccggucgagcugcgcpag\n", + "ggucuugcucuguugccuaggcuggagugcagugguacaagcacggcucacugcagccuugaccuccupaucaagg\n", + "guucupaaguucuggauuguuuaauaaccauggacuccaaguacagcagcaacagcaaaggaaucucucacuacaugaauac\n", + "ggacuacgagcgagcccauguuugcgcggcucugacccagcccuuaguccgcgaggauccccggcggcccggccguggcugcuccugcaguuucuaagagaupcpagcag\n", + "gugcgugcguugaccupaagcacuggaccugugaggcgugcgaacugguggcagugagagacuucggcggac\n", + "guugaccupaagcacuggaccugugaggcgugcgaacugguggcagugagagacuucggcggac\n", + "gaaucaccgcggaaaapcuccaguaggcaggacggcgccgucucucugccggcaaccuuugccccaaagcggacccucugcpaucggagapaugccccggcgugagg\n", + "gugcugcccaccaacccugaggagagcuggcagguguacagcucugcccaggacagcgapcagguguaucugcacaguggucgcuccacagcagacc\n", + "gucccggaaapaucuaugugauggagagugaugacacccccgugacagaguccgaccucagucgcgcacccauaaaaaug\n", + "guaaaucuuaaaaugagagagauaacagagaaagaaguuaaauuaaaacaacaguuauuggaaaguccagcucaucaaaag\n", + "gcccggcgcggcgapcggcggcgccuuuguugcggccpccgccgccucagcccuuugucugcag\n", + "aguuugaggccaacacuaggaagugucuggaaccggauccggaggcuucacaaucuauauguugccuccaaag\n", + "guguuggaaaucaauagcucuucuagccuuugcauuguuuaaauauaauagugucauuggacuaag\n", + "pcuccgacagaggcggcgauuguggcggcccauuuguaaaugcugcggagauugaggugucgguucgugcugcugagcugcccaggcuucacggagcg\n", + "upaccggccupuagcugcgcagcaggupucggucccpaugcagcgcpucagagagcgaccccaacapuagacg\n", + "gucugupuucuggcaccaccugagcccacupcaucuggucaucccuggcaccucuccuuuggagccaccuugucccuggcuagacagucacauuuuccagugccguuuuggaaag\n", + "cuccpcggcupaccggccupuagcugcgcagcaggupucggucccpaugcagcgcpucagagagcgaccccaacapuagacg\n", + "aucgcgcacupcuccpcggcupaccggccupuagcugcgcagcaggupucggucccpaugcagcgcpucagagagcgaccccaacapuagacg\n", + "agucucgcucugucacccaggcuggagugcaguggcaugaucucagcucacuacagccuccaccucccagguucaagcgauccuccugccucaggccuccugaguagcuggaauuacag\n", + "ggaagugugaccuuugaagauguggccguguacuucuccupaggaaupaucuccuugaugaggcucagaaacaccuguacuucgaugug\n", + "agcauuugucacucaaccucugaauguuagugacacuauupacgaaaaaggacugugcuggcccaa\n", + "gucgcugauuucuuggagccugaaaagaaaguaacacagcapaugaggacagauggugugagucaguga\n", + "gccuccuuuguccuggauuupaguugagcaccuucgucgccauuggcuuuccucccccagcuccagccucucucaucuupaaucugcgucagaagucacucgcagucccgucagcccag\n", + "accuguccagguucugccggccccagccggaagcuuacuccgcggauugugcacaguucuugaag\n", + "gacuugugcccupcugccuggcaucupccuccucagagccapcucuuucugguugaggcugagacucacuggugucaucaggccccucc\n", + "aguugcuaggcaaccacagcugcpcguggucugcgcpuugcccuccuguucugguuuaucapauccccaaagaaagcaapaccaaggccpacugcupugaag\n", + "gcuaggcaaccacagcugcpcguggucugcgcpuugcccuccuguucugguuuaucapauccccaaagaaagcaapaccaaggccpacugcupugaagguccpaggcuga\n", + "guggucugcgcpuugcccuccuguucugguuuaucapauccccaaagaaagcaapaccaaggccpacugcupugaagguccpaggcugaguaapacggaagg\n", + "aguuuuggccaguggucgugcaguccaapcuggauggcaugcuggacccaagcucagcucagcguccggacccaauaacaguuuuaccaapagcagcuuucuauccuggccacacugag\n", + "guugguagaggugcagcaauuuuugcagugaaacugaaguccagcugcucaaacagaaauggccucaucuaauggacacuuuaauga\n", + "ccuucucuggcupucuggccagcccuccaggagcgauccgucuguaguccccaggacccccuccagccpcaccacagcccagccacagcag\n", + "gcuugcgcgcgugagcugagccggupugagcggcggccacggcauccugugcugupcuacgaggaaag\n", + "gcgcgcgugagcugagccggupugagcggcggccacggcauccugugcugupcuacgaggaaag\n", + "acauucacguucugacugaaggacaaaaggaugagagagcagucugcguggcugccgccugcaacaccgcgagcccggcgcgaggaggagacg\n", + "aagucggaaupaacgaggugcccagcucccguggagaaagcuuaaggacaccacgccagugcuuuccugccuuccuuccgag\n", + "auggaaagaggagcuccuagcucacuuaagccpuapcugguucuccuuuccgagccaaaaucccaggcgauggugaauuaugaacgugccacacc\n", + "aaaacuaagaagucggaaupaacgaggugcccagcucccguggagaaagcuuaaggacaccacgccagugcuuuccugccuuccuuccgag\n", + "ugguccucpccggacggagcgccgccccgcgugccggcagccggcggacuggagaacugaccccccguuuuugucucuuccacccuccgagaagaggcgaggagaaap\n", + "gacccacagugaccacucuaggcuccuaugaggcuuccgapcugugagaggaagaapccaacgcupucccuggaacgacp\n", + "apuccuggaacagcpuucugaggaggcupaggcapcugagagguggccgagagagaggagucgcagagccgccaga\n", + "ugcucapaggcggaaggcggcggcpagcggucauggaggcpcgccggagccggcgcpagccgcpcuggagcugcccpcccag\n", + "agugcgccugcgcpuuuuauacucugcuauauguguguccgcugcuuuuaggcaaccagccgcugccccupccgcaaggcaggcuggaaacgauuccgccgucaggucccaaau\n", + "acuccuaugcuagccucuggcuccucapacacagccgaguggucggaccaaacgcaacgagucuucgccagcccaaaggcgacucgacaccgucccagcugaagagag\n", + "aguuacacucaacgcagcaagauguucacacuaggagaagccaaacaagaguacagaagauucaagucugccaucucaugcuaaaccuggagcauauccuuuga\n", + "gccpcggaccgcggcgguggcggcggcggcugcgauuggcucaggcgccccauccpacupcucggcgcugcucguucgcccuaaag\n", + "cuucuccagcaaucagagcgcucccccucacaucaguggcaugcuucauggagauaugcuccucucacugcccucugcaccagcaac\n", + "agagcgcucccccucacaucaguggcaugcuucauggagauaugcuccucucacugcccucugcaccagcaac\n", + "agugucaaacuugacaucagccugcgagcggagcaugguaacuucuccagcaaucagagcgcucccccucacaucaguggcaugcuucauggagauaugcuccucucacugcccucugcaccagcaac\n", + "gagcgguugaauucucuguuuugcugupugccagccucuaucagccccugcccugguccaucugucagcuucag\n", + "gcguuugucccaugcugguuccgugagucuggccuuaggugucucgugucupuugauccgagcugucgccgccgccgccgca\n", + "ugucccaugcugguuccgugagucuggccuuaggugucucgugucupuugauccgagcugucgccgccgccgccgca\n", + "cguuugucccaugcugguuccgugagucuggccuuaggugucucgugucupuugauccgagcugucgccgccgccgccgca\n", + "gugcguuugucccaugcugguuccgugagucuggccuuaggugucucgugucupuugauccgagcugucgccgccgccgccgca\n", + "acaguupccupaggcuccaggapugacagcagaguccuggcuuggagucpuuacaccacuugugucugaguucacgcagc\n", + "aacauugagcugaagguugaaguggagagcuugaaacgagaacuccaggacaagaaacagcaucuggauaaaacaug\n", + "gcagccucagcagcgucccagccggcuggcuucaugcugcggugcagcugcaccauguuccupuugapcaaucpcacgcuccuccccaupuugcccauc\n", + "agucccggaaaacaccaggaaaacaagcaggaaccguagcuaggacupuggccaggcccaggaaaucc\n", + "aggcuccupuggaguccaaaucacucauuguuugugaaagcugagcucacagcaaaacaagccacc\n", + "aucagcugccuuccccpcgucuccccgcaaccuccucaacuucccuagucagugacgcggcgccggccagaaauccgaccggaccpcucpagcgugaguugcag\n", + "gcggccgcgapacuccgacccagagcagugacuucgapcugacuuggagaagaggauggcauccgugaupcgauggcgcu\n", + "cucaacuucccuagucagugacgcggcgccggccagaaauccgaccggaccpcucpagcgugaguugcag\n", + "cccpcgucuccccgcaaccuccucaacuucccuagucagugacgcggcgccggccagaaauccgaccggaccpcucpagcgugaguugcag\n", + "gaacaaaggaacaguaaauggaguaacuuggcuagaauauggcaguaacuacaaggcauguucugcucuggcacgaag\n", + "cucaccugucugaaacpacacpucggaggaaccaggaucuagccuggccccaagcggaacucucugguggcccagaggucgucacupagcccgccuccugcccuagccucacuggugcgg\n", + "gacuugaccccggaagupugugaagcuccggugcuggugcggcpacugcpccagccucag\n", + "gaccccggaagupugugaagcuccggugcuggugcggcpacugcpccagccucagguaccuc\n", + "aaaauggaccguggauucccccguagcucccugguggcuagaaacuaggcpupuucucuuuugauccccaaauacagcaagcuuugg\n", + "gaaugugugaaggagaaauugaaucucuugcacgaauuucugcaaacagaaauaaagaaucaguuaugugacuuggaaaccaaauuacguaaagaagaauuauccgag\n", + "gcggccgcccupacgcagacgccaaggccccuccggccapccpagccpccggccuagccag\n", + "gcacgaauuucugcaaacagaaauaaagaaucaguuaugugacuuggaaaccaaauuacguaaagaagaauuauccgag\n", + "cccagccccagccgcggccgcccupacgcagacgccaaggccccuccggccapccpagccpccggccuagccag\n", + "ggucugacucugucacccaggcuggagugcagugacguaaucacagcucaccgcagccuugaccuccupcucaagccauccucccaccucaaucucccaaguagguggaacuacag\n", + "uggucuccuugcguugaagucccugaguaggaggucuguucaucuguccccucuucuuauuuccuccccuggcucuaag\n", + "uccuugcguugaagucccugaguaggaggucuguucaucuguccccucuucuuauuuccuccccuggcucuaag\n", + "cgaucuggcagcgccgcgaagacgagcggucaccggcgcccgacccgagcgcgcccagaggacggcpagccaagccgacccccgagcagcgccgcgcg\n", + "gaucuggcagcgccgcgaagacgagcggucaccggcgcccgacccgagcgcgcccagaggacggcpagccaagccgacccccgagcagcgccgcgcg\n", + "aagugugucccuagcggcggcccgugcagcgcucccgcgagacgcucaccugcgccccaggugagcggcgapcpapcugagccggaggcggcucaccuggcpacag\n", + "agaguaagauccuugauacuggcucagcauggaacaucuggcacacaguaugcacugaggaaauacuuguuggaauaaucagugaaucauagaugaaaacuuaaccuuggaauuaauuaugagacug\n", + "cccuuguucuaggcacuupauucaccaguauacaauggagacaaaaaucccugcccuggagcagcuuacauucuagcauggcaaacaggcaguaaaca\n", + "guuaccagaaaauuuaaaguuacgccagucacucccauucuauugcugagagaaaauacagagcggugaagagcuuacagucpugagcaagauacgccccca\n", + "agacgcgccuccaccgccpcagupcagguauggcugapcgugugagcgccgagcgcuaapccgccgccacc\n", + "uucauuuucagcaaauucgaagaaaagaggaauaauguaaaugaccccacapaaacagacaaacccugaauguggagcauuucacaggacaaaaccug\n", + "uuguggaguagacaguuggaagaaguacccaguccauuuggagaguuaaaacugugccuaacagagguguccucugacuuuucuucugcaagcucc\n", + "aaugcgcccgccguguccauggagagaagcugaggcggccgaccuucggcccgaggcaccpcgccpacggcgaag\n", + "guagguguaaaaguugguguccgaaccapcuguaauggccuuucuuauacucuagaauauacaaagacaaaaggagauucugaugaagaaguuauucaagaug\n", + "acacugacugaacagacuuuuagupuuaccuggcuaacagcagcagcggcaacggcagcagcagcagcagcagcagcagcagcagcagcapcuccupauaacucag\n", + "cupcuapccuucuuccgcugccgcgguacacccagagcuacccccgccucuccccpaggaggaaggacg\n", + "cccagaagcappaauccugaaucgagcugagapcuuccccgguucuccupaaccccaucggcccccugccagcacacaccugagcag\n", + "gugugugacucupuguaacgcgupcagcuapaugcugaugcuggagaapauccuggcaccuucugagg\n", + "gcagcagccuaacccagaagcappaauccugaaucgagcugagapcuuccccgguucuccupaaccccaucggcccccugccagcacacaccugagcag\n", + "aaacguuccuggauccgaacacugcccccugacgaccuagagagaucccggcucccagcccacugaguggcuucagccucgcug\n", + "ccugcgccucgccgucccccauucgcacacccgaugcccpucgcuacggacuuaaaaucuccgcaccgcacccuccaccucag\n", + "gcgccugccccpccccgccuacapacccagcucuucuugcagccacuggaagcugaucaccuggagugaagaccucacac\n", + "guacgguugacauuuapauguggccauagaauucucucaggaggaguggaaaugccuggacccugcucagaggaucuuauacapacgug\n", + "gcaccucccaacuccuggccucucugcacgaggcgccugccccpccccgccuacapacccagcucuucuugcagccacuggaagcugaucaccuggagugaagaccucacac\n", + "gugaaguguccugcagccaccuugugagguagauuguuaucugagcagacuuugacaacuugcccacagcuaauaa\n", + "ccuggcccagucacuaupcccuguucaccuccucucuggccaucucccugguguuugccgucauccccuucugccgcgacgugaaggugcuggccucaguc\n", + "guuaucugagcagacuuugacaacuugcccacagcuaauaagugagcagcuucuuccucagcucucuuccuuuucuaccagapagaaaugucuuggcugcccagaccacccaguga\n", + "aacuugcccacagcuaauaagugagcagcuucuuccucagcucucuuccuuuucuaccagapagaaaugucuuggcugcccagaccacccaguga\n", + "cuccccagcccggccggcccucccgcpcggcacucpcaccpcucgccpaccagauccgcgagcccgucagccugcgcc\n", + "ggcagcgcggagccgccgcpccpcccaucccgccgcagcggcccpccgagcapcuaggcpapagcggcgcccagcpcccggagcguggccag\n", + "gcggagccgccgcpccpcccaucccgccgcagcggcccpccgagcapcuaggcpapagcggcgcccagcpcccggagcguggccag\n", + "guccccgugacgaggcagcgcggagccgccgcpccpcccaucccgccgcagcggcccpccgagcapcuaggcpapagcggcgcccagcpcccggagcguggccag\n", + "agacaggucugcgacucuggucaacugcagcugcuuuccccggccuccaccgcugccgcacacccccuuugccuuuagcauuuuccuccucuccucuaauugcguggcguccccagaug\n", + "ggagccgccgcpccpcccaucccgccgcagcggcccpccgagcapcuaggcpapagcggcgcccagcpcccggagcguggccag\n", + "cuacaaugguugucuggcaagupacaapccgccggcgaagccgccuggcacugagccgccggucgcacgccaacpugaagccagacguc\n", + "gacpaaggagccgagcuupuuauggcggcgccpcgcgcugcuggugaupcgugagcggcucpaa\n", + "pcgcagapcacggcccucacugccccggccpcgagagcggcuccgccccucgagcgccpuaggccpccggcpcccggaaggcgacpaaggagccgagcuupuu\n", + "auauugguaucaacuugacugacccuauguucagaggaauuuauappuucaaaagcaucaag\n", + "gcccuuccggcuggccccgcucagucacccgcagcaggcgugcaguuucccggcucuccgcgcggccpaaggucagcgccgua\n", + "aggacgcugcagcugaaacguuccggcuccggcucugcuggccggucuaaagcggcagccgccpcgca\n", + "agcaugcauccggcuggaaacucaggacgcugcagcugaaacguuccggcuccggcucugcuggccggucuaaagcggcagccgccpcgca\n", + "acuuguaaucuaccuaacugcagagguggaugcaaacuugauaaaacguacauuuucauaagacugu\n", + "cgcccaggcgccuuggaauccccguccuupcccccgcaagguccccggccgugcgcgaggcagc\n", + "aggcucccggcggcugcuugcgccccagcgcgcgcccaggcgccuuggaauccccguccuupcccccgcaagguccccggccgugcgcgaggcagc\n", + "gcugcuugcgccccagcgcgcgcccaggcgccuuggaauccccguccuupcccccgcaagguccccggccgugcgcgaggcagc\n", + "gccccagcgcgcgcccaggcgccuuggaauccccguccuupcccccgcaagguccccggccgugcgcgaggcagc\n", + "gugagacucucgcgcuggccucuggagcgcpupcgucccgucacccugcgcccagcuuccccggcccguucccgcapccggccucccggcgcc\n", + "ccccaccagcugcuucpupcagccuucaggaggaapcuggccupaggagcuggcugccccucpacguguucucaggcccugcccgcugcccugccccauauaccuucuccuucgag\n", + "uucccagcagagcaccupuuggucccgaagccuccaaccaccugcacgccugccapccucucupcagcc\n", + "cuaccuuucccagcagagcaccupuuggucccgaagccuccaaccaccugcacgccugccapccucucupcagcc\n", + "ggugcugcgcggcggccgugauggcuggugacggcpccpcapaccpccgcggcccpagcpccagcugccpagcccugaaucaccgccuggcccgacuccacc\n", + "gcaaauaagcuuuacuacaaccauaucugaaauguguuuuccugaucaagupaupaaagaacagugaguggagucccaggcauguuaagaauggcgugcuguuuuuuaagug\n", + "uuugugaaguuugccaacaucgaggaggacaccccguccuaucaccggagcuaugacuucuuugugucccgauucagugaa\n", + "guguguguggcugcuguggugcccuacgccccagguacaaaaggcugguugacaacaucuucccugaggaucccgag\n", + "gaccuguaaguugccuaggacaguggccuggucccapcuguugupaguugaagaacacccuggccuccuccauc\n", + "cuguaaguugccuaggacaguggccuggucccapcuguugupaguugaagaacacccuggccuccuccauc\n", + "guugccuaggacaguggccuggucccapcuguugupaguugaagaacacccuggccuccuccauc\n", + "agugagauuuggacuuuagaugauccugguugauugauauaggaauggugcuucuccugagacag\n", + "agccuuuccugcccucaacaagugaggugapcupagucccggcuggaacuacccaauguagccuuuggagcuccacugcuguuugugccag\n", + "ggcgugaagaauuucccucuucuccugugcuuucaucuaaaaguucucccuggauaauuaucauugcaguggagugccuggauuggacauccucaucupucaacuaaaaaaagaaag\n", + "ugaagacucccuguauucccaguccuaagcaapagcaaaggcapacagagcccugcugcucag\n", + "augcgcgcgaggugcgcaggcucgcgccuuuuucccuuuucuaagcuuucuguguuacccccgguuccgcugucuuuucugucuacaguuugcgauccccgcguccagg\n", + "gacccggaagccgccguggccgccgcacaagcugcgcucgucucucggcupagcuccgugucgcaccpuucuupcuggccguguccuucucccucggucgccacuggccc\n", + "gcuuucuggcucaucugcuggaggaauccuugcugcpuguuuucauuuucucgucuaacauggcagugguccauugcagcagagguuuuuagcuuaaacaaucucuuugupcugcuu\n", + "aagcugcgcucgucucucggcupagcuccgugucgcaccpuucuupcuggccguguccuucucccucggucgccacuggccc\n", + "cucggcupagcuccgugucgcaccpuucuupcuggccguguccuucucccucggucgccacuggccc\n", + "agcacaguugagucuccagccuugacucuucucaagagccugugacuuuccucccuggacaaaggcauc\n", + "gagapcapcggagcuggapugguucggcgupccguuggcuccagacaaauaaac\n", + "aaaugaaagaucauuuauaugcaauuauaaggaacacugguuuacaguuagaaaauuaggaaaacag\n", + "ugguuuaacuugaauucucucuugacpuccagaauuaauaucagauacauaucuugcacuuuucuuggcucaauuacaacaggaag\n", + "guauauugaagcaagucaaagauuacauuaaacaguguagcaaaugccaggagaaacuagaucgaucccguccaauaucagauguuucagaa\n", + "gapaaggapapaagcagccgcugacccguggcaugagcuggaugcgguguccguugcaggacuapcgccgac\n", + "cauaaaucagcacgcggccggagaaccccgcaaucucugcgcccacaaaauacaccgacgaugcccgaucuacuuuaapcugaaacccacpccugagagacuauaagagcguucccuaccgcc\n", + "cauguuaagagcaagaaggcuuuuguucuuggagcaggcagagaguauuguacauucuuuuggccgaggaaacagaaugagcugcgacagucuuaaggacaaacauuugug\n", + "uuacaaggaucacapuugguacaaguugcuugauaaucugcagcauucucucugagauuuagcugccauuguguugccaaauuucugcaugucagu\n", + "guggccaccgaguacuaaauucacuupaauaaaagaaaaacauaagaaaauuauaagagaaag\n", + "gaauugucuuagaagaaagaaggcaagccaccauuuuacccacguaaauauaugaauauauuucugacauugagguguuccagaagaugauaaagaa\n", + "ggcccaaaauggagaacgcggagcagcgcaagauggaggcuccgcuucucuguguagcaguagauuuagguuccuuuucuccggcaggcuccuaagccuaggagagcccgaacuggag\n", + "uuuupuuacccagcugaagucaaaugguauuaagcacauuugaagauacucugaauuuguuaau\n", + "uccccucgacaccccacuaaagacagaagaaccgcggcucgaucpuccgcggcggaagcgcggccaaacgaauga\n", + "agugcugcuuuucauucccacccccacccgcacugucuuucucaaggcacgaacugagcugauccuugccccag\n", + "puggcccaaaauggagaacgcggagcagcgcaagauggaggcuccgcuucucuguguagcaguagauuuagguuccuuuucuccggcaggcuccuaagccuaggagagcccgaacuggag\n", + "cgcguggupaacugcupaaggcgauuggcaucgaucucuccaucccuuccgaggcccgacuucg\n", + "uucaugugacpccccucugcuucucccccgccccaucaucuccagcgcguggupaacugcupaaggcgauuggcaucgaucucuccaucccuuccgaggcccgacuucg\n", + "gagguaaguuauaaaauggcggaggcgaagcuucuagaaguuuggapcacccggapcgcuuggcccaccgugag\n", + "auacauccagaaagugcccagaagaaacuuccugcuggaaaaaaugaaaaagcaguauuuauaacauuagaaucuggauaauuuguuaac\n", + "paaaugugguuucuccagccggcccpcgguggccgcaaguupcuuacagcgcggccgauccggcguggacccp\n", + "gugguuucuccagccggcccpcgguggccgcaaguupcuuacagcgcggccgauccggcguggacccp\n", + "accgucagcgcapcucgccpaaaugugguuucuccagccggcccpcgguggccgcaaguupcuuacagcgcggccgauccggcguggacccp\n", + "guucgcgcgacgaccgcpucggcpcpcgaggcccuggacggcggcggcagupcuccuccuucuguuucccagaccgagagccgcgccggcacc\n", + "aauaugccgaguuucuacauugcaaaggaaagaaauuuacagauuuugaugaaguucgccuugagauugaagcagaaacagaucgcgugacugga\n", + "cugcauccuacugcuauuuucauuuuaucgauggaauacuuugaagcacgaaaaaucauuauaucuugaaauaauuuuuaaaauaauccaauaacaaacucagaacuacugaagaauaauaaag\n", + "gacgucugcgccaggaccuggcuggcugagcccggcgcagcagcagcagccapcagcgcggccccuacucccugucaggucguagaggcgagcapaccagcuggucgccggccccucpcaag\n", + "ccucucggcuuucggcucggaggaggccaaggugcaacuuccuucggucgucccgaauccpuucauccgacaccagccgccuccacc\n", + "uuaagaugaucauaucaccugagagaguucccaagucuacaauugcucuacuaguuacuauucaguguuugugaaaaauuuuaaucucaguacugugaagaagcuggaaaaapauauu\n", + "auaucaccugagagaguucccaagucuacaauugcucuacuaguuacuauucaguguuugugaaaaauuuuaaucucaguacugugaagaagcuggaaaaapauauu\n", + "cacuguuggucaccgcaggccugucuuccuauucaccgupcagcagapauggcugcucagcugcugacugaugaggcacug\n", + "auuguccuggcagagcggcgagccggugaguguggcugcpucgcgcccacccucuaccugugccpccggaaccuggccccpapcgcggccucpagacggcgugcaggcccag\n", + "cgccuugacaggugaagucggcgcpapuapccaacggccuggacgccccaapcpcgcagaucgcggagcc\n", + "cuagaagccugcagcuccggagcaguggccgcgccacgccggccccagcgcgcagaacccugcaggccccgcccguccgccccpccgcgcccgcc\n", + "cgccuagaagccugcagcuccggagcaguggccgcgccacgccggccccagcgcgcagaacccugcaggccccgcccguccgccccpccgcgcccgcc\n", + "aggugcuccgccuggaaaugucuccauuaguugucgccggcuccccgcuggagcgcgcgcgccgagcuuccgcgcggagcccucgcpcugccpagcggcccagcgccaccgcag\n", + "cccagcgccuagaagccugcagcuccggagcaguggccgcgccacgccggccccagcgcgcagaacccugcaggccccgcccguccgccccpccgcgcccgcc\n", + "gcgcggccgccgapagcpcggcggcggcugcggcgacuccccggugcgucccpcugcgagcugcuccccgcggccccggcagccacacggcgcpcpagcuuccccagcucag\n", + "gugagcuccpauugccggcauucccgcuucugcugguugcuucaugcugcaggcugcggccgucagcccucgcucgcauugguggcgcugaggugccpcagcaagugac\n", + "auaacaaauugcuggaaaagucagaucuucauucaguguuggcccagaaacuacaggcugaaaagcaugacguaccaaacaggcacgagauaag\n", + "guguggaggugagcuccpauugccggcauucccgcuucugcugguugcuucaugcugcaggcugcggccgucagcccucgcucgcauugguggcgcugaggugccpcagcaagugac\n", + "uguguggaggugagcuccpauugccggcauucccgcuucugcugguugcuucaugcugcaggcugcggccgucagcccucgcucgcauugguggcgcugaggugccpcagcaagugac\n", + "guucagcauuucuacuccuuccaagaagagcagcaaagcugaaguagcagcagcagcaccagcagcaacagcaaaaaacaaac\n", + "cauuucuacuccuuccaagaagagcagcaaagcugaaguagcagcagcagcaccagcagcaacagcaaaaaacaaac\n", + "guaugaucucgugaaaucuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugagguuaaaap\n", + "ugucgcccagccugaagugcagucguguguuucaugcgcguccgugugaagagaccaccaaacaggcuuugu\n", + "guugauggacggauggcuacauggaugugauggagaugguuuacuaucpaccuuccgcacccugcug\n", + "cugucccuugcagcacucuucuggccuguguucccaapccucggccapuaggaugguacacac\n", + "gagacauuccucaauugcuuagacauauucugagccuacagcagaggaaccuccagucucagcacc\n", + "agaucugugagcccagcgcugacugcgccgcggagaaagccagupaacccagacccauaggagacccgcguccccgcucggccuggccaggccccgcgcu\n", + "agagccgcaggucupcugcaguaggucccggcaaccgcaggcucgcggcpcgcupcgcpauccgacucuagucgua\n", + "gcggacggugagupauggacuggaguugaagagcucgagaugaapcuugapcgugugu\n", + "guauccuaggaauaccugccugcuuagacccucuauaaaagcucugugcauccugccacugaggacuccgaagagguagcagucuucugaaag\n", + "ccucuguucccpucccucaggcggccacccagupcacacucccaggcggcgcuccggccccgcgcucccucccucugccuuucauucccagcugucaacauccuggaag\n", + "agccugcgucugccaaugauccaggagccgcuccuuuccacucpaaaccuucagaggagucucagaaaggacacggcuggcugcuuuucucagcgccgaagccgcgcc\n", + "gccagucucuucgcggcguccaccacuuagacgcaaguugcugaagccggccpagaagguguuguugccggagcugagaccpcggccacaguccgcap\n", + "acugaggaaaauccagaaagcuacacaacacugaapugaaauaaaaguccagcgauccagcgaaagaaaagagaagugacagaaacaacuuuaccuggacugaagauaaaagcacag\n", + "caacacugaapugaaauaaaaguccagcgauccagcgaaagaaaagagaagugacagaaacaacuuuaccuggacugaagauaaaagcacag\n", + "cuagcuauccuagaagacuaugcggacccguuugauguucaggagacuggcgaaggcucagcaggagcuucaggagccccagagaaggucccugaaaaugauggcuac\n", + "gaguugccaccupugcccaupcacugcaggcuagagcugaggaggcccacgccagccucggapucgcagcucupcaupcccaggacuugg\n", + "gcagugcuucaggcuucagcagccuuggagaagcaucagcugagaggagcuaucacaupagccpacugcucagcaaag\n", + "uguaaaaguuacauuuuaacuucuugacugauuuauacuggaugucaccaugagaaaugacagaaaggagcagcaacuggaaaacaagcauugcauugcaucagg\n", + "uuccaaagaacuacugguucagauuuuagcucuucccaaguugugaaaauagugaaggaugcuuagacuacuuaacauacaaacu\n", + "gugcupugcpugcpugcpuupccugcgcaucpugagacgcuggcugcuugcggcuaguggaugguaauugccugccucgcgcuagcaggaag\n", + "gaagguagagcaaaaaugauacaacacccaagaaucguacuagcuaccauuucucuuccugucuuuaucuuggaguucugucc\n", + "ggugcpugcpuupccugcgcaucpugagacgcuggcugcuugcggcuaguggaugguaauugccugccucgcgcuagcaggaag\n", + "guacaacuguaacugcuuuaagauuauuuaagaaucuaccuguaagaaagcaguuuuacucaacugcaaaaaaauguaaagaugaaauaaaaaagauccaagaucuccuc\n", + "gugcpuupccugcgcaucpugagacgcuggcugcuugcggcuaguggaugguaauugccugccucgcgcuagcaggaag\n", + "gcacaccuguuguccuuaacugacuuuccpucaucagcacuucuucagaaguguuccuuuucccucccagcaaauauggaagacugacuauccugauauucccagacauucuuugcugugauuu\n", + "gaucuauuuucaucugucauuauuauugccauuuguccuguuggucaggaaugcuuaacaauucuuacaaguugcauuuuuaucuucuagcugcucuguuaaaagcgaaa\n", + "gugacggcccugcucpaggcccuccagucucugagccagcggcuucpugcaggagcaggag\n", + "aguugcuupucuugcugucacuucpcuuccccagcgucauucuacgccccacguaacuccpccccucgauguuucccugcccccugcguuacuccpccucuucucgug\n", + "cucuccccggccguggcccccgcggcuuagacgccuccuccgccgccgccgcucggagcaacccpccgg\n", + "ccggccguggcccccgcggcuuagacgccuccuccgccgccgccgcucggagcaacccpccgg\n", + "ccgupaaaagacccccucuccagcccupcccuggaucucggaggagcaauuacaauuugg\n", + "gacucuuguugguguuucaupcagcaaaacuggcccuuuuuaucucagcuguagauccuugaag\n", + "agugcgccugcguggccgcgaaucaccagccagccucupucuguagcaaccgcccagcguugaggcgcggcuc\n", + "acuuuccaggacucapcagccacagcgacagccgcpcagcagccucaggagccggagcuggaacggccpcggcggcagcggcggcgcugagg\n", + "augcuacuggacuugaaugguuaauaaaauugcacaauguuguugguggcagugacuucuuucuguucag\n", + "aucccugcccgcagccccgcgcgccggccgagucgcugagccgcggcugccggacpacpaccggcuaggcupcgcgccccccpccccgccgupc\n", + "acauucuuuuaguucucuagcuugucgucucucccuccucuccccuaaggaugaaacaaaacaggcauguauagauucaaguuugg\n", + "aguuugcucuccaaagcucpaauugauuccagcucuguuaaacuccpuaguucucucuuc\n", + "gcagacacccagccacucugagcagaacugacagcaugaagguacpcccapucpacucauagc\n", + "agaugcgaaccuugauugagagugauaaucaacuuuguuuugauugaacugacauuuuuuucugugguuuuaucacuuuuuauuuuuuaupuguaua\n", + "agacapcaucacuguguugccaaggcuggucuugaacuggcucaagcaaucugcccaccucggucucccaaagugcupauuacaggagugagccacugcgcccugccug\n", + "acagagcuuaggacacagagcacaucaaaaguucccaaagapcuugcucucucuucaccugcucuguucuacagcacacuaccagaag\n", + "agguggagccugugcuggacuaccugaccuuucugccugcagaggugaaggagcagauucagaggacagucgccaccuccpaac\n", + "gacgcaagauggcggcuguggugcuggcggcgacgcgguugcugcpcucpuucuupcuguucgcggcugag\n", + "gcuggcpaaugugcgcacccccgcgcpccccgcccgagcaucccgcgccgacpcugugccggagcagcugugcagagcugcaggcgcgcguc\n", + "agcggcggugaugaagacaaaauugaacaucuacaacaugcaguuccugcuuuuuguuuucuuggugupacccugccag\n", + "guuggugcuggcuaacauccaagaagaugaggcuaaaaauaacauuaccaucuuuacgagaauucuugacagacuucuggaugguuacgauaaucggcuuagaccaggacupag\n", + "acaguauuacugaagucuucacuaacaucuacgugaccaguuuuggcccugucucagauacagau\n", + "aauucuaggucaagaaguaaaauauggcacagagcauugaaaggaggcaacggaugcccagugcaagauucugaagaagcaggaauucagcccg\n", + "cpuuagcpugcggcgagcugcpauupagcaacpccpccpccuucpcccgaggcggcggcggcgguauaaagccggcgacupagcaugua\n", + "gcggcugacguggagcguccpuuagcpugcggcgagcugcpauupagcaacpccpccpccuucpcccgaggcggcggcggcgguauaaagccggcgacupagcaugua\n", + "cuggccaacaapcugcagaggaugcacacaucaggaagapupacuacuugcuugcugguuuugcuugcaucugaugaguagaaauucagccuauucuuuguuuug\n", + "augguuucugaagugagaucagaaguagagcuucuaaugacccccagaagcacugagugaccaagugacauaccugccaggcccauuguguccaucgcucucagagcagcupauugug\n", + "cuuggcucccagagcuauggugcaaaaggcpucgcuapccacucapaaagagaacccagaaacauggcaugcugacaaaagg\n", + "cccuccpcccupccuagcgcgcgacggupuggagcuagccucgugaccuuuuaccccaac\n", + "ucugaccagugcacaggacuucapcuuccugguguuccacagcuuuggupcacuggcucuggcuucaccucacuccug\n", + "gaauucauuucugcggcggcgguggaggcgaupccaacagcggccucuagugucuggaggaggaagugucagcgcuacugccgcag\n", + "aaacccaauccccgcuuupcupaaauaacuguaaagacuccagapagagcggauguapcupcugcagg\n", + "ggcggagupuggaaaggccacgaggagccgccgcggcucaggagcpuggupcgucugagaagucgccacc\n", + "agaaaagagagcagcauuuguuagcacacaupccuguggagcccagucccaggcaacaguguccccagagccccagugauggcupuupucupcacucccapagcuccccaag\n", + "guggaacguccupcugcapcgcgcuccugucccacuucguggagcccguguaccugcagagcaucguggupcagccugcaccacacpccaccucgcacgcguc\n", + "acuguagcagacagugucuccaggcapuacugagcaaagaggauagugaaaapcagugaaacaucggccuuuuucacuggcaacuucaagacucacugccuacaau\n", + "ggugcaaagaaggcuaccaaggaguccguugugaucaauuucugccgaaaacugauuccaucuuaucggauccaa\n", + "cauuccagcuggagaugcgugaccuucggucugcggcaggcggaapcgagagacuuggacaggaggugcaucuugcccpaaggcugaacga\n", + "paagcaaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagca\n", + "aaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagca\n", + "apaagcaaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagca\n", + "aaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagcaauggcggugucugccpuccgcgcggaccucgcccagcucag\n", + "aucuucauuguguacuucauugcpugugaaaaagcuggaugcagacupuugaaggcuauucc\n", + "acagccgcugacgcgucpaggcggagccuapaagcaaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagca\n", + "gacgcgucpaggcggagccuapaagcaaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagca\n", + "gcgucpaggcggagccuapaagcaaauucuccuggcggccuccguucagacgcggcagcugugacccaccugccuccuccgcagagca\n", + "agacagcgcgucagugacaggcacacccpccapuccucuccuuuccucagcccgucucucugugacagacccugccugcacucccaagccccucucucccuguacg\n", + "aagagacggaggaugcaaaugaagaagccccauugapaccgcucccacaucgagaagacccuc\n", + "cugccugugcugugccugccuccuagagcucauucccuacgccccgacucuguccuggacagcgugcccaccagcc\n", + "ggcggaggcupccpcpcggcagaagauggcgapuguguaggcggcagcaaugcuccguugagagacgcggcuuucggcaagaacuggauucguggcgccacaagcucauucacuguguag\n", + "gucccguuucccucugugcggcggccggcpaccauaapcuuaacucauauauuuaaccccccuccaaaaa\n", + "ggcggcagcaaugcuccguugagagacgcggcuuucggcaagaacuggauucguggcgccacaagcucauucacuguguag\n", + "gguuugaaaguauucuugaapcuguuuggaccugcauuauuaaaagaucucaguuuauuuaaag\n", + "acugugaaccugaaagcauuucugauuggacuuuugaugaaaacuguuuauucuguugcuugagaagagauaaaguaaag\n", + "agaagauggcgapuguguaggcggcagcaaugcuccguugagagacgcggcuuucggcaagaacuggauucguggcgccacaagcucauucacuguguag\n", + "pcgugugcgaagcgugagguggagaupcggapagcuggagcugucacaguccccpugcgccugaccgagccaagupuguc\n", + "pccpcpcggcagaagauggcgapuguguaggcggcagcaaugcuccguugagagacgcggcuuucggcaagaacuggauucguggcgccacaagcucauucacuguguag\n", + "gupugucauggccgcppcagcggcugcacuuccucagcpcggcgguggccpaguuaauccucgacgcacpucg\n", + "gcgcccggcgcucpcgugugcgaagcgugagguggagaupcggapagcuggagcugucacaguccccpugcgccugaccgagccaagupuguc\n", + "cucauuguucgcagcugaugucacucgcaguugugagcggccgccucucccpacaaugupacugagcggcccagccgccgugccgccgccgccgccgccgcaggacagccccagcgag\n", + "cuuuguccaccaggccagauggagaggaapagauuggauuccccuccccacccacacauacccag\n", + "cugaugucacucgcaguugugagcggccgccucucccpacaaugupacugagcggcccagccgccgugccgccgccgccgccgccgcaggacagccccagcgag\n", + "ccucuggagucccuguggcagaacucaaauggaaggaggagcagcugcacccapagcapugucaccuccguuggauag\n", + "uuuguccaccaggccagauggagaggaapagauuggauuccccuccccacccacacauacccag\n", + "gaggaapagauuggauuccccuccccacccacacauacccaggugccaagagacucagcuguppagguggag\n", + "ggcaggaacugcugccacaaccucaggcupcaccaaacacccgugcccgccaaugcggcccagcccccggagagucaggcccacagagc\n", + "gccccucugagcagcccccuccuccuucapcaggaacugcugccacaaccucaggcupcaccaaacacccgugcccgccaaugcggcccagcccccggagagucaggcccacagagc\n", + "ucucacucugucccgcaggcuggaguucaguggcgcgaucucggcucacugcaaccucugccucccagguuuaagcgauucuccugccucagccuccugaguggcupacuacag\n", + "ggagccggcgccpagcgguagcpagagcggcagcpaccccagcgcpcggcggcggcupcpagccccagag\n", + "gcaccacaaggccacauaaggapugaggucccuggaguggauuauauuuucaucacuguugaagauuuu\n", + "ccauaacacaaagacaacaucauggcuggauccacgacuugcgaaaaaggcuaaaccuccagaagagugcaaagaaaaug\n", + "ccacauaaauagaagaacacaguuugaaaauccuguccuggaagcaaaaaggaagcuacagcaacauaac\n", + "gcaccacaaggccacauaaggapugaggucccuggaguggauuauauuuucaucacuguugaagauuuuauggaauuggagaaaaguggugcucuccuagaaagupacuuaugaag\n", + "ggapuaccucuugaaugapuccuaugaccugcuucapaagguuagaaaauucuuccupauuu\n", + "acggagucucgcucugucgcccaggcuggagugcaguggcaugaucucggcucaccgcaaccucugccucccag\n", + "agaaccaguaagcaaauuaaguguaucgauugcaauuuuguuggacuaacccugcuuuuuuuuucuuaaggaauaaacuugauuccuuuuagu\n", + "gagguugccaaauuuacagcugccuugcacaauuacucuuacaccuccuucapcuacuuagaacca\n", + "uccuuaaaaaacgaugagcagucugccaaaacugauguucagaaacuucuggaauuaggacagaaacaaag\n", + "agcgapaaggaggaccccggcaggcagcagcaugaaauucagcccagcgcacuaccugcugccucuccugccugcgcugguccucagcaccag\n", + "gacuaugaagagcuagaaaagcagcugaaagaagucuuuaaggagcgaagcaccauucuucgucagcugacaaagacaucaagagaacuugauggaauuaaagucaaucuucag\n", + "guggcgccapauuugaaccgcgcugacgaaguuuggugauccaucuuccgaguaucgccpauuucgaaucgcg\n", + "gccapauuugaaccgcgcugacgaaguuuggugauccaucuuccgaguaucgccpauuucgaaucgcg\n", + "aaaguuaagaguggcgccapauuugaaccgcgcugacgaaguuuggugauccaucuuccgaguaucgccpauuucgaaucgcg\n", + "aaauuucugccuagucaaaguuaagaguggcgccapauuugaaccgcgcugacgaaguuuggugauccaucuuccgaguaucgccpauuucgaaucgcg\n", + "acugcugaagcagauguggagaacuauaaauuaaggaucccagcuacuuaauugacuuaugcuuccuaguucguugcccagccaccaccgucucuccaaaaacccgag\n", + "uucuuuuuucuuguuccuuuguagcaagauaguuuucuuucauuuucuuccuggcauuuggcacuccuaaauaaugcaaaugcaaaaauaacucuguuacagaga\n", + "aaaccacaaggauucagacagagcccagagcccugaaaacuuuggccacgcacuuucccgcagcagccacaggcaccggcaacuucagagag\n", + "ccagauaaaaguggaaugaggaaugcagccguucugaacaccacccuccauuucauucuggaaccpaagguacacccaggcaugacaauagcuucucuccucacagaaauuuaacug\n", + "auuaaaccacaaggauucagacagagcccagagcccugaaaacuuuggccacgcacuuucccgcagcagccacaggcaccggcaacuucagagag\n", + "auaaaaguggaaugaggaaugcagccguucugaacaccacccuccauuucauucuggaaccpaagguacacccaggcaugacaauagcuucucuccucacagaaauuuaacug\n", + "auucuggaaccpaagguacacccaggcaugacaauagcuucucuccucacagaaauuuaacug\n", + "agcuaguagcagugguuuccauucaaaaaacaaacuucuuacacaaacauaggcuggucgaaagaauuaauuuguaca\n", + "agaaauaggagcgcgcaggcgcgacgugcggcucgcagaacggcgaguagcggagcpacccgcu\n", + "acaggcugaaucuguugcggcagcugaggcuacaacaggccugcgccggcggcagagaggauaucuupcpaugugagcgcugagcccuuggcag\n", + "gaaucuguugcggcagcugaggcuacaacaggccugcgccggcggcagagaggauaucuupcpaugugagcgcugagcccuuggcag\n", + "aagucaaugugauuuuaauuugaagcaaaacugaaaupuucuucuuccucauucuauucauguugcuuuuugauggccauggcauaaggaacucuaucccaggaauacagcuuugcauuag\n", + "cpaagcguuuccpcugaaggcacaggcugaaucuguugcggcagcugaggcuacaacaggccugcgccggcggcagagaggauaucuupcpaugugagcgcugagcccuuggcag\n", + "auuccugcuuccucagcccaggagcucgguuggccuupupucuagacagccgcggcggcugcggcgccgauagugacagugagugcgugagacccggagagaa\n", + "gaupapacgcgcggcacugcccucgagaacuggcgcuccggugaaguaggcgccgccggccguccgccucccccaagccguuccgcaccgcggccgcucagccucugcc\n", + "gugccagugacpuggcccgugagcugaugacgaggacuggcuuuuaauccuugguggugauuaagagaaagcuuauupccupagcagcuccccgccgacccccaccacc\n", + "agcagacgccaaccagcagccucgcagagccgaccgcggccgcccagccugccggcccacuucggcccgcucccupcaucuucccagcccu\n", + "gauuuuuguaggugcauccaacugcaacagaauacaucagccucaucggaaggagaauggaaggccugagaacgcacaaaaggagcauuuggagagg\n", + "cucuguaucggccaaauaaaaucaaucuggcucucagaugcauuggaaacuucaaauuaaagcaggacaaauagccuaa\n", + "ggaggcuucacaaggauggaggcaguaggaugagagauuccugaaaggaggcapaugacuacaucauaaaaag\n", + "uccggaagupugucagaaccuccacgugcugucccucccccuccccuuuucggcccaguagcggcggcucaguugcugcc\n", + "agugauggcuguuuuaguacuucagguggaauucguccuuuucaucuucagaacuggaagcagaaaguuaaucagacuaagaaagcagaauuuguacgcacagcagaaaaauuuaaaaauca\n", + "aucccggccaagcccgcagcgcapagcugucugcagaggccapugcgccugccacgaauccccaggcaccgguggccgccgcggcccgaguagcucggcpuaaac\n", + "ggauuacauccuuucccugcggaggaccapcaaguuuccugccugcacggcacaggagagcaaacuucuacagacagaccaaggcuuccauuugcugcugacacauggaacugag\n", + "gcgguggacgcgccggcuucgagcaucccuagccpcaggupaggcacpuugcggaucccgcggccgcgguucggacccgccggcgac\n", + "cuucgagcaucccuagccpcaggupaggcacpuugcggaucccgcggccgcgguucggacccgccggcgac\n", + "agucuggagcccagaapacacaccagcacagucugguaggcuacagcagcaagucucuaaagaaaggcugagaacacccagaacaggagaguucagguccagg\n", + "ggccpccagcacccacacupucuccacagcggcauggaggccugcgugucuucacugcuggugcuggcccupcccugucaguag\n", + "ggcgcaacgcugagcagcuggcgcgucccgcgcggccccaguucugcgcagcuucccgaggcuccgcaccagccgcgcuucuguccgccugcag\n", + "gauccaauuccuguaucuucaccuugucuaccpauuucuagagcagccuugugagagacauuucugagaccuguauguccugcgucuaugauucuucccugaucaag\n", + "ggcaugccucugcuccuuugcgcacgcgcgccgcuucccaguggcaagcgcpcaggaccgcguugcgucaucpcgcgcgccucagagagagcugugguugccggaaguugagcggcg\n", + "agcagccuugugagagacauuucugagaccuguauguccugcgucuaugauucuucccugaucaag\n", + "aguggcaagcgcpcaggaccgcguugcgucaucpcgcgcgccucagagagagcugugguugccggaaguugagcggcg\n", + "gaucuucuuuuuccuugauguucugaagcuacaagaugacuuccaauaccauguugaauaggagug\n", + "auauacacucuuuggagucugaaauauggaggaugcagcugcacuugacugaccgauuaaaagauuucccuugacuuugagaaacgauauuuaaucagaacaaaauacugugcacuaaag\n", + "ggagucugaaauauggaggaugcagcugcacuugacugaccgauuaaaagauuucccuugacuuugagaaacgauauuuaaucagaacaaaauacugugcacuaaag\n", + "acucuuuggagucugaaauauggaggaugcagcugcacuugacugaccgauuaaaagauuucccuugacuuugagaaacgauauuuaaucagaacaaaauacugugcacuaaag\n", + "ggaagaggccccagcacugaccuccgupuggagaugaggaggauggaaapugucuuccuccagcaucuuccugaag\n", + "acucuuuggaugcacaacaauggccacacaucgagauugaaaugaapauaaaaacauuccuauaaauucgaaggcaaguuuugcugacuagaaaaacaagccaauaauuugaa\n", + "acucucucugugcugaacgauggcgaacacagcagaaupacugacgaaaucagaugauuucuucuaauuuggaggcaauuuucacuaauuagaagaagacugaguauuugaa\n", + "accaaaccucuucgaggcacaaggcacaacaggcugcucupauucucuucagccaaucuucauugcucaa\n", + "acuucagagaagcggaggaauaagagaagcagcaggacuuuaacagagacuagaauauuuaaauuuuugcaaaacaugcucuucuaauuugaucaaaacauugaggauuggua\n", + "agaagcggaggaauaagagaagcagcaggacuuuaacagagacuagaauauuuaaauuuuugcaaaacaugcucuucuaauuugaucaaaacauugaggauuggua\n", + "auugcupcuccgcuucpaggaggacgcugaggaggcgccgagccgcgcagcgcugcpaggcgcccgcgccgacgcpccc\n", + "cgcaggaugapcggccauugcupcuccgcuucpaggaggacgcugaggaggcgccgagccgcgcagcgcugcpaggcgcccgcgccgacgcpccc\n", + "gugaaauugagaccuggcgcuuccugaggcuggcagcccgguugagccugaggaccagacuugaggcaguuggcaguccgcgccucguugcccucugucugcccugg\n", + "cauugcupcuccgcuucpaggaggacgcugaggaggcgccgagccgcgcagcgcugcpaggcgcccgcgccgacgcpccc\n", + "ggcpcgcaggaugapcggccauugcupcuccgcuucpaggaggacgcugaggaggcgccgagccgcgcagcgcugcpaggcgcccgcgccgacgcpccc\n", + "acgaagucucgcucugucaccaggcuggagugcaguggcaugaucacagcucacugcaguguugaucuucuggacuuaagcgacccuccuaccuuagccucccauguagcupacuacag\n", + "ggcuaggcuugcugacauaupcuauuggaggauaugcagguccacauccuuuauuugcaguucugaaaugcaagaguuuuuguuuuuug\n", + "gcucgagugcaguagcgagaucucagcucaccucagccucugucuccuggacucacaugauccucccacgucagccuccuaaauagcupauuacag\n", + "ggucucacucugucacccaggcuggagugcaguggcgcaaucucaguucacugcaaccuucgccucccagacucaagcaaucucaccucagcccuccaaguagcupacuacag\n", + "gcauuccucacccgcuccucuucaucucuugcguccguuuaccuuccccgcccagauucaguaccucucgccagacucucaccuggaucccagacuccuucuucuccag\n", + "auccugcpapacgcauuccucacccgcuccucuucaucucuugcguccguuuaccuuccccgcccagauucaguaccucucgccagacucucaccuggaucccagacuccuucuucuccag\n", + "gucgccgucuccgccucgccgcagucpcagccgcucgccccucuuuuccauguauccguccag\n", + "gaucccaugacagauucuguugucacgucuccuuacagaguuugagcggugcugaacugucagcaccaucuguccg\n", + "agaggcgcgupcpcpcupuupcugugucupcuuapcpccupaugcugccgcugagcugacccgcuggacuupuuguggcagacgg\n", + "ggcupccgapcucggccpcugaggcucapuuggacuucacgcaagaguccuguagagacgaagaccupcggagagcg\n", + "ccgugccpuucgucugacagaucccapagcccacgccccacguggccgccaapugac\n", + "ggcagcuggcggagcggcccagcccgugugcacguggcgccggcgcugccuuucgguugccaaaauucaggcuguagacggcgag\n", + "gagcgcggcaguggcccuggcagcuggcggagcggcccagcccgugugcacguggcgccggcgcugccuuucgguugccaaaauucaggcuguagacggcgag\n", + "aaacagccgagaggacccggaagcggugcgcuccgucaccapagugcpaauccgccguuugcgcugaggca\n", + "accugcpcccgapucuggcugucgcagcgccpccgccccgacuccgagcggcugcugag\n", + "uccccgguccacuccugcccgauccuccgupugccaggcccagccacgcagapagagccgccgacccgcuggcccuuugcaagcagccacgcucc\n", + "acuccugcccgauccuccgupugccaggcccagccacgcagapagagccgccgacccgcuggcccuuugcaagcagccacgcucc\n", + "gugcgcaaggagcpcgcggagccggcpcpcggaggauagcgcpcgcggcaccugcpcccgapucuggcugucgcagcgccpccgccccgacuccgagcggcugcugag\n", + "pcpcggaggauagcgcpcgcggcaccugcpcccgapucuggcugucgcagcgccpccgccccgacuccgagcggcugcugag\n", + "gugugcgcaaggagcpcgcggagccggcpcpcggaggauagcgcpcgcggcaccugcpcccgapucuggcugucgcagcgccpccgccccgacuccgagcggcugcugag\n", + "gapucgcppcggcapcccggcccpcpccgcpaapaugaguucpcgccugccaggcccugcagguggccpucgcaggccagccgcggaagcggagcg\n", + "agucucacugucgcccaggcugcagugcaguggugccaucacgcgucacugcaaccucugccucccggauucaagcaauucuccaccucagccucccaaguagcuggaauuacag\n", + "accagagucucacugucgcccaggcugcagugcaguggugccaucacgcgucacugcaaccucugccucccggauucaagcaauucuccaccucagccucccaaguagcuggaauuacag\n", + "gccaguuccucucccguupcccpaapcagcuaacgcuggacacupacggccgcggcggcagcuucaagacc\n", + "ggcaguuagagaacuaacugccaagauggagcgaapaacauuuaaccuugacuuuccacaguccugagguucccaaaauaaapaaccggaaauaccaaagg\n", + "ucauaggcugacaaggccuguacaugccagauagagcuggaagugaaaaaccaauggaacuaaaca\n", + "agucaggcupcucgaagupacccucgccccguccucggcuguccaguccuccuccucgcagaccccggcgguuccuaccccaggccgcapagacpccccaaggcag\n", + "gcuucauauccugaacgcupaucccccaggacauucccuggcccccaggccccaggucccaggccccapcugagcugupcaggccccaccug\n", + "gcagucaggcupcucgaagupacccucgccccguccucggcuguccaguccuccuccucgcagaccccggcgguuccuaccccaggccgcapagacpccccaaggcag\n", + "ggcupcucgaagupacccucgccccguccucggcuguccaguccuccuccucgcagaccccggcgguuccuaccccaggccgcapagacpccccaaggcag\n", + "ggccgcgcagugccggaacccggcugcagcggupaaggcpcgugccggcccagcpagagg\n", + "aucaugcuuuuuguguugugugugaaaucuuauugccaaaucaaggucgucuugguuuugacaagugugaaauu\n", + "gacccaguggcuuuuaaggauguggcugugaacuucacccaggaggagupcuuugcuggauauuucccagaggaaacucuacapaagug\n", + "uaggugccuccaccagagcuucugucgcucuguaaccugcacugugaccuacacuagucgcpagccacgcagaggacgccggaacacccuggaagccgagaa\n", + "aucggagcgcgccgcacupauggaaaccugacugccuggcccpacggcgcuugcagccaggcag\n", + "ggagucucuugcucugguucuugcuguuccugcuccugcucccgccgcuccccguccugcucgcggacccapcgcccacgccag\n", + "ugaaucccuguuguuacuauccaugccagcaccapcaucuguguccgcuucggccuugaccgcuaccagugugacugcacccgcacpcuauuccggccccaacugcaccaucc\n", + "cuggccuguggaccuggcuccggaauucacugcggcccagccccucuuucacccacuuccugcucacucacpcgcugguucupaguuugucaaugccaccuucauccgagag\n", + "agcuuguggcucuucugccugccgaggcagagcucuapccauggcpaggccuuccggcuccaccucagacagcuguugapccuggaagaugapacuccuuuuggucaggcuggag\n", + "gaaggcpapaggapccaggcpapcpacggcgcggcgapcpucagcgccgaggccgcpcagcaacgacgccpcagcpagcggcggccgcgcc\n", + "gccuuuggaaaugcaaagacagcucauaauaacaauucaagucguuuupaaguuuauucaaguaaauuaccaggaaacaggcacuguacuugg\n", + "gaacuaucauguauucuauuaccuccuggcaggagcaagugaagaugagagaucagcauuccaucuuaagcaaccagaggaauaucauuaucucaaucag\n", + "aguggcgucacgugcpcpacapcpccgacccgugcuggcaguapcgupag\n", + "uuauuuuaccaagaaaaugguuugcacgacuuugaacauauacuauccaugcugaupacaggauccaau\n", + "caguuauuuuaccaagaaaaugguuugcacgacuuugaacauauacuauccaugcugaupacaggauccaau\n", + "caucuccgguccuacccupcggapuggaaggcagcuuccgucgaagaggapcugcgguggccaccgcggcggagcccgag\n", + "caagaugaugaagugacgacuguucagguuaaagagcaagaccagagcguccuggugcugaagaaagugcagugcuguggcccagcccccacagcupagugcggagagccauuggag\n", + "auauguggugguguccpaccccggagaagauuuuggagcaccuuuugaaugacuugcaccuggaagaaguccaggacaaagaaacag\n", + "gauggacucaguucccagugaaaggacapauggcaagaucuuuuagcauuuapaugccuuuguuaguaaccguucaca\n", + "agucgcgcccucucgcuuccuggcgaaggcgcggacggcgcgcggaggcgagcgcgguggagaggagcccccggcgccgcagcgccgucapc\n", + "ucucgcuuccuggcgaaggcgcggacggcgcgcggaggcgagcgcgguggagaggagcccccggcgccgcagcgccgucapc\n", + "aguucccagugaaaggacapauggcaagaucuuuuagcauuuapaugccuuuguuaguaaccguucaca\n", + "gcugcggccgcggcugapaccugcccgcgcugcugcggagcpcucacgcugcggaggaagcggagcgccgcupccgg\n", + "auuuauggagagaauucuucuugugcaggaagagcauugaggaauauuauuaucguucaagcagcugaccugauaaaggacagagugaaccucaapuuuuacag\n", + "gaggagcugcguupucagagcugguagacuggcuucuagaacacuguccuuucguccagugcagaucu\n", + "aaaauagagapaggcaccacagaugccagaagaacacuguugcucuugguggacpcccagaggaauucagaguuaaaccuugagugccugcguccgugagaauucagc\n", + "agaagaacacuguugcucuugguggacpcccagaggaauucagaguuaaaccuugagugccugcguccgugagaauucagc\n", + "gcaagcgccuccaagguuugucuugaagcauagcuccagcuggapuaccuuuuaagcuguucaaggucaag\n", + "guucgugccgcgcuucuagcaacgccpccgguaacccccucucccuccuugcgcguuccpucuc\n", + "aucuuuguucccugcccggccauuguucgugccgcgcuucuagcaacgccpccgguaacccccucucccuccuugcgcguuccpucuc\n", + "gagaggucggcaucuuuguucccugcccggccauuguucgugccgcgcuucuagcaacgccpccg\n", + "auguggaucuccuguuacuggaaaacaggaauuagcuugucugcuugaggaugugguugguucuuuauaaaaaggauacagaagaaauuugcacagacugccagcuucauu\n", + "gaugcuccaaauaucccuacaaaguacuuuauuauuccuguuucacagacaaggaaacupcacagacagguugaacaauguuccuguagcugagccaggauuugaacccag\n", + "ggauuuauuucucuacaapacacaggugacugaacuuccuccuggccccgaggacccapaagcaccucuuugagaucagcccag\n", + "acaaucacaaagaguguguaggccagccccggucacagagugcaccguauccugucacuucuggaugugag\n", + "aaaaacagaauaauucugaaagaaagaaaacaaagaaaaacauacuccagaauuccuaauagaaca\n", + "auuuuggaggaaucuuuggcauucugaaucauccuccuauaacacuuucccauccaggccccacccaacuaauuuuuaaucauaauuuagaucucaacacaaaggcuggcacaaag\n", + "gcugccccuccaagagcggaggcagcgagaguacgcgugugccucgcgccgguccacgcpagagcacupaccgagacccggcaccaccucccgguccgcccuccag\n", + "ccuccuuucacuccgugcccaauuccugcaguuguugcugagguuuaccagauggauuaaaagaaaaaauaagaaguggcuccaaacau\n", + "auucauccuugugauagauaugcaugcaaaaccaaaaugaaaucaaauccccacagauggcucguaagucaaaaacacuguuuaauucuuucacugcaucccuuupaagccuggcccuug\n", + "acuuggcccucgcucucacucgcggucgccuggccguugucauugucccuccgcugucaccuuuucaag\n", + "pcagugcgcgacggcggcggcggcgcpagguucggagcpagcucpcucgcggacggu\n", + "uuuucapuucagcucccugcauguuuacacccuacugcuuccucccugcpcuccaccccuucuccugcaauccugacccggcgcccgcccgccugcagguu\n", + "apaggaggaggcgcccgccugguucccugcaaagcggccuuauuuaucupcacagccucagccuccccggupaggcuupcggccgauccucucccaccpagcuccuuuccgugcg\n", + "auggupcagugguggugcuggcugcguuccccucccuapcaggupagacucccgaagccccuccggagucauggacccagcuaugguucuuccgauuugugguga\n", + "acuuccgcuggccgcuggcucgcuggccgcuccuggaggcggcggcpagcgcapcgcgcggcccpacucgcauuccccgguucccccuccaccccacgcggccuggacc\n", + "agaauuacuacccagccaacaaagcaaggagacaccuucauccugucagaaaacpaaacuaacacagaggagcggcuupaugcagagccucaauguccuguccacaagauggcaaug\n", + "gugugaaguaggcgcuggcaacgcpuuacccgcuguuauugaggaguaacggcccagcggaccacccaggcuugaggcagcggcpaaccacucgguuugcugcgauacc\n", + "gcgucgcuguauuccuuagcucugaaaugccuuaucagucucuccacgaucauccugcucggucugaucaucguguaccacgccapaaauacag\n", + "gcucccgaccauaacgcauugcgcapugcaccaccgcuuggucucccugcagcuuuaacagcccugac\n", + "auucuugcugagagaacuacaaaaggauggacuccagcaagaggaaaaaugaaucuaaggaauggagupauauaagcaauaaca\n", + "agaccuucagauaaaggagcucucgaaauacaacccauaaggaauaaagccauagccagugcuucccug\n", + "gguaaaauguuuagcauucugguguuuuuucuuauccauuggccuaaggaagauaagagaaacauggagcagcccaggauacaaccuacagcuuagagcuaaacucauucaagcccagacuag\n", + "gcauggauaucaagcaugccucugaguaaaacaaagagaauccagucuuugaccaauugaccaaacaagacccaagcagcupaaguuugucaagucucauaagaaugag\n", + "uuccugucccgcucggcuccaggcccugcgugucccapacugcggccpcpupcucuccccuggccagga\n", + "gcauugccgcuucccuggugccpagcagucgccgcugccgccuccgcccgcggccpacccccguccucgcccpacuccuuacccpaaccuagaccag\n", + "uugccgcuucccuggugccpagcagucgccgcugccgccuccgcccgcggccpacccccguccucgcccpacuccuuacccpaaccuagaccag\n", + "cugaagugguucguugccucaacagugcucuacaggucggcugcpcuuuugcaugccuggaaaacuccaccugugacacagaup\n", + "gaggaaupagcugcuggaugaggcucagagacucuucuauuaugaaauaauggcuucugugcuucgcauuuauagucucccugg\n", + "gagcggucacgugugapcggcccgaggucacgugacggagcgccggagcggapagccpcupaguucuccugapaagaggaguggaguappacgcggcggcggcguugaca\n", + "gaggucacgugacggagcgccggagcggapagccpcupaguucuccugapaagaggaguggaguappacgcggcggcggcguugaca\n", + "ggucacgugugapcggcccgaggucacgugacggagcgccggagcggapagccpcupaguucuccugapaagaggaguggaguappacgcggcggcggcguugaca\n", + "aguuuucuuggaggcuuuuuugguccaauuugugagaucgauauuguucuuaaugaupaaaccaggaaa\n", + "acucgccugcaggcuggcguuggcuacggaaacacccucagcugcauccgcgugguguacaggapagagu\n", + "ccugcggcgugcucgagacuccgacuucggucuugcggcgcgcucgcgcccgcpccaugccccacugacucuaagupcacugccccggcuccpapcgagaccgagcgccggcc\n", + "uguugcucagucuucagaccgcagcacagcaucaucugcaccpacccpaauppacacuuggagacugagagagaggaggcucgaggaaugaaccuug\n", + "agcgaucgucuucugaucaaaggagguaaaauuguuaaugaugaccagucguucuaugcagacauauac\n", + "aagcugaagauacagcgguaaacaaaccuccaugucucaagcugaccacacuuguaucuggacuugccagcugauuagcucuguucccaccaggcucguucaaagacccacagcuugapcagag\n", + "aguagucgauggcggaggugcgcugaacgcaugcgugcuguggucgccuaguaaacpcugcuggupccgcgucgaagac\n", + "gugcgcugaacgcaugcgugcuguggucgccuaguaaacpcugcuggupccgcgucgaagac\n", + "guacpcgaaggcguggaaaauaucccagaccgacucagaauuacagagcuuuccagagcuuauauaccuu\n", + "cgugcuguauaccgaaacagagugaaagugauccauaaacuuacguaguuuauucgaucaacaugauuggcccgccagccccgg\n", + "guauaugaaugaccuaaagguacaaauaaagacggagagagaacagugccaacupagcapcaaga\n", + "cuccuccacccccaccaccugugauccgaaauggugccapaugcucccccucccccaccaccauaccga\n", + "aaucgugcgcaaaaapagacpaacggaggaccuguupaacggcuaauuagcaggaugcugugg\n", + "agacguggucucacucugucgcccpcuggagugcaguggcaugaucauggcuccuuaaagccucgaccucccpcugaagugguccuuccaccuaagccccgccaauagcupaccacag\n", + "aguuucuccaaaauaaaaaaaaaaagaaaagaaaaacaaaugacaaguuugcaagacugauaaaacag\n", + "acuaaugacagacugccccacugagaapucuagcggagcacaggucaccagcupcaacauucagaaaguuagucuuccu\n", + "gcaggagcacguggagaggccgaguagccacagcggcagcuccagcccggcccggcagcgacauggaag\n", + "aaagugcagcgguuuugaaugacuacaguuuaaccaaaucucaugaaauggaaaauguggacaguggagaaggcccagccaaugaagaugaagacauaggag\n", + "uggagaaacccuacaaaugugaguuuuguggaaggaguuacaagcagagaaguucccuugaggagcacaaggagcgcugccguacauuucuucagagcacugacccapacacug\n", + "guacugguupaupucgagcuuucccaucucggcauaagacugcaagauuugaaugugcccuggugucggcuucacugaccacagcagguaccccaggcaagaaucugagcaguuauaacag\n", + "gaaggaaagaugaacuugaguuucacuucuuagugccuuuucucapagaggccaucacuugaag\n", + "ggccucccugccacpaugcugccuuuucugcuccpuguuuccacgaggcaggcauggaaucuucccuggacaagcgacauaccguggagagacag\n", + "gcuccugaauccuaagagaauguuggugaagaucuuaacaccacgccuugagcaagucgcaagagcpaggacacagaccaggaaccgagaapacaagcac\n", + "guuggugaagaucuuaacaccacgccuugagcaagucgcaagagcpaggacacagaccaggaaccgagaapacaagcac\n", + "acaguuaacagacpcgcucapagcuapagcugugaagcugcuggaggaguuggcguccpagcaapcc\n", + "ggacucuugacguuuagguauguggccauagaauucucucuggaggaguagcagugccuggacacugcacagcagaauuuauagaggaauguuaugaaaaccuggccuuccugg\n", + "guauuacugucucuaagccagaccugaucaccuaucuggagcgagaaaaagagcccuggaauaugaagugacaugagaugguggaugaacccccag\n", + "uaacaaugcugcagcuuuuccgcgcuaccugcagapuccauacggcguuguucuggauucccgucguaacuuaaapaaacuuucaca\n", + "guuguaagcacugagauauupuuguuagcacuaccucaacccaacugauggccacacuuuagaugugcaggaaaug\n", + "gaucuuggaaacaaagaccucaacapauaaaauuuacuugauuugucaaauaguccpucggcaag\n", + "cucgagcugagcuuucgcuugccguccaccacugcccaccacugucguuugcugccaucgcagaccugcugcugacuuccaucccucuggauccggcaag\n", + "ggccuggauuuugacaaugucaagauuuaccguauaucccuguuuguuuggauacaccagugacguccacuucuagaagacaaaguuauauuacuuaaacaaccaaag\n", + "uauuagcagcaugaggacagacuaauacauapugaaacuuuugauuauauauguaaauauauaaaaauagccuuuccacuaauaagacuucuuucuccucagauaugaaacuaucc\n", + "acuucccccauuauuaaacacuauguucaaaaggcgccpacuucccggagccacggagcccgcgccgcccgcccgcccggcccacggagccc\n", + "gacucgucggaggagccacagcugaggupcpaupacgcagcucggagcgcuagagagacgcggcggcgcuggcagaagaggcggcggcpcgg\n", + "ccagugcgugccpugcggcgccagcagcggapcggcccggcgcccagcggagagccgcuggcugg\n", + "augcugcgacuggagcccacgcupuuccgugacggcccuacucacggccaagacucccuggaccgcaucgcaggagcpcuuggcgcguugcuggcuccgagag\n", + "auccgaugcauuccccgaagccugcpcugcuaggaggaaagucugcugaggupagaupcaccg\n", + "gugcgugccpugcggcgccagcagcggapcggcccggcgcccagcggagagccgcuggcugg\n", + "agugcgugccpugcggcgccagcagcggapcggcccggcgcccagcggagagccgcuggcugg\n", + "gaaagugaggucaucauuccuuucaggaaguugagugaggccugagacagcaauguuucguuuagccuggcggcggcccuccuugucuucgagaagagcauccgcggcuagcaguggaag\n", + "aucauuccuuucaggaaguugagugaggccugagacagcaauguuucguuuagccuggcggcggcccuccuugucuucgagaagagcauccgcggcuagcaguggaagaupuupccccag\n", + "cucggauucugaagguaauuuugagacuccugaagcugaaaccccgauccgaucaccuuucaaggaguccugugauccaucacucggauuggcaggaccupccaaaagccaag\n", + "uccucccgccccaccgccuccccgcccapucupcacagccgcccgccgcccagcacaggapugcagccccggccccaaguucugcgcc\n", + "ucccaapuuccaaggccagagagagguccuggucuugauugcuggcauguuuacucuuccaaguacacugagaucaaaugcaaagacaaaccaucaaag\n", + "uuaacaagcagugacuuuuguucucccacugguaaucacguuaaugaaaucuuagaaucacccaagaaggcaaagucgcguuuaauaac\n", + "gaugcgaaaucagcgguagcagguggcgcagaapagapagcgacccupaccgacucupacccucgccgaagag\n", + "gugcaucaccagguccuuuuaccggaauguggupuguccugcuggucuuugaugugacaaacaggaaguccuuugaacacauccaagacuggcaccaggagguc\n", + "aaagaagccagaaaauauuaucaacccuuugagaacacgacacaacgaacuuuauauuuuaccacuuccuugaauag\n", + "auucuucagcuugucucuaaccgaggaagcauugauupagcuacucauucagaaaauuaaaag\n", + "ggagaccagaugaugacauucauaggcugauagacucgacuccupacacacuuggauggaggcaauuaaaaugccugucaggcauuugguaccagaagccccuauggcaaaccgcuaaauc\n", + "ccucugcccaguccupucccgcggccgccuaggapagcccgccpcpcpccpugccc\n", + "gccccgauuaccauggagaccgccuguacacaguuuccucuuuccucugcccaguccupucccgcggccgccuaggapagcccgccpcpcpccpugccc\n", + "gcuguggagaccupcuccgaccccaguucauccccccacacccccgccgccccgugccacccugguccgcgcupaacccuauccugccccucgugucagcccggcacuggccagaaucgcpc\n", + "gcuggcgccauuaccugaguucuccuccagcguuuccgcacccucuccgauuagcggucccaggaguuuccaag\n", + "gcgcccccugucucagcuuugacauaguccpaucaccupagacaaccggacagagcuuccucuuacacuuuacuugugugcupacccaggcugagagcgcccagagcaacag\n", + "caccgguaccgugguggaagcgcgcccupcugccpcgcggccgcgguggcacuuggacccgaggaggcggcag\n", + "cucuaccgucgcaggacucugcccuuccccaagagaggaaccagaaggaggaccuaucagcccuugaaauucuaaaaguc\n", + "ggcugcgcacggcgaauccaccgguaccgugguggaagcgcgcccupcugccpcgcggccgcgguggcacuuggacccgaggaggcggcag\n", + "guggcuuuaccggcgugagacuacauuucccgccggcccucgcggcgugcgcuuucuggcgcccccuuucugcuuccagccucauagcccaggugcauggaccccuuag\n", + "ucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "auacupagaggcuucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "cupaucagccugaccacgcuccauacupagaggcuucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "gucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "pagaggcuucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "cuccauacupagaggcuucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "ugaccacgcuccauacupagaggcuucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "pugcccccagcccacgcuucaucuagccaaguguuacacauccuuccaggaccacacugcagaccag\n", + "gcuucupucaaaggaccagucugcagapauccuguggcuggaagcgaggaggcuccacacggccguugcagcuaccgcagccag\n", + "gccggcgcugacgcagccauggcggaggcggcuuuggaagccgugcggagcgaguuacgagaauucccggccgcugcaap\n", + "gcccggugccgucuugaccguggucgcggcgaagcccuguguuuccuacagucuugagcagcuugcuguuacccuuguugaaagcucaucgaaggcacacagcuggug\n", + "agccacagupcuccacagaggugaguguggccgugaccccagaugguuacgcggaugccgugagapaucgcuuc\n", + "ucucggccggcgcugacgcagccauggcggaggcggcuuuggaagccgugcggagcgaguuacgagaauucccggccgcugcaap\n", + "uaguaauaccagcuguaaucccagcuacuupaggcugaggcagaagaaucgcuugaacccpaggcggagguugag\n", + "caacuacacugcgcugcaucggacucgacgcccgcuggugacgcacacgcugcgccggaagugugaacugucugccuccaggcuuuguc\n", + "puaaaucuucagcgaaaacaggcggcgaacuucacggccggaggacagccgcggcgcgaggaggcagugagcgcccuguguupcaccggcggcgagacccag\n", + "auggagucucacucucucccccaggcupugcagcggcgugaucucagcucacuccaaccucugcuucccagguucaagcgauucuucugccucagccuccggauaccupauuacag\n", + "agaagagacaggacaauggacpuguauuacgugaaccauaacacucgcacgacccagupaggauccccggacccap\n", + "gugcuguggcuuacguuuauaaucccaucacuuupaggccaaggcaggaggauggcuugagccuaggaguucaagaccagucuggacaacuug\n", + "ggcuugcccgcggcgapaggcugcgcccagguccccggccccgcgccgcgcgcccagccgcgcc\n", + "acgccgugccuuacagcgaccggcapacucggccguccgcgagcccagccgcccgccccgcuccggccaggauguuggag\n", + "gcuucucuaucugagaugugcacagaaacccagacaggaccagucggcacugugugcugcgugcugccuccugaccagucugugugacaccgucpcucuucuggccagacagcucacaauccag\n", + "cuaauugcuguuggcucaggaaauguggacaauacgcaggaapacgccgugccuuacagcgaccggcapacucggccguccgcgagcccagccgcccgccccgcuccggccaggauguuggag\n", + "cggaacggaacccagagaapcacgcpcggcggcgcucpcuugcccgcggcgapaggcugcgcccagguccccggccccgcgccgcgcgcccagccgcgcc\n", + "gapagcacuggcaguugcupuaauuugaagacgacgguggapuuugguaucaaccaacagccccaacgucuggucuaaguaugguggcuuggagcggcuuugcapac\n", + "gcgugccgccgccagacggauuacuggcaguucgugaaagacauccgguggcucaguccccacucagcccuucacguggagaag\n", + "uucuuuguucaacacgccaagaaccuggacacucuucacugguaacauauuuuggcaagccaaccaggag\n", + "ccaucucuagaaugucaaauggucucucuucaacuggaaugaugagaagugaaacaaauaugcgaccaugaggacacuguaaccuauggauggugugcugagacuggaaacccaaaaugaug\n", + "gagauuugcgccugcgcagugcggcgccuagapaaagcgagapagacggacguugagagaacgaggaggaaggagagaaa\n", + "gcagugcggcgccuagapaaagcgagapagacggacguugagagaacgaggaggaaggagagaaa\n", + "auaucupuacacpaaccgcagaggacaaacucucacccgcguuuucgauuucugcgcuuucuucgagugaggcaagaccuagcagaggcccaag\n", + "agaaggcupccggcagcgguugugaggaguuagcucgcggcauugcaggcucugagaggapacccgguucccpugaguguccaggc\n", + "gcugcupacpaaaggagacgcuucuuccucuugcugcucuucucguucccgagaucagcggcggcggugaccgcgagupucggcaccgucuccggcuccpugcgaaca\n", + "cupacpaaaggagacgcuucuuccucuugcugcucuucucguucccgagaucagcggcggcggugaccgcgagupucggcaccgucuccggcuccpugcgaaca\n", + "pacpaaaggagacgcuucuuccucuugcugcucuucucguucccgagaucagcggcggcggugaccgcgagupucggcaccgucuccggcuccpugcgaaca\n", + "gccauuuggauaugguucgcuuucuacuugaagcuggugcagaucaagagcacaaaacagaugagaugcacacugccuuaauggaggccugcaug\n", + "gcgcuaaugugcaugcuacaacagcaacaggagacacagccuuaaccuaugcuugugaaaauggacauacggauguugcagauguuuuacuucaagcapcugauuua\n", + "gaacaugaaucugaagguggaagaacaccuuugaugaaagcugcaagagcuggucauuugugcacugugcaguuucuuauuagcaaag\n", + "gugccaauguuaacapcuacagccaauaaugaucauacaguagugucgcuggcaugugcaggaggccaccuggcaguuguugagcuucucuuggcucaupcugacccuacucaucgacucaag\n", + "gugccacgugugccaacgcauacacuugccaugguuguaccuccccaggaaccugacagaacuucacaggagaacucuccugcccuuuuaggagugcaaaaag\n", + "acugagagcaaucaugacacagcauuaacacuagcuugugcagguggucaugaagaacuuguaucugugcucauugcacpaugccaaaauugaacacagagacaaaaaag\n", + "ggucauguaaaaguuguucaauauuugguaaaggaaguaaaucaguucccuucugauauagaaugcaugagauacauagcaacaauuacagauaag\n", + "gaacuguugaaaaaaugucaucaaugugucgaaaccauugugaaggcuaaagaccagcaagcugcagaagcaaauaagaaugcgaguauucuuuuaaaggaacuugaucuggaaaag\n", + "gagaauugagaauuaaaugaaaagguaaauccuuuuaaagaccucagaagauggaucuguuuguuucaaucugcuuuugag\n", + "ucugucagcacugccuucaaaaugcacccagaauagauucacaauucuaccauuucucucaaccgccacugucaccaccuugguccaggcccccaucaucug\n", + "agaagcaccaaaagaggcaaacugagaugcagacaaaugaucauccguaugcugaucauuuugaaua\n", + "gcaagaaacacauaauccaaaaacuuuaauuauuuauguucaacucuguacuggaaagaaagagcaggcag\n", + "ggaggccccgcgcgcpuuuccaupacgcgccggcgcugcggcguuggcgcagucgupaacagcgcggagcag\n", + "agaccaaaaccugucaaaaaaauacuaccguggaaagcucauaaauacuacagugugaagaacccugugcuuaucuucaguuuaucaucagacaucuuapaaguuuaauaaagaacaccag\n", + "cgcaggugagcugcagaggcgcgcguggucccugccccacccgcgcggagccagagaggaggcgguugucaaggcgacgugg\n", + "cgccuucugccagcagaagcagcagccgcagcaccugagccgcuacugccgcucacucaggacaacgcu\n", + "uuuuuuuccgccuucugccagcagaagcagcagccgcagcaccugagccgcuacugccgcucacucaggacaacgcu\n", + "gccaagaaagaagagagaacucucaccacaacauuucaaapaauacauugccagaacuuggaauacucuacuggacaaacauuuccuccaag\n", + "gacacagcucucugccuccaugucaccaccuuugaaggacugacugauucccucggcuggugccagugccugcuccugcc\n", + "aguuuucuccaaaggagaaggagugcacuuagapagcuguguuuuggugaccucugaaacucaguacugcagcgaaugagcuccugaccuugaggaguacuuaacagaauu\n", + "uggaugapaaaggagguaagaucuguaaugaauaagcaggaacuuugaagacucagugacuca\n", + "uugcauaaauugaaaaaggcaguaaaugaauugucucgugcuauccaccuucagccagauggaauccaauuauacauaagaag\n", + "agucgagcccacccggccccuaggcacaggaaaggccuguuggacacucgccgagcggcpccaagcucaccgccaccugaauuggagcggaggcgcccucgaugccgg\n", + "aggacaauaucuucuuaugaugaaauauuaugaucuugcaaaguuuacuauuuaucaaauagcagaa\n", + "gaaaacccuuuccuguaugccaucuguuuucugupcccugagugaugaggagaggaacaaggauucauggaagugag\n", + "cuucgcucgccgccucgcucagagccpccpccagagcggcgccccgcugcccuguccccgcgugcagaccccpcccggccccggccccccgccaagcc\n", + "gcggcaggugaagcggugguggcagaggcgccugcgguuacuggccpccgacpuccugagucuccagagcucggugaggcgucccggaggcggcgaucacg\n", + "guucuuacauccccgcguccccagguuuagccugagcapuuguggaaggccpacccauugacagcacg\n", + "gagaaaauggcggcccccagaccgcacugcpcgucgcggcaggugaagcggugguggcagaggcgccugcgguuacuggccpccgacpuccugagucuccagagcucg\n", + "guagcggacauggcpcucccggcucccgcggcagcucuuccuccapcguggcggccgucuucauguuugcuuucgcuucccucuacacgcaaaucccag\n", + "gcupaucugcaggcccugacucagagguagucuagucugcaapcuguccapccuggcc\n", + "gaacaucagacuccaauuucuucaguucupacucugacuggcuuccuugcuccucagccugcagauggccuauugugagaccucacguugucauau\n", + "ucccaugcuggaugcuucccgcccuugaacaucagacuccaauuucuucaguucupacucugacuggcuuccuugcuccucagccugcagauggccuauugugagaccucacguugucauau\n", + "ggauggucauuuauuacugcggacacuuauguaaccupuguauauaggagccuggcugaggacacacucgccagccugugcuuugccaccugagcgccgcucccucucagg\n", + "agucagagguuaacggaaaacggaagcuggcuggcugagaagaagcuuccguuaguccuaccuugaagagaaaagagccagauaaagagaaagauuaaaagu\n", + "gauuuuaaaacuuauguagaucaggcauguagagcugcugaggaguuugucaauauuuacuaugagaca\n", + "cccugcggaccggacacgugaggagguagugacgccgacacugccagaacacacugcuacaaggucccagauggccacgucucug\n", + "gccccugauugcugauucuguccgccugccacaccggcucuguccggagccacupacucpauccaguccacacacaccccucagapcacuguggccagagaa\n", + "auugcaguupcgcucagcagcuguggcagccgguugaggucuggaaguagcguupcugaagcagcggaguucgcc\n", + "ccuuaccaugauuugcagaugucugaguuccauguaaacagaaguuaacucucugcpcugucaucuucuuuugagg\n", + "upagucuuguaaugcagccacuguggauaaaagugaauuacuguucuuaauuuacccuuuugucucccuucaggauggauuguaggaauucccc\n", + "uaaugcguagacauggugacaacaguccacaggcuaaaauauuggacccauaacagacccuuccugaacccaaag\n", + "aucugaagucuaggacugccapcaacaugguaccuuuggcuuuacauuucccuggagaaguupcuccaagagacagcagucag\n", + "gcggccgccpuaaggcpcgcagcgccucaapagcggccpccggcpccuggcgccgcgguguccgcggcagcgccgcccugagccggagaagcuuucccpcaacag\n", + "gcggcgcgupcpacpapcgcggccagccpcuucugcuuccgcgaccccggcggugcapcpuggagucgcggaguaguccuc\n", + "gccaggcucgccgcpcgcugagcaggccpacaccgcggccgagguuaucguuaggcaucucccaggcgaccggcuccgcagcaag\n", + "aggccaggcucgccgcpcgcugagcaggccpacaccgcggccgagguuaucguuaggcaucucccaggcgaccggcuccgcagcaag\n", + "aguagaggcugccccucugacapaguuuguggucagcgagupcccuupucuupcugucacapacuccagaaagccaugcagagccuugugcc\n", + "gucaugugucuccagcucuucccagcacaaccucacccuccucapcucugapcggagaggacaggccagagcg\n", + "aacagcggccucugacaccagcacagcaaacccgccpaucaaaguguaccagucggcagcaugg\n", + "ccggaacagcggccucugacaccagcacagcaaacccgccpaucaaaguguaccagucggcagc\n", + "cuccucaagaacagccaapugccupcuucgaccagacaaacacagagcugcacaccuacugcacccucguguuuacuucuc\n", + "guaaacucuagcpcuagagcaaacauuggauuagcggcagcagccugccagccugcccgaggagugcupaccagcgcgcugcacgccgacuggcacg\n", + "auuggauuagcggcagcagccugccagccugcccgaggagugcupaccagcgcgcugcacgccgacuggcacg\n", + "cccagucucccccgcgcugcgugcaguaagguagccgccgccgccgccgccgccgcguccccucgccggcucgcugguaccggcagugcc\n", + "gccgcccccgccucgccgccgccgapcapcccccucacccccuccccuucccacgcgccggccccguugcccccgcgcgcgcgcacacucgcgagccccggcgacaugcaaaugag\n", + "aagacugcgagcuccccgcacccccucgcacucccucuggccggcccapcgccuucagcccaaccuccccagccccacpcgccacggaacccgcucgaucucgccgccaacugguagac\n", + "ggcacagugacuuuugaagacguggcugugaaauuuacccaggaggaauggaaucuccuuagugaggcucagagaugccuguaccgugaugugacucuggagaaccuggcacuu\n", + "cagccaacagagcagucagcagagcagccacgaugaugauucuagcagguuccugaguccucgagcgcpaagaaag\n", + "cacugccaguaacuccaaccgcagcacgccggccugcucgcccauccuccggaagcggucucgcucgccaaccccgcagaaccaggacggagacacc\n", + "cggcugcucucauguaccuuuagacagaggcugugagucucupaguggaguppugugaaccgcccgcuccuggcuccuguguaggccucagucagucugaauguuauugcaag\n", + "cccguppcucauccuacccacaguaagagcauccuggcgugaccccacugaggacuucaccuccucucccuugguggacaccuauccag\n", + "agucauauuugaccucaccaagacacgacuguguggacugcucuaggcuggcacaggccccucuggagagcuguugc\n", + "aagacaugcuuugugucuccuccuccuucugccaggauuguaaguuuccugaggccuccccagccauguggaacu\n", + "aacucuuuucaucuucugcuacugaaauuupccucauuaaagaguaacuccucauucgccaucugucuccgupuuugacugcucau\n", + "guagaacaccugaaggagaagcucauuagccaggcccaggaagugagccgacugcgaucugagcug\n", + "agagugacuugcuuucuccucuuccgcacccpuguggagagugapagaauauugcugcuggcucuggaauaaa\n", + "cucuucugaggcucuaggugccccaguagcapccuucugcagcaaggccpaacugcugcaccauug\n", + "apcgcgagcpcuggccgaggaggaggcggcggcguggagcugccuccugccggcpccpccpccgagccccpcgcugcggcgacgccuggauccugccuccgccaggccg\n", + "agcugccuccugccggcpccpccpccgagccccpcgcugcggcgacgccuggauccugccuccgccaggccg\n", + "gaaucagcugcauucccucuggccaagcuggucagagcucugcpcugccguccuuggccaagagcgugupcuagcuccggucucugcccaggcugguaaacaag\n", + "papcgcgagcpcuggccgaggaggaggcggcggcguggagcugccuccugccggcpccpccpccgagccccpcgcugcggcgacgccuggauccugccuccgccaggccg\n", + "gcagcagccgccaguuccaugcacuggcggagcagcucuaggcggcggcuucuacuuucaguuucgugcagagcgcggaggagccgcgagcgcugagg\n", + "gagucugcacuauggaaacaaccugucaauccagcucaaggcacacauagcccagacacccaugagacccucuccgupacccuagagcaccuaucaugaacgaggagaccaa\n", + "gugugacuuuauccuggaggcagupaugcugauagcaaguucagacaggcaugaggccagaccagagcugaguuuucaagauaacuccagccagag\n", + "uccgcgccucggugcagagcugcgcugcgcccuuccagucgugcgucuccuccuuucccucgcccccaaauaaaa\n", + "agacgaggucuugcuacauuguccaggauggagaaguaggaauucuuaaggauauuguuauggapaaaaaaauca\n", + "pauggaggcaagupucgcgccuggagcggagccucggccuccggagccgcagcugcag\n", + "cuggccucupaggaguuucuuuuuccuuacguuccaaaucacccuaccugaggugcccccucugcagauucccaaaccuaauuugcagugcagcuucugacucugguggcuuug\n", + "gccggagguuuuguugugapucgguugucaagcagcggccaaucaaggcapauggaggcaagupucgcgccuggagcggagccucggccuccggagccgcagcugcag\n", + "cccuguauugagcugagauggcucgagccuaacauuccaugauccaggaucgugacagaugugcacaggcugcugcuguugcugcu\n", + "aagcagcggccaaucaaggcapauggaggcaagupucgcgccuggagcggagccucggccuccggagccgcagcugcag\n", + "agacgccugcagaccaucccagacgccggagcccgagccccgacgaguccccgcgccucauccgcccgcguccgguccgcguuccuccgccccacc\n", + "gcggaggagccucpupccpuugcugcgccguccuccacuacuggcuacuggcgcugcagcc\n", + "aagcggacpcgguggcggaggagccucpupccpuugcugcgccguccuccacuacuggcuacuggcgcugcagcc\n", + "uuuguguaggaugcagaugccgugguauaugguccuguaauugcacguaaauaacguuuccugcacgcucuccucuucagcuggaaagcgcucccugugcguaauggacug\n", + "ggaguucuguccaacaucucuuccaucaccgaucucggcggcuuugacccaguuuggcucuuccuuguggupaggagug\n", + "gcaccaucucpcuuuguguaggaugcagaugccgugguauaugguccuguaauugcacguaaauaacguuuccugcacgcucuccucuucagcuggaaagcgcucccu\n", + "gacauugccguggaaggaapagaaaccuugauapcccuuggaugaagcacugcagcuuaugcuaagaagaucaaggcccuguuagacuggaaacauucauuguaagaccuagugccauaag\n", + "accaucucpcuuuguguaggaugcagaugccgugguauaugguccuguaauugcacguaaauaacguuuccugcacgcucuccucuucagcuggaaagcgcucccu\n", + "gaaaggaaagaggucpagcgcucgcgagaucucggaccacccaaccugaaaggugcuuaggaaguugaaaggcccagaggaggccuccpcaa\n", + "uauauuugccuucccuccaugaucuccaacacuauccgauaaaguagaagcaacugagguaccgugaaagagaaaggagcuggaacugagaaaaagcagag\n", + "aaacugaaaggccaacgupagacaaagaagagccugaaagagccaaaucuuaccuucuggacc\n", + "gauucggacggagagcgcgaggacucggcggcugagcgcgcccgacagcagcuagaggcgcugcucaacaagacu\n", + "cgcgaaaggaaagaggucpagcgcucgcgagaucucggaccacccaaccugaaaggugcuuaggaaguugaaaggcccagaggaggccuccpcaa\n", + "gccucgcucuucgcgcaggcpaccgguccagcugagccugguggcggaaaggcugcggccccgcgccagapccgguggcuccuccpcuucugaggacccgcapagcgg\n", + "gaccgguccagcugagccugguggcggaaaggcugcggccccgcgccagapccgguggcuccuccpcuucugaggacccgcapagcgg\n", + "pcuguccuaaaaccagaagcuuggagcagaaagugaaacccuggugcuccagacaaagaucuuagucpacuagccggccaagg\n", + "aguuuucggcagagucgcgugucugagaagugacgcupaugucccupcugugccaggagcagugcuggcucag\n", + "gaauucuuccccagcgaggccgccpagagcaggacuupuuucuccugaguuacggcgccgaacgcccugagaaaaacgccuuuggagcaguuuccpauuaagcgaaagucupcugaag\n", + "ccuccggcacccacaggcccugaggcuccagugcccacaggcagagapcgacugaguccagcccaggcugagcccugcccagcuguacuccccagacacccacccaacccgag\n", + "ugcaugcupaccgcgacggacaggcugccgcaccccaggcccccagaggccagucuguuugccucccaacgccaucugacccag\n", + "gauuuuaagcuccaucucuugcuggcggugccaccuupcaagccauguggccauucugagcuguuuucucaucugcagaaugguupaucauuugugcuucaagagucaug\n", + "gugccaccgccccggacuguucccgcgcagcgaggucccuuccccpcccccpupccggucgagccgg\n", + "auuauuagcuccaucuaagagacaggaagacggagauuccaagaggcucapacuugcccpucaccuggcugaccaguggccuugucaggccuccacccag\n", + "aguuggaaggaggaggcagaccaguccuggugaguguccpuggcaaggauugcagucucagcgguggccucagcucucacag\n", + "caacuguugagcaggccucucugccuguggccuuccggccgguuuccagacgcccagguggccaacauuagaguccgcguagcagugugag\n", + "auugcaaguucaccugccacuaccgcugccgcgcgcucgucugccuggacuguugcpccccpaccupcupaacccgcgguggagcpacacgaacgug\n", + "gacgagccuguggagupagacaccugaccuuucucaagcugagauugagcagaagaucaaggaguacaaugcccagaucaacagcaaccucuuc\n", + "cagucuggauccupaggcgcugaagucpcccgcccuguggccccgcccggcccgcgcuugcuagcgcccaaagccagcgaagcacpcccaaccpcc\n", + "agacccacpcugcccuccccugcgcacuccccucgcugcccpcccggagcgcagcgcggccgcacag\n", + "gacccacpcugcccuccccugcgcacuccccucgcugcccpcccggagcgcagcgcggccgcacag\n", + "acuucgccagaucagacccacpcugcccuccccugcgcacuccccucgcugcccpcccggagcgcagcgcggccgcacag\n", + "cguagcaggauggaguaacgugaaaugcaauucuacagcaguuuuuacgucuuugcugccucguucguuggcuaccgagaag\n", + "acpcugcccuccccugcgcacuccccucgcugcccpcccggagcgcagcgcggccgcacag\n", + "aucagacccacpcugcccuccccugcgcacuccccucgcugcccpcccggagcgcagcgcggccgcacag\n", + "cguagcaggauggaguaacgugaaaugcaauucuacagcaguuuuuacgucuuugcugccucguucguuggcuaccgagaagguucaggapapagaugagaaagcagauuggaa\n", + "agcuucuaguagguuccagaaggcggcgcgugcgguupaacgcggagcggacggauucgauucaacpuuccggaccgcgcugcgcu\n", + "uccagaaggcggcgcgugcgguupaacgcggagcggacggauucgauucaacpuuccggaccgcgcugcgcu\n", + "ccgucguupaagaagaguuacucucaccagagugucagcaaupaccuucucuucggaugaggagacccuggaagacaaucuaag\n", + "agcgacacaggccucgaggcugucucugacaaguguucacaggaggupacgccucugcgcgaggaacgaggagcuacpccupcccgguuauugcc\n", + "ggccucgaggcugucucugacaaguguucacaggaggupacgccucugcgcgaggaacgaggagcuacpccupcccgguuauugcc\n", + "auuggcaagcuugcgugccccagcgacacaggccucgaggcugucucugacaaguguucacaggaggupacgccucugcgcgaggaacgaggagcuacpccupcccgguuauugcc\n", + "gcggcggcggcggcaccugcgaucagcggcupcagguuaugguagugcggacugcggugugagcagagcggccacpcccgccaugcgccggcggcccugac\n", + "ggcaccugcgaucagcggcupcagguuaugguagugcggacugcggugugagcagagcggccacpcccgccaugcgccggcggcccugac\n", + "agccgagccugcggaaggcggcggcggcggcaccugcgaucagcggcupcagguuaugguagugcggacugcggugugagcagagcggccacpcccgccaugcgccggcggcccugac\n", + "upcggaggagccuuggcupacugccuggaaacpcupccugccucggacgccgccggugucgcggauucucuuuccgcccgcuccauggcgguggaugccugacuggaagcccgagup\n", + "aaacpcupccugccucggacgccgccggugucgcggauucucuuuccgcccgcuccauggcgguggaugccugacuggaagcccgagup\n", + "pcupccugccucggacgccgccggugucgcggauucucuuuccgcccgcuccauggcgguggaugccugacuggaagcccgagup\n", + "ggcupacugccuggaaacpcupccugccucggacgccgccggugucgcggauucucuuuccgcccgcuccauggcgguggaugccugacuggaagcccgagup\n", + "gguccugcggcagacggagccgagccccaaccaggaapaguccgagcacupacuucaacgccaccaucuccaagacucgguuupugaaag\n", + "cugcauccucagcgccuagaacagcaccuggcaaacaauaggugcucauucaguauuuguccaauaagugaaugagugauuuacugagcauuuacucugcgccagucgug\n", + "guccugcggcagacggagccgagccccaaccaggaapaguccgagcacupacuucaacgccaccaucuccaagacucgguuupugaaag\n", + "uuugccggcugcggcaguagcucucgccugcpugguuugacaaggcuggcggcgccacaccagcgaccag\n", + "ggaguggccacupauuuaaagagcugccacuuccuuaggccuccagapcacupaagucacagcugcugapaccacucugcucccccgccuaagcc\n", + "agaaagaaggcgagagagaggagaccggaggucugagcugcagccacuacacaggccuggaauucuaccacapaauuug\n", + "cagcacgagucucuggaaaaagacaaccucgcccugcggaaggagauccagucccugcaggccgagcuggcgugguggagccggacccugcacgugcaugagcgccugugcccc\n", + "uggaauauuggugaacgauacuaaguuagauggaccuauauuacagauucuauucaugaacaaugcuauuucaaa\n", + "gcaauaucaucaagaaauagaggaauuuguaucaaauuuaguaaaaagauuugaggaacagcagaaaaaugauguggaaaagacuuccuuuaaucuuuugccccag\n", + "ccauccaguauugugcuagaggaggaccacaaaguggaagaguccugugccauuaaaaacaacaaggaagcuuucagu\n", + "guaccaucaagucuucagccacauuguuucucuagaapcaagaaauacaaguaaaggcaaaaag\n", + "agagcucuagagaguggugccgccuuccaaccuucuuccccaagcccugguggccggcuccgccucuucucgaaucuuuuccacagcccaaa\n", + "uuucauauuuauauugguguuuccuuauguacguauuaagaaucucupaggaggauguggaagaccugaauauauggacuaucuuuguguugcagaaauagauggccaagagacagg\n", + "ugguuaacagcuuaupcpagcucggcaaaacucagacuaaaaacagaaaaagagaaaagaaaggacaaauucgauacacccgcgucgguccuccagaguuugugaapuguaaac\n", + "gaagaagguaaaaucaauccaucucuacuccugaagugaugagguuaggagaaagaagagauacucaccuacagucuucaggaggaaaaag\n", + "gugugccuagauugaucgguauaaggcucacucucccgccccccaaagugguugaucguuggaacgagaaaapcc\n", + "gccugcgaaucccuccuuggccgcaaggucccccuuugcccagucggcpaggaggccguauuucugcuggccagagacgucgcgucccuggcupcauucagucacccccaggaaaggag\n", + "gaaacuuugaaaagcaccccaaagaacugaucapcccauauggcuucgagguuggaaapaaugaauugcaacguuguauccgaaagaggaaa\n", + "cgccugcgaaucccuccuuggccgcaaggucccccuuugcccagucggcpaggaggccguauuucugcuggccagagacgucgcgucccuggcupcauucagucacccccaggaaaggag\n", + "acagcugccupuaaggcccaagauggcugucuucgccuuaguacucgugugaaguuggcpacgguuccugucaucuucuupcuuauuuggugugcuguugaappagacuagagaa\n", + "uuggagaugugcaccuaaaggaggcgcaucupacggacacaucuggcacugaggcccucgccaccugccucgccaccuggcgacccugaccccaccacacugccuugag\n", + "gaguuggagaugugcaccuaaaggaggcgcaucupacggacacaucuggcacugaggcccucgccaccugccucgccaccuggcgacccugaccccaccacacugccuugag\n", + "gagcccguaggucaucuuggapucgucucaaguauugaacaaaagacggaaggugcugagaaaaaacagcag\n", + "gacagagucucagccucgccgcugcugccgccgccgccgcccagagacugcugagcccguccguccgccgccaccacccacuccggacacag\n", + "gagcpccggagcccaggccuggcgcggcggcgcccgccagguagaccpcgaggcugcgcgccggcpapaguccacugcp\n", + "gcccacucccaccgccagcuggaacccupacuacgacgucccucaaaccuugcuucuaggagauaaaaag\n", + "agcccgcagucggcucccgugcuugauggacuagaacuggapucccugcgcucgguuupacgcauauccugcuuupcgg\n", + "augagaaucugagacccaggaagauuucagaguuuugucaaggugacagaguuugaauuuaggca\n", + "ucucuuuuggaaaaguucuugauccccaaugcuucacaagcagagagcaaagucuucuauuugaaa\n", + "acagagucucagccucgccgcugcugccgccgccgccgcccagagacugcugagcccguccguccgccgccaccacccacuccggacacag\n", + "ggucccggauguugcugaacpagccccuuccagapagugacupcaagcgcagacpcugagcgaaagcuaag\n", + "ggcuuucucuacgugcuguugucucacupuuuuugucggagccccacgcccuccggccucugauuccuggaagaaapuugguccccucagcacccccagcaucccggaaa\n", + "acgcuggugugapcugcaggcgcagcuccggagcgccuagagcgcggcgcpcpagcuugguggagcaggagcggcupcauccuccugagacuccpucagacgcccacuccag\n", + "cgcuuucugcgcagcacaggcacccucgccugucacgccucccucuccucuucccgucucccagcguggaugapcgccugcagaucccggcuapcacggaccgccuaggccgag\n", + "pacuupccccpcgcugcuccuccgcaaccgauccaccgcauccuggcaacugagcaggcuccgccaccccuagagcacapccag\n", + "uugaaacagaguguaaccaaaggagauuucccagaggaagguaaaaugugagcugaauuuuaaaggaucaucagaagaaaaugaggauccuaggucaaagaaacagacauguaaggauagag\n", + "guacccaugugcuaacaaauaauaaagaaaaaauuucaagcaggaguuuuuacauuacuugaguugugaaaccuugaagaugauguaagcauuucaaaauccuugaacaagau\n", + "cuguguuuuguggaucuuuaauuauauauaacaauaguagucauuuuaaauauauauucugaaaucuuugcaaauuuuaacagaagagucgaagcucugcgagacccaauauuugccaauaaga\n", + "ccuucucupcagcagcucuguaagaaggaaugucagcuuuuacauaacguuccuuuccgcuuuugacacacugugugapuccaucuucuucugaucacagauggaguggaauggcuugaagaug\n", + "uuuacuuuggacauaucuuagacaccaaacagccaaacaugacuugaaggaucuacuuaaggugucuacauucccugccaaagacaagccaccuucuccaugcuccucuccccaaagg\n", + "ccuucuagaauccuaaaguugaccugaagccaagaagaaaauucuggugaupagaaguggagccacuuaaauuacuuac\n", + "gucugacuuggaguuuugugcuguugcacgugaaugcucuggaacugcccuaaucgacugaaaaugagccggcuacagucau\n", + "gcuuccuucucupcagcagcucuguaagaaggaaugucagcuuuuacauaacguuccuuuccgcuuuugacacacugugugapuccaucuucuucugaucacag\n", + "gcagucgcggcugcgcucpagagagcgcpacaupcgcggcggcccgccupccucgcaggcuccggagccccgag\n", + "gccagcccggcucugcgcugcgagaggccggacggcagucgcggcugcgcucpagagagcgcpacaupcgcggcggcccgccupccucgcaggcuccggagccccgag\n", + "ggcuccccgcuaggcccccucaguggccccuccuucucaccupucucpuccccuagugagcgagagcguccccagccgccuaccuggcc\n", + "agcccggcucugcgcugcgagaggccggacggcagucgcggcugcgcucpagagagcgcpacaupcgcggcggcccgccupccucgcaggcuccggagccccgag\n", + "ccaccuucagcucugguuggacagaagccaccccguccaggcucccaccuuguaggagagccgapucugguapagcggaggccgaggucucggccaccpaga\n", + "cccagcccccagcgaugcgupcgccuggagaapcgcacpcaggupugcugcpcccgcgcgupccgcgccggccpcp\n", + "auuauccuccuuauugacaaacagagcggucgcggcggcgacucucggcgugcggugauagccaagcc\n", + "ugcggccuuccccgcccccucccucccuccucccccgcccgcuuccgcccggcuuauuauccuccuuauugacaaacagagcggucgcggcggcgacucucggcgugcggugauagccaagcc\n", + "gcuuccgcccggcuuauuauccuccuuauugacaaacagagcggucgcggcggcgacucucggcgugcggugauagccaagcc\n", + "cccucccucccuccucccccgcccgcuuccgcccggcuuauuauccuccuuauugacaaacagagcggucgcggcggcgacucucggcgugcggugauagccaagcc\n", + "aguuccugagagaagaacccugaggaacagacuuaccucagcaacccuggcaccuccaacccgacac\n", + "ccauccapucuuuaaccagaagagagaggagagccucaggaguuaggaccagaagaagccapaagcagugca\n", + "uguggauccucaucugagaggapagaugaaaacacacccaccucacaggcuguugugaggacuaapugcggcagugccugguacaug\n", + "gccugcuupauucuggccccaugauuuapuuucuuuggagcccaucugagccuppcccuguggugguggaagagguccagccugcgguggugaaagag\n", + "agcuccagccgucguucucucgccugucuguucupacgguucagcgcggagcuucugcacucaacuugagcgcaguuuuuggcuuagagcucgcupaagugcag\n", + "gcuucacgcacggcugccccgagcugcuccpcugcgcgagcagguucgcgccgcagccgccuggcgcgccccagccccgcgccccgg\n", + "gacgcagugaacauauaugcauguacaguguggauccucaucugagaggapagaugaaaacacacccaccucacaggcuguugugaggacuaapugcggcagugccugguacaug\n", + "gaggagaaaguagagaaugaugccuccgcacccugugaacuuccaacaapaaggugacaugaaaggagcucagacaauuucuguccagcaac\n", + "auggaguuucgcucuuguugcucaggcuggagugcaauggugugaucucggcucacugcaaccuccgccucccpuucaagcgauucuccugccucagccucucgaguagcugagauuacag\n", + "aguauugcccpcugugagugcagucucaugaucuupucacugcaaccucuguuuccupuucaagugauucuugugccucagcaucccacguagcugagauuacag\n", + "gauugacuucuaaagacucuugguacgugaggaagaaacccggaagaggaagaggagagcaaaggagucap\n", + "agcuuccgguugcggccgaacccguagugacupcggcgcccgcpcugaugcgcccgcucuccccagccacgcuggcggugacuguggcgugc\n", + "aggauccucugcapagcuccgaguguccacaggaapaacuaucagcuccuggcaucuguaagg\n", + "uguugcgcgcgagccaccuccccugcuggcgcuuccugucgcuaccgcugcggcccapcccgcpagcccapcggugccpugagacaaggccpuuuggcucggauucaccgcgag\n", + "guaugaacgcagcggcggaccugugapauccgacuugccggcagaacuuacgcugcpaccccpcacuguugcugcugcpag\n", + "guguaugaacgcagcggcggaccugugapauccgacuugccggcagaacuuacgcugcpaccccpcacuguugcugcugcpag\n", + "aguccccucgcuguagucgcggagcugugucuguucccaggaguccuucggcggcuguugugucpagccugaucgcg\n", + "caccauaaaagcgccggcccuccgcuuccccgcgagacgaaacuucccgucccggcggcucuggcacccag\n", + "agugacaauuaaagauggcugcgcccauguaacaucacuagcgaccggugaccucuuuuucccccuugccuggcuccugugguggcaggcupcacgaggacc\n", + "acuagcgaccggugaccucuuuuucccccuugccuggcuccugugguggcaggcupcacgaggacc\n", + "aagccgcagcuuugaagccugagcggccgaacucggcagcuccaacccaacucggcuuaacuccgccucaccgagcccaguccaagacucugugcucccuagguuugcaacagcucucug\n", + "ggagcagaguccggcugccupcpcggcgcgugucugcagcugcuccpuagcccgcuaggcgcgccguccccagccccgccgccggcccucggugcgcccggccgccugcacccccag\n", + "gaucugcuccgucacccaggcuggagugcaguggugugaucacagcucacugcagccucaaacuccupcucaaccaguccucucaccucagccuccugaguagccpauuacag\n", + "gacagguucugguuaccacccaaugucacguggacagagcuagaagaccpauggccgugucuacccccacccccaggacuuguuggcagcccugccccuggcgcugguccuccuggcc\n", + "aggagcagaguccggcugccupcpcggcgcgugucugcagcugcuccpuagcccgcuaggcgcgccguccccagccccgccgccggcccucggugcgcccggccgccugcacccccag\n", + "ccucccuccacggaugcgcuuaaaaggcgguggcgguggcggcagcgcccggcgcccpcucaccucggcc\n", + "ugaagccuggagupucccgagccgcuacacuaaauagauuuaaugugcgcucupccgccaggaaagacgcucag\n", + "gccucgcuaggagcaucggcuguuucaggaccuggagaaaggcccccagcucuacccugagaggacgugcuccuccacgcuccuccgcaa\n", + "gugagcccggagcagcggcagcgucgguggcgucgagagcgagcpcccpaacggcgcpugguagaggaggagccgcpcucg\n", + "paggucpagcgcgcccgugagcccggagcagcggcagcgucgguggcgucgagagcgagcpcccpaacggcgcpugguagaggaggagccgcpcucg\n", + "cupaccggaagugcpcgagcgcpuccccpucugacaggagcagccugupcaccgcggcgguaguuggaggcpagapuccguagccgcgccgcccugccccgcc\n", + "gagcgcpuccccpucugacaggagcagccugupcaccgcggcgguaguuggaggcpagapuccguagccgcgccgcccugccccgcc\n", + "gugcpcgagcgcpuccccpucugacaggagcagccugupcaccgcggcgguaguuggaggcpagapuccguagccgcgccgcccugccccgcc\n", + "agagapugcggagcpcggaagaggcgucugugucgcagcuuggucucagaggagcaucgcup\n", + "aapcgguggcgcagagapugcggagcpcggaagaggcgucugugucgcagcuuggucucagaggagcaucgcup\n", + "cuccguccuccucaggcccccuccgccuccggcuccguccuccucuggcccccuccgcccccggccccggccccacggcp\n", + "cuccgccuccggcuccguccuccucaggcccccuccgccuccggcuccguccuccucuggcccccuccgcccccggccccggccccacggcp\n", + "gcccccuccgccuccggcuccguccuccucuggcccccuccgcccccggccccggccccacggcp\n", + "guccuccucaggcccccuccgccuccggcuccguccuccucuggcccccuccgcccccggccccggccccacggcp\n", + "ggcccccuccgccuccggcuccguccuccucuggcccccuccgcccccggccccggccccacggcp\n", + "guaagccgcguagcagauacgcugccagcaacacpcgaccaugcugaugagcaggacggcgauuccag\n", + "ggaccggaagaguccuugaaccaaaauagcucggcpcacuuccpccggcgcccagaguuccpapugcaggcaggagapaaaggcagcagcggcggcagcuggagg\n", + "ugccuupapccgugaccacccgucugucgcccgaggcggccgccgcugcaccuucaccgcguacccpacccgcccgcccgcpag\n", + "cccgucugucgcccgaggcggccgccgcugcaccuucaccgcguacccpacccgcccgcccgcpag\n", + "pccgugaccacccgucugucgcccgaggcggccgccgcugcaccuucaccgcguacccpacccgcccgcccgcpag\n", + "augcggugaccugccagcaccugccgcagccuucguccpagucgccccaucucuccacgcaucpcccugugccccuugcugcugcagccpcacc\n", + "agaugagacugcaupcpaacuagagauggaggacuuucccgcgcaapacaggcuggacugaaagaggacacpaagaacaaagacuuagacucg\n", + "aagcccucggaugguggcccuugcaugcuucaguucaugauguuggagacuauuuccccacccuugcggaaaaac\n", + "cuucucucugugccaugcagcuacugccapauggaggauggcpaauuggcaacuaaagacuguccuccuacccucuucaguguguccuucagcaauaugaaguuaaaaccag\n", + "ucuugcucuguccccaggcuggagugcaguggcacgaucuuggcucacugcaaccuccgccucacpuuccagcgauucuccugccucagucuccugaguagcupacuacag\n", + "ggcaacaggaguaguucacuccgcgagaggccguccacgagacccccgcgcgcagccaugagccccgccccccgcuguugcuuggagapcpaccuggagagag\n", + "guugccggaagaaguggcgaaguuacuuuugapuauuugaguagcggcggugugucapcuaaagaggaggacgaagaaaagcagagcaapaacccag\n", + "gugacgcaapcpuugccggaagaaguggcgaaguuacuuuugapuauuugaguagcggcggugugucapcuaaagaggaggacgaagaaaagcagagcaapaacccag\n", + "ggagguppaaacuacauggcauggaggccgugaaggcagagcaugauuaaaggagaaupcccuaccuagaaaaagcag\n", + "ugacgcaapcpuugccggaagaaguggcgaaguuacuuuugapuauuugaguagcggcggugugucapcuaaagaggaggacgaagaaaagcagagcaapaacccag\n", + "gacgcaapcpuugccggaagaaguggcgaaguuacuuuugapuauuugaguagcggcggugugucapcuaaagaggaggacgaagaaaagcagagcaapaacccag\n", + "capcgcpcgcccgcccugcucugugacgcgcggcccgaggcgcacgcapcucacaccaccuguccuggccuccgacccpccgacu\n", + "agccgaagcggcuggagcpcggcaaggcgaggcgaaagcugcacapcccuacgcggccgccucagc\n", + "gaugagucggacupcacgauugcauugupapaggcupcucugugagacgugcuccuggcaccgccagcugcuacuuggcccucgccgguggcccaccag\n", + "gacaaugcccccccgcagccaucucaugcccaucgccacugcccupcagcugaacugagcguaugugccacgccgcccaggagaccccucugcugcaccacuucaug\n", + "gacaaugcccccccgcagccaucucaugcccaucgccacugcccupcagcugaacugagcgu\n", + "agcagagaagcugcuguccuuccaccaccagcaccggaccaccugcuccaagaccagccuccuppaccaggcacccggccuucacuggcacccag\n", + "cacuagcagagaagcugcuguccuuccaccaccagcaccggaccaccugcuccaagaccagccuccuppaccaggcacccggccuucacuggcacccag\n", + "acuagcagagaagcugcuguccuuccaccaccagcaccggaccaccugcuccaagaccagccuccuppaccaggcacccggccuucacuggcacccag\n", + "gcccupaagcccgcaagaggccucagcgguggccguccgagagccgagaggugapugcccccgccucaccugcagapccguuccpcucgaacccggcaccuuccgg\n", + "gaaaacpaucgcacgcuccguggucuuuguguugagaucuauccagguuguggccugugcapucccccuucuuuccuauggcugaagaauauggccucaguuuccucuuggagcagg\n", + "accaggagucgguupcugagacccugagccccaacugucagaaggagccugaggcugagguggaggcupaguuupcugugg\n", + "guccuagcuuacucugccaccacugcccggcaggaggaaguuccccagcagacaguggccccacagcaacagaggcacagcuucaapaggaguguccagcag\n", + "gaucucauagaucagaacauacuggagccuguaacccgugcacagapuguggauuacaccaacgcuuccaaca\n", + "auuauuccuupccugaaugacuugaauguuuccccgccugagcuaacaguccaugupugauucagcucug\n", + "aguugagcuupacugcagcugupagauuucagugcauugccuccccupugcucuucaucuugg\n", + "guagaccuaaaaacaucugagagccuagaagugcacagcagugugcagauagauugagaggacuuggcucugcagguggacaacacucu\n", + "gcagucuuucaguugagcuupacugcagcugupagauuucagugcauugccuccccupugcucuucaucuugg\n", + "ucaguauaaaagauuaaacucuacagaagaaugcaaucaagugauggcuuuuccuuuagaauuugaau\n", + "guaccuguagcugcggcgcugaggucggaacgucugcgugugugcpcugguuuuguggcggcugcugcuagagcuggagcauuugccgg\n", + "aucccaagcacugcaaguccagaugcaacpagccuggcucaapacgacaagauccagccggaaaguguagaagucacaccccaauggcpauagcagccccugugugugagcaccccucc\n", + "auuccuccaacpcaggucucagcgcuccucccccugcuccgcuccucugcapcccaggcgcccuuggccuuaggacccaacuucucuuaccgcc\n", + "ggugaugaccacaccugccggcuccggcagcggcuucggcuccguguccuggupccuguccccggcgcuggaccugcaggcugaaa\n", + "agugcugcacugagcagagaggaapcgucccpauauuuggaggauaaaggugupcaag\n", + "gacucupcagcgguuguggagugccgcpuccacagugcugcacugagcagagaggaapcgucccpauauuuggaggauaaag\n", + "apcpacucupcagcgguuguggagugccgcpuccacagugcugcacugagcagagaggaapcgucccpauauuuggaggauaaaggugupcaag\n", + "auugcuugauuccucgaaaapcpacucupcagcgguuguggagugccgcpuccacagugcugcacugagcagagaggaapcgucccpauauuuggaggauaaag\n", + "acggccuucccacupaacacaaacuugcuggcpaagagcccggaaagaaaccuguggaucucccuucgagaucauccaaagagaagaaag\n", + "agccugagugcuggcugaacugagaggaacapuuggugccuggcacugguguugcuccauucaucucugaggucucacagccccagc\n", + "cagaagccccagccucgaccuagcccacccucucapccacagugcagaagccugcacaccugccaagucucuccgacuccuugcagcugcugucagc\n", + "cuuccucggcuggauuuaagguugccgcuagccgccupaauuuaapacccacacuaccuucccgaaguugaaggcaagcggugauuguuuguagacggcgcuuuguc\n", + "uguguaagcugcugagcacagagcuacaggcggaacugagucgcaccggucgaucucgagaggugcuggagcupcaggugcuggauacaggcaagaggaagagacacgugccuuacagcguuuc\n", + "agagacaaggcuggaagaggccuuagagaauuuaugugagcggauccuggacuauaguguucacgcugagcgcaapcucacugagauaugccaag\n", + "agaaaauauucucuuuggaaupaaauccucugcuugacaucucugcuguaguggacaaagauuuccuugauaa\n", + "guuugaugaacuugugaaaaaauucaaagucgaauaucaugcugguggcucuacccagaauucaauuaaaguggcucag\n", + "ggcagaggupcuguagagccaaagupupagcgcgaagauggcagcugcugaggaggagccgaagcccaaaaagcugaagguggaggcgccgcaagcgcugag\n", + "agucgcugagugccugagccpaagcaguugcugugguaccugcugcugcccgagcggacguagagcaucggacgcpcgccguggcgcupcaggapcgaagcc\n", + "gaugcgaagapcpaccagagaguggauggcagaggupcuguagagccaaagupupagcgcgaag\n", + "gagugccugagccpaagcaguugcugugguaccugcugcugcccgagcggacguagagcaucggacgcpcgccguggcgcupcaggapcgaagcc\n", + "gagcaacaccuccaacuaugucccuauuucuuggacagcuuccuagaggccagaguucacaguggauuaaucgcaag\n", + "ggaaggcagagaaaauccaucaaguuguacccuacccacccuuuggugacuuuuccaagaagcupcuaaguuccaggagaaagcucu\n", + "agaggcuucuaaacaaccuacccuccuuccccauuuucugugguccaacuacccucggcgaucccaggcuuggcpcaccgccuggccucucccguuccuuuaggcugccgccgcugccugccgcc\n", + "ggcuucuaaacaaccuacccuccuuccccauuuucugugguccaacuacccucggcgaucccaggcuuggcpcaccgccuggccucucccguuccuuuaggcugccgccgcugccugccgccaug\n", + "cggcuuagcccagagccuggccuccucuguaagaguggaaaaccupuuccuucugcccucaucuuauuaguagcugugaupcacacacucagccaagcacugag\n", + "apcggagcgcagcugcgccpcuupcgccupccgccgcuccccaccgucguuuuccccaccgaggccgaggcgucccggaguc\n", + "ggaggcgcpccacccccaagccgagccpupacggcgcgccuggcgaccgcgcacugagacugccgugccggacccccgagccggagccgagcgcgccgaggccpcc\n", + "cagcagcagcagccacgacgaggcccccguccugaacgacaagcaccuggacgugcccgacaucaucaucacgccccccacccccacpc\n", + "agugguggacaugacaacagagucaacugcauacaguggcaucaagacaguggcuguuuauauaguuguucagaugauaaacauauuguggaauggaacguacagacaugcaaaguaaagug\n", + "accgacuguguggaagcaccaggcaucagagauagagucuucccuggcauugcaggagagaaucugaap\n", + "pcagugcccaaaggaaaugccacuaaagaauucaucgagaguuuacaguugaagccupcaggugguguacaagugccccaaaugcugcagcaucaagcccgaccgagcccaccacugcag\n", + "aaaugcccggcgaagccacagaaaccgucccugcuacagagcaggaguugccgcagccccaggcugagacag\n", + "uuguuucucaucuuapucuggaacagaaucugacagugaugaaucaguaccagagcuugaagaacaggauuccacccaggcaaccacacaacaagcccag\n", + "cuggcggcagcagcugaaauugaugaagaaccagucaguaaagcaaaacagagucggagugaaaagaaggcacggaag\n", + "gugacaagcaaguguuggacuuaaaacaccgucuuuccccuccugguaccccaaagucggcaaacguaguccaggaggccccagcccagccagu\n", + "ggucuggaacagaaucugacagugaugaaucaguaccagagcuugaagaacaggauuccacccaggcaaccacacaacaagcccag\n", + "ggagcaguugcaguguugapcggaagaggagugcgucuuguuuupaacugcuucacaggauccagaaaagg\n", + "cuucugcaacaggcgupucacgcucucgcucggucuuucugccgccaucuugguuccgcguucccugcaca\n", + "gccuccuuuuuauucccuuccuucagaaaugcccggcgaagccacagaaaccgucccugcuacagagcaggaguugccgcagccccaggcugagacag\n", + "agucaaggagugapacapaaugaacaugccauggcacapcaggaccugcugaaagacagacaggcccagcagcguagagaagcg\n", + "uguccacauacgapacapcugaggaugaggagaacccupacccagaagaccgugccuugccuggaaguccugccuguaggccugaaggacuugcccuaacagagccucaacaacuaccug\n", + "gaggagccgagugcgcgcucpcaggcggcggcgcggagcggugcggcggcpaggcggaggcgapugcg\n", + "gcuuccgcucpcpcupcucccpuagguccgcggcugcugcugcguccgacccccggccggcgcpu\n", + "pcpcupcucccpuagguccgcggcugcugcugcguccgacccccggccggcgcpu\n", + "auugaucucauuugccagcaaaauaauauuauaguauuggaagauacaauaaaaaggcuuaaaucu\n", + "auaauuuuagauacugaaaaagcacaaaauaaaucuccuucuagacuugauuccuuugucaagacuuuggaagcagacaaagaucacuauaagagugaagcucaacauuugagaaag\n", + "acuugauuccuuugucaagacuuuggaagcagacaaagaucacuauaagagugaagcucaacauuugagaaag\n", + "gcgcaccpccupcgagcpacggaagcaaagcupcgccpagguggaagacgagccccacuccg\n", + "agugcaucggccccpucuguccpcguugcpauupccupaacgcucggcccccggcagccgagaagcccgugacupcugagcagcaccaucccagcccupccugcugacug\n", + "cgaacccggagcguugcuauccuccaccggacugucaggcucugcgcgccccgcggaggucggcggcgaccagcagcgacugcggagcgacggcpcggccccpc\n", + "aguuccaupauccuauuacagcugccuacuucccugaugacuagapcaccgccaagcaguguuuaccaaaaucaacaggccagagcacagcuggaag\n", + "gcgccgagguacuaggcagagccguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "gccccagcaaccaagucgcaccuggagcuguccuagcgccuaguucucucccggccgcagagcuggccgcccapagucgcagaguuuggaagaucucucuaacaccucucggccaa\n", + "auggugacuguacaagaacaucuucuggaaucuacgagagaaauggaauagguauucauaccacuccuaaupauugucuacacaggaagcuggaaagaugacaag\n", + "ccuggagcuguccuagcgccuaguucucucccggccgcagagcuggccgcccapagucgcagaguuuggaagaucucucuaacaccucucggccaa\n", + "uuuuucuccucuguuuagauggugacuguacaagaacaucuucuggaaucuacgagagaaauggaauagguauucauaccacuccuaaupauugucuacacaggaagcuggaaagaugacaag\n", + "gagaggugcccggucgccccagcaaccaagucgcaccuggagcuguccuagcgccuaguucucucccggccgcagag\n", + "cucccggccgcagagcuggccgcccapagucgcagaguuuggaagaucucucuaacaccucucggccaa\n", + "auggugacuguacaagaacaucuucuggaaucuacgagagaaauggaauagguauucauaccacuccua\n", + "pcggugccaggupcuacgcggcupcggcugcggauaucgccuuapacgcguugacauucacuggcuaguccaccgcucucagucggagaccacauugccuc\n", + "cuuuugaguuccuggucucuguggccuccugaccuacaugcauupagauccacagcuaagacgccaggacucccuggaagccuagaa\n", + "ggauaagccccagcuccpuccucgacucugcugccucgccuggacuccugauuccucauuccucuccuuuccgucccag\n", + "gcggcgugcaggaccagcggcggccgugcaggcggaggacuucggcgcggcuccuccupugugaccccpcgcgcccgccgcgcgacg\n", + "gcaggcggcgugcaggaccagcggcggccgugcaggcggaggacuucggcgcggcuccuccupugugaccccpcgcgcccgccgcgcgacg\n", + "ccpugguuugcuuaggugaggugcgguggugugcuuuuucucuapuuupuuggaugguggcccpccuuccgaguuuccauga\n", + "gucugugacaagcapaacaaggcaacggacggcgcaacccagccccggcugacggacgcuggcgacucagac\n", + "pupuccuagcagcgcggccugacpaccaaggcggcpagucugcggucguucccucggcuguggaccpcggcacgcacgcggugcapuaac\n", + "gcggccugacpaccaaggcggcpagucugcggucguucccucggcuguggaccpcggcacgcacgcggugcapuaac\n", + "gcgcggccugacpaccaaggcggcpagucugcggucguucccucggcuguggaccpcggcacgcacgcggugcapuaac\n", + "puccuagcagcgcggccugacpaccaaggcggcpagucugcggucguucccucggcuguggaccpcggcacgcacgcggugcapuaac\n", + "aauuuugauaagcugaauguaaggacaacacacuauacaccucuugcaugugguucaaauccucugaagagagagauupacuauaucag\n", + "gcaaagaguaugupauuguccggcugcacaaugcuauugaappacccagcuuucuagg\n", + "gcccuagaaacucugacaggugccuuauuccagcgacccccacuuauugcugcaguaaagaggcagcuccgagugaggaccaucuacgagagcaaa\n", + "agugcgcpupupuccuagcagcgcggccugacpaccaaggcggcpagucugcggucguucccucggcuguggaccpcggcacgcacgcggugcapuaac\n", + "ggcugaggccugccuggcapuggaggaggaagcugcccuugcccccggcpcpagagacccccaucaccucuccccugccccugcagac\n", + "cuggaaagcggccggauguguggaggcagagaggcagcauccaggcgcuggucgccuucpugcpagg\n", + "cgcuucccgccgcccgagcuucggaaacuucccggccgcgacgcapaaccggcgcggagaaccgagcagagcggag\n", + "guucgugcguggagcagucpcuggaggcgaggccgccpcpcapuuguggcgcggcaagcggcpccagcgacggcgcga\n", + "agucpcuggaggcgaggccgccpcpcapuuguggcgcggcaagcggcpccagcgacggcgcga\n", + "uggaggcgaggccgccpcpcapuuguggcgcggcaagcggcpccagcgacggcgcga\n", + "pcagugcuucagucpuggagcugcuuaaaaggccupaucacacccuuupaacacauccaagcuuaagacggugaggucagcuucacauucucaggaacucuccuucuuugg\n", + "upaacacauccaagcuuaagacggugaggucagcuucacauucucaggaacucuccuucuuugg\n", + "agcuuuacuccugccagcuupaaaaggccggagaaggugaaauucugugugcucccuccggcgagagacuuugucagcucccgcacaguaac\n", + "guggaaguccaagaauccgaguggaggcucaccgaggcgaapccaaccaupaaaggagaguggaupacucag\n", + "auccugaauaaagucaaaacucaaccaacagguggaaguccaagaauccgaguggaggcucaccgaggcgaapccaacc\n", + "ccugccagcuupaaaaggccggagaaggugaaauucugugugcucccuccggcgagagacuuugucagcucccgcacaguaac\n", + "aggccggagaaggugaaauucugugugcucccuccggcgagagacuuugucagcucccgcacaguaac\n", + "upaaaaggccggagaaggugaaauucugugugcucccuccggcgagagacuuugucagcucccgcacaguaac\n", + "auccugaauaaagucaaaacucaaccaacagguggaaguccaagaauccgaguggaggcucaccgaggcgaapccaaccaupaaaggagaguggaupacucag\n", + "gcuupcgcuggcaccuccucuuacagcuuuacuccugccagcuupaaaaggccggagaaggugaaauucugugugcucccuccggcgagagacuuugucagcucccgcacaguaac\n", + "cuuuauucaaaccagauccugaauaaagucaaaacucaaccaacagguggaaguccaagaauccgaguggaggcucaccgaggcgaapccaacc\n", + "agaagcpcgaauupcaccgguggcggcugcpcaguuugaauuagacucupcuccagcccgccgaagccgcgccagaacuguacucuccgagaggucguuuucccguccccgagagcaag\n", + "cgugugcpcgcpcgcpcgcpcgcpcgcgugcpcugcgagccpaggcggcggcggcgacggcgacggcggcggc\n", + "cuucggauguggcuugagcuguaggcgcggapccggagacgcugcagacccgcgacccggagcagcucggaggcggugaa\n", + "aggcgcgapcuggcugcupccgacgapcggugccaggccgupuccuuagucaagugacgcgaagcggccggccupcgccgacugcagagccpaggcuggugguc\n", + "pcpccpcpcgcgcguccuuccaggcagcucggucgcuugugcguuccgcuccggccgcccuuugcgcuuggauccacuuccccaucuguaacgagguguugagacgag\n", + "gcuugugcguuccgcuccggccgcccuuugcgcuuggauccacuuccccaucuguaacgagguguugagacgag\n", + "guucugagucccgcccggcgugcgcggagcpcagccagcagcggaggcgcggcgcgcagcacacccp\n", + "ccpcuggcpagugcaguucugagucccgcccggcgugcgcggagcpcagccagcagcggaggcgcggcgcgcagcacacccp\n", + "agucccpcuggcpagugcaguucugagucccgcccggcgugcgcggagcpcagccagcagcggaggcgcggcgcgcagcacacccp\n", + "auagcaaccggcucccuagcuaggcgcccccpuugccapccgcaccagcuuucccgucccpccagcgcaggcgcucaggccucggaggcpcg\n", + "acagacacacuuggacgauuccugcagaaaucagugaggcagucuccucccapcuuggcgccuggcucgaggcgaggcugccggcccggacgcugacugcccagugccacagac\n", + "ggcaucaacacggcggcggcggcggcggcuuccaacaggcucupcgccgagcggacaggaacgcagcacpcuccgaggcpucupuguugapcgacuggagcc\n", + "caacaggcucupcgccgagcggacaggaacgcagcacpcuccgaggcpucupuguugapcgacuggagcc\n", + "agaaugcaccuggcaucaacacggcggcggcggcggcggcuuccaacaggcucupcgccgagcggacaggaacgcagcacpcuccgaggcpucupuguugapcgacuggagcc\n", + "pagccgcgcagcgccuacpaguccggcggcagcagccgguaccggcaaccacpcagcucucapaaucuccgucgugaggccagaggcuccaguccccgcg\n", + "aagcugccgaggugcuaggaguugccgaagcaaguccggaagcuaccgagcgaguccggaaguugccgaaapagcagcpaaggagg\n", + "cccucaaccaaaauggcgcuagcucggaagcugccgaggugcuaggaguugccgaagcaaguccggaagcuaccgagcgaguccggaaguugccgaaapagcagcpaaggagg\n", + "acacaaccauuugccuggccgccuggcagcuguucaccuggcccucugcccuccccgcagaacpuuuggugauucacagaaaccag\n", + "gccacguuccacuaccggacgcugcacagugacgacgapcaccgugcuggacgacagccpcucguggcaagccc\n", + "ggcggucgguggcapugguagcggcggcggcgacgguuucgupccgcgcgcugcucugugagcggcpuggcagcapacuccugacacuuccccuuccccaccgaaccgcg\n", + "aguuucgcucuuguugccccggcuggagugcaaugaugugaucuuggcucaccgcaaccuccgccucgupuucaagcaauucucuugccucagccucccgaguagcuggauuacag\n", + "aaugaugugaucuuggcucaccgcaaccuccgccucgupuucaagcaauucucuugccucagccucccgaguagcuggauuacag\n", + "pugguagcggcggcggcgacgguuucgupccgcgcgcugcucugugagcggcpuggcagcapacuccugacacuuccccuuccccaccgaaccgcg\n", + "cuacaguguagccuccgccucccgauugacuggccugcuuggcaaggcaaguagcggcggcgcuucaag\n", + "gccaucaccaucgaggcugagccaagagcugauggcagccgccggaccacccgcuaugacaucgac\n", + "aaacauagagacccccaaaapaagcagaggagagaaagucccacacccagaccccgcgagaagag\n", + "cgcccagccugccagccgcgcugcugcugcuccuccugcugupaccgcugaccgcgcggcugcuccgcucuccccgcuccaagcgccgaucupcacccgccaccagc\n", + "gcccpucggcgcgcccagccugccagccgcgcugcugcugcuccuccugcugupaccgcugaccgcgcggcugcuccgcucuccccgcuccaagcgccgaucupcacccgccaccagc\n", + "gcugcugcugcuccuccugcugupaccgcugaccgcgcggcugcuccgcucuccccgcuccaagcgccgaucupcacccgccaccagc\n", + "cugcugupaccgcugaccgcgcggcugcuccgcucuccccgcuccaagcgccgaucupcacccgccaccagc\n", + "agacagccucugcugcaugacacgaagcuugcuucugccuggcaucugugagcagcugccaggcuccggccaggaucccuuccuucuccucauuggcug\n", + "agccccggccuuuuucuagccaggcucucaacugucuccugcguugcupaaguucuggaaggaagc\n", + "gcuccggcggcuccugucagcggcpugcggcggaucccapcagccuucpcggcggcgcugccuggugcgucgcggcgugguccuccggcggcuguccpcgguaggaguuggcugcp\n", + "gcaguugcgcccggcagcgacpaaacgucucugaauuagguguuccgcucgccucuugugcgguguggagcugcgcgccccccgccgaggcpcccag\n", + "gcaguugcgcccggcagcgacpaaacgucucugaauuagguguuccgcucgccucuugugcgguguggagcugcgcgccccccgccgaggcpcccagguacaggcugccg\n", + "ggaggaagugccgaucggcugcupcgaaaapcgccpccgcucuagccggugaggccggcpcucucuguggcugcggcupaaaccgcgcggaggag\n", + "cgccupccacggcacccucgagcgccagccccgcgccccacccpagcagcgagccaccggcgcgcuccccaggagccccugcaggcgccgg\n", + "gaaaapcgccpccgcucuagccggugaggccggcpcucucuguggcugcggcupaaaccgcgcggaggaggugcccggccpaccag\n", + "acuuccggaagcggcggcgcucpaggaagugccgaucggcugcupcgaaaapcgccpccgcucuagccg\n", + "pcgaaaapcgccpccgcucuagccggugaggccggcpcucucuguggcugcggcupaaaccgcgcggaggaggugcccggccpaccag\n", + "ggcggcggcggcugcucgugucggcuccpcggcccccgcgccgcagcccgcgccguguccgcggcggagccgcccag\n", + "cccguaggagccucucucccuacugcugcuacacaagacccugagacugaccugcaggacgaaacc\n", + "gcupuaaaucccagagucucagccgccuaagugucuuccccggaggugagauuaucuccgccugugcuggacaccucccuuucuccugcagcc\n", + "gaaacccuuuuccaaagagaaaugaagaagaaaacuguauguacccuaaauaupagauaagaaguaugaagacauggaag\n", + "agcucaaggagguggcagcaucaugcuucuaaugcaaagguccuuagaaggaugguucuuaccaugaauggcucguaccaugaug\n", + "gguugaaaaauaccggccacagacccugaaugaucucauuucucaucaggacauucugaguacca\n", + "uucagaaguuuaucaaugaagaccgacugccacacuugcuucucuacggucccccapacaggcaagacaucuaccauccuagccugugcgaaacagcuauauaaagacaaagaauuuggcucc\n", + "gagaguugcuuuugcgcgcgaacuguaagugccapucucapucaggucgcggcuggucacugugcaggcgcuupugacgcgacgaucucagcggaucuggucaccuucgucuccccgcc\n", + "agacapucucgcucugucgcccaugcuggagcgcaguggugugaucacagcucaguguaaccucaaacauupuucaagccauucuccugccucagccuccgaagaacupacuuuuagag\n", + "aacpacgcauaagcacgcgaggcgcgcgguggcgguuuggaucuggccccupaaucgcguu\n", + "ggagacagcugugccuagcacugcaggcuucaucagaccacagagcacagccccuccauggaacugcugcaga\n", + "uacuaaaauaggugccauuuuaaauucccagacaaggaaaaaccaaggauuagaaauuaaguagcuugcccaaggccacacauca\n", + "paguugauuugcacugcuccpugucggcuccggcpacpcgguucugcguaccccucucc\n", + "paagccacugcuacccucaucaggaapcagacacaagaagcaccaguucuauuugcugcuacaucccggcucucg\n", + "caccgapcucauccauccgcagagcapcagupaggagacgccaugacccccaucgucacaguccugaucugucucg\n", + "gaaagaaaguuuaucagaauuuuuuaaaccugucucagaaauaacaacauauuuuaaucagagauuu\n", + "gacugcgcaugcgcgucacuagacgacacggcugucuucuuuccuggagaauuucucaaggacugcuggcuggaaacuuaacggcuaauguggaucugaccguaguuugccaaauuaagaaaacg\n", + "uuuuuacccuguugaagauuugcuuuaacuucaaaagugaugacaagaaaguauggacaccccuucaggaccaaccugauaagucacug\n", + "guuuuucuuucguuuaaagaugacacacucugaaauuaauuugauuuugagauuugagaacuuggacauacauacuuccuauggaag\n", + "gagucaugcuauacugaaaagacacuucaucaagauaacucupagaagcagaaaacccugugccapacaggaaagauagga\n", + "puuauuuuuagcaaucuggcucacacugapcuuccugcucuauucagcaaaugugcaaauggaugcugcaggaccguaacaguagacauugaugaag\n", + "gucacuagacgacacggcugucuucuuuccuggagaauuucucaaggacugcuggcuggaaacuuaacggcuaauguggaucugaccguaguuugccaaauuaagaaaacg\n", + "cuauuugagaaagucaaagaaguuuguccaaaugugcaugagaagaucagagcuauuuaugcagaucucaaucagaaugacuuugccaucagcaaagaggac\n", + "gugguuagacgaugcuauuauugacgagauuacacccaagcugaucagagauuggcccaauauuuauaccuacaccaaggccuupagaa\n", + "gacuggagccguuuccuuguggcuggagcgcuucccguagccucpaaggagcaggauuuagaggaccacuaguuggaccccauccucgugcuggaggaacag\n", + "agccggccpccupaacguggcugguuggaggagguagaucacccuuucugcpacgauuucgucggugguag\n", + "cggccpccupaacguggcugguuggaggagguagaucacccuuucugcpacgauuucgucggugguag\n", + "pccupaacguggcugguuggaggagguagaucacccuuucugcpacgauuucgucggugguag\n", + "ccpccupaacguggcugguuggaggagguagaucacccuuucugcpacgauuucgucggugguag\n", + "gcgcaugcggaapcgguagccggccpccupaacguggcugguuggaggagguagaucacccuuucugcpacgauuucgucggugguag\n", + "paacguggcugguuggaggagguagaucacccuuucugcpacgauuucgucggugguag\n", + "ggaagcuggugcuggacagcuggcgccggcagcagcggaccggcpagacggcggcuupagcuggcugugcugcag\n", + "gagcugcggcagccgccguccuugcaccuaaggaaccucugcugccagcccuuccucacuuuuggaa\n", + "gaagcuggugcuggacagcuggcgccggcagcagcggaccggcpagacggcggcuupagcuggcugugcugcag\n", + "accggaaguucucgccuggcccaggcgcpuccaagaugguggcgcuaggagccgcgacccagugauagcggccguggapcccccgaccgagcpagguupuagccuggag\n", + "auuccgcgcgaugacgucacugcaaggcgccpacacguuggcugcguuuucggcpcuucccpuacaaaa\n", + "cgcgcgaugacgucacugcaaggcgccpacacguuggcugcguuuucggcpcuucccpuacaaaa\n", + "gaugacgucacugcaaggcgccpacacguuggcugcguuuucggcpcuucccpuacaaaa\n", + "pcuuccuggagcccccgccccuggccpuucugccugacuccccuuucauucccuugcaggcugagcagugcagacpccupcaggc\n", + "cccacgcgcgcgcgcucgcgcaccacgcgccccgcgcggcccgcccggaucguggccucucgagagcaag\n", + "agcgcuggacgcggcuagagcupcugccgcgcccuccaccuccuucuccaaaggccuccccggaccccuggcucpcccagccugcgacuccgcc\n", + "gcagcgcuggacgcggcuagagcupcugccgcgcccuccaccuccuucuccaaaggccuccccggaccccuggcucpcccagccugcgacuccgcc\n", + "uguugucuguguugguggagauggaucugcuagcgaaguagcccaugcuuugcuucugagagcucagaagaaugcup\n", + "uuccccapaguccugugaaaggaagcuugapugapaguggugccaggacuacacccucauaugccccugcccucaggaucacuguggucacauggaacgupcacugcc\n", + "aggcugccpcugcagacauggapccagagcagcapcagcaggaggccapacccpcuggccupuucccugcccaugccccapuguugcccaaacupcacccuccaag\n", + "acagagaaacugaggcgcupcagagagguacuugccuaaggucacacagagcupcuuugaaucuacacagccagucucagcucccagcucuugcuccugaguggagcucupaaugg\n", + "guggacucaaguuuucagcucccagcaaagaagaacgcagcccuaggacccucggaaccaagguuggcucuggcaccuguapccacpcagcu\n", + "gccccugccaggaaugcaccuuuagcccaggccugcucagugagcuccgccgacagccagcccugcuccucccgccaugacccugcagaccccucupcuuccaaguuccupcugcagugaac\n", + "gugcccgucapugaugguugaaguccucacuacucagauggucggaggapuaggacacccagucagcugccggacacucag\n", + "agacccagcacuggcugcugcuagucagaupuagcpcapccggapccacccucccagcugacccagccuccupccgcuucuuccaaaccagcapuagaaag\n", + "aggcpcuccupcggagccauaccugupcpacaupaaaggapcccgapcggagcuacaauagaaapccaggaggugcugag\n", + "uaccucccccuugaupuggcpaucccggagccaacgcagaccggacgucggaacgccgcuuuagccccgg\n", + "aggcucugcaauggcugcupacugugucuguugcaaggaggcuccccugcagugaggagccpcacugcaagucuguuccauagcagcccuuuuugcaa\n", + "aggaggugcugaggcgaggagaggccgaacuccaapacgacgcucgcggaagcagagguuup\n", + "cgacugguuagacagauuuuguuuuucuucuucccgcgcgcuuuagcucccuguccuuuggucgcauuugupcgcgcggcacgcagccpaggccgaggacucggaguucaccugcag\n", + "gaaugcupagaguccgacgagcgcugcacuaacgcaggauccggcugccgaagguccucgccag\n", + "gcggcugccacguuggaacggaacguggagguggcccuggccpaggapcggcggcgaaugcupagaguccgacgagcgcugcacuaacgcaggauccggcugccgaagguccucgccag\n", + "acguuggaacggaacguggagguggcccuggccpaggapcggcggcgaaugcupagaguccgacgagcgcugcacuaacgcaggauccggcugccgaagguccucgccag\n", + "guuggaacggaacguggagguggcccuggccpaggapcggcggcgaaugcupagaguccgacgagcgcugcacuaacgcaggauccggcugccgaagguccucgccag\n", + "gaauuguacucucagagauguugagaaaagauacaupucuuggaagauaauuacucaaaauaugcapaag\n", + "aauaagaccauccaauuaauggaggacuccuuucgcguaacucuccuuaaagcgguaggcggugcgagaaccggcuauucagag\n", + "agcuuccagcacagcccgcggcccggugccagcuccgccggcgaccggugugccaaagugcggugcucccgcapaaccuggcucpapccucc\n", + "aggugagugccpcucggcgcucugcuccuggagcucccgcpacugccupacapacugcuguggcgcucggcccuccacugcggaccucuccugagupugcgccgaguc\n", + "agaugaaaacucuccuccugaaaggaccuuugcugagugcupaggcpcgcpaagaacggagaccgcccaggaggcugcggcacuccupcuaa\n", + "agacggacaggcugacaggagagagaacaggcacugcpaccugcaggagaaaggcgauccuguggcupaaugugaccccacggccagaagaggaccc\n", + "gccugagagaapagagaggugugccaaagugugcaucugcaggccgaagaugaggccuggacuuccugcuccaggugcacag\n", + "ggagacuugccuugcaaugccauguuuguguaugugcucuaacucccggagagcaaucapagacggcuccccggccagacuuggcug\n", + "agacuugccuugcaaugccauguuuguguaugugcucuaacucccggagagcaaucapagacggcuccccggccagacuuggcug\n", + "gugccpcgagcccggagacuugccuugcaaugccauguuuguguaugugcucuaacucccggagagcaaucapagacggcuccccggccagacuuggcug\n", + "auucacagcucuguaguccpcupcgcuuccucucupacugaaauaagagcgcucuagacagaucag\n", + "aggcucuuaggcuccacccggcccugaacagcuggcuugucuuggagucucuugugccacccuccccaggaacaguggcuuccuuguauuggcgccagcgaugaupccagcucugugcuaa\n", + "acggagucuugcucuguugcccaggcuggagugcaauggugcgaucucggcucacugcagucuccgccucuupuucag\n", + "gguuucauccuguugccuaggcuggagugcagugccuggaucauaacucuggaucaucacugaaaccugaaacuccupcucaagcgauccucccaucucagccucccaaguagcupacuacag\n", + "ccauguaagcaccaagaagacccuuaccagacacugcaugcuggugccuugaucuuggacuucccagccuccugaacu\n", + "agugccuaaupuguuguuccuggcuggacuugauguccapccugapuuuucucgccgagucuccupcgguccggaggcucgugcccuguugupcccccauuugccgccgcc\n", + "gugccuaaupuguuguuccuggcuggacuugauguccapccugapuuuucucgccgagucuccupcgguccggaggcucgugcccuguugupcccccauuugccgccgcc\n", + "caagcuguguaauguucuugaucgacuaaaugugauugcagaaaguguggugaagaaaacagguuucuuuguaaaccgcccugauucuuacuguagcauuuugcggccagaugaaaa\n", + "auacuuucuaguupagcaauaaugcagaaacgaaauaucgugucuugaagauugauagaacagaaccaaaagauuuggucauaauugaugacagg\n", + "caugucuauacucaacaagaaguaapaacuucuuggccgcuuggaucuuggaaauagaacaaag\n", + "gccuaaupuguuguuccuggcuggacuugauguccapccugapuuuucucgccgagucuccupcgguccggaggcucgugcccuguugupcccccauuugccgccgcc\n", + "aauucccauguuugaugagaggaaugagcagcagcauuguugugguggagaaggacucugugauggagcuuccugg\n", + "agauacuuucuaguupagcaauaaugcagaaacgaaauaucgugucuugaagauugauagaacagaaccaaaagauuuggucauaauugaugacagg\n", + "gguguuguuccuggcuggacuugauguccapccugapuuuucucgccgagucuccupcgguccggaggcucgugcccuguugupcccccauuugccgccgcc\n", + "cuauuugagcaaucuuagcugcuuucuacaaaaugcuuaaacaaccuuagcuuagcuugacuacaaggccaagauaaauccaacugaauuauuccaccag\n", + "guggcuguggcugcggcggcggcgcaggagcagaaaccggugcggcgcagaagccccagaggcpcpcggagcggapccagcpccccggcgupucucccgccaggccgccgg\n", + "agaaaccggugcggcgcagaagccccagaggcpcpcggagcggapccagcpccccggcgupucucccgccaggccgccgg\n", + "ggcggcgcaggagcagaaaccggugcggcgcagaagccccagaggcpcpcggagcggapccagcpccccggcgupucucccgccaggccgccgg\n", + "ggcgcaggagcagaaaccggugcggcgcagaagccccagaggcpcpcggagcggapccagcpccccggcgupucucccgccaggccgccgg\n", + "cauuggaguuuccaucaggacuccagguccccuauccuguccucugcaacccaaacguccaggaggauc\n", + "guagucgcugcacagucugucucuucgccgguucccggccccguggauccuacuucucugucgcccgcgguucgccgccccgcucgccgccgcg\n", + "agucgcugcacagucugucucuucgccgguucccggccccguggauccuacuucucugucgcccgcgguucgccgccccgcucgccgccgcg\n", + "uaucuaaauugcucugcgcauccagauucaaaacacagaacuuuuuggauuccacaaaacgaaaccacucacacaaaaccuuucacacaauugagacuucacugaggauuug\n", + "ucaucaccucuguggucuaagcuaggcugcugcccccucucauuuacacaaguaggaagaggaaagagaaccuggaggag\n", + "aaacauuuuacacagccacaagagccaguuaagaacucacagguacuuuuccagccacccagauaggagagaucauuaaaacag\n", + "gccccaugagcccgcggcuccccgucgcccpccguccguagccccugaccugaccuguccucgcc\n", + "guucuguggccucagcuacaaaccauugauaaagcaugguauaaaccaucuagacagaaauggccauggaaacuacuguuucuucugaug\n", + "ggagcacupaaugcupaaucgugguuccuaccgccaauggauugcaguuucucaccgguucccaaagccaagcaugag\n", + "gccgccgcgcgccaaagcpaaucupaggcgagcagcucugcaguuaaugcacguauuuuaaacucccpccugcggacgcu\n", + "cuugcuuugaacuugacauuuuuacugaacaguuuccuuccuccagccugcaggauguuuccucaaugapaaggcugcugcaca\n", + "ccuucaacuccgcpcaguaggaguuaguuagcaaagagccgaggccpcgcgcgacccucguccuucugccccuggccgcacacuuugcgcacaucucuuuuucugc\n", + "aaagagccgaggccpcgcgcgacccucguccuucugccccuggccgcacacuuugcgcacaucucuuuuucugc\n", + "ucgcaauugaaguaccaccucccgapugauugcuuccccaugcpuagaaccuuugcuguccuguucaccacucuaccuccagcacagaauuuggcuuaug\n", + "ccuacucaaugugaagaugaugaggaugaaaaccuuugugaugauccacuuccacuuaaugaaug\n", + "agagapcuccgcpcccagcuggcagccaggccggagacaaguugcagucccpcucuggugacgccguggccgcag\n", + "gcagagcugcagaggcaccggacgagagapcuccgcpcccagcuggcagccaggccggagacaaguugcagucccpcucuggugacgccguggccgcag\n", + "uggcuggcaauggccuugcugaccucgagccpcccacgupaccuuuggagcacagccuacgauccuggugcaag\n", + "gccgguggaugcagaggccaguccauauaccacccaggccugcgaggagcgugguccccacccauccagcccauaugugcaagugcccuugacag\n", + "agaggcuggucauauccauggugaccauuuaupccacaacagguccccaucugcgcagugaacccugugcugagcaccuugcagacgugaucuugcuucguccugcagcacugugcpcag\n", + "gccupccgucugcccgcagccaugagcgugcucggccccgguggagcccgcaguccucuagauuagucuccaccgccguccaggacccacuugcagc\n", + "gugcggcgccagcuggccccgcagccugcggcgcagagaggcupcuugcaggcgcaguagcuccagaggucgcgcupcugagagugcpccggcagaggcuggcpagcagccpuu\n", + "ggcupcuugcaggcgcaguagcuccagaggucgcgcupcugagagugcpccggcagaggcuggcpagcagccpuu\n", + "aguggcgucggaacugcaaagcaccugugagcuugcggaagucaguucagacuccagcccgcuccagcccggcccgacccgaccgcacccggcgccugcccucgcucggcguccccggccagcc\n", + "gcaccugugagcuugcggaagucaguucagacuccagcccgcuccagcccggcccgacccgaccgcacccggcgccugcccucgcucggcguccccggccagcc\n", + "ggaugccgcagauguguuagcggcgaguccagaagcagccccaggaggugcupcaucguuucucuaaucuggccucccgagugccaaggaggcgucccggcagcggucauc\n", + "gccgcagauguguuagcggcgaguccagaagcagccccaggaggugcupcaucguuucucuaaucuggccucccgagugccaaggaggcgucccggcagcggucauc\n", + "gcagauguguuagcggcgaguccagaagcagccccaggaggugcupcaucguuucucuaaucuggccucccgagugccaaggaggcgucccggcagcggucauc\n", + "gcgcuggcccuacggcucggacggcugccaggcucacggcuuccapcuuugugacagcguuggccagcaucugcagcagugcagccaucgcaupcguuaucaccacuacugcaccc\n", + "gcugcacaaucacccgccgcaugcugugcugcccaaagaccgcguagaggacacugaaggcaguuguguucuuagccupugccuuccacaccaaggacacgcugug\n", + "agagacagcupccacuggcagugapagagugaggauggcagagaccagugcccugcccacuggcuucpagcucgaggugcuggcugupauggugcuacugguggaag\n", + "guguaapcuggcgagcaagupcagcugcugagcuugcupccggupacggagcgguccapacaggccccugccupccagagaggagccaggagcc\n", + "gucgccgcuacccccauuguggucucugcccuccccgcpcccapcaugcuccgugccccugcgcccggucucggcggcggcaggcgacacuccgcgccggcggagac\n", + "gcccggacgcagugappucggcgcgcgugucuacgcggacgcaccggcuaagcugcuucugccgccgccggccgccupaccuugcg\n", + "aaguaaaaugcuuaauaaaaccccgguuuagacugucuucaaaccgaccgccaccccagagccugcagcugacucugaccccgc\n", + "gaacaucacagaagcgucugugcaggacagaagugccgcuucuaggcagagcuacuucuggaccaagugaapugacg\n", + "cagugappucggcgcgcgugucuacgcggacgcaccggcuaagcugcuucugccgccgccggccgccupaccuugcggugaggcugcgcpccgaggccgccuccgagcgccag\n", + "gagagaaggcaagcuuggcugcuguggaggcupcccauccucagaccaucugcuccccucauggugacacagaucugaaaaccag\n", + "gaccaccgccguugaagcugcaggcpcagccgugcgucucccpacagccagccccggcggcugcuccucccgg\n", + "gauguucuagugacuggauccuuuccaguuggugccupaaauggcagccacuacuaauucagccuugaagacaguaccgugcccacucagcaccauuacauagaagauagaacucaagag\n", + "aguuggccgcuccggccugupcuacaucccugcugccggccaggcgcggcccgcpaccccgaguguagcgcc\n", + "uuuuccccccacgaccugaccgugucgcuauagugacpapacagauggcauuggcuauucuacagcgaagcaucuggcgagacuuggcaugcauguuaucauag\n", + "cuggaaauaaugacagcaaagccaaacaaguuguaagcaaaauaaaagaagaaaccuugaacgacaaag\n", + "agacgugagucuugcuguguugcccpcuggcuuugccucuggaacucaagcgauccucccaccucagccucucgaggagcupacuacaggcgugcaccaucauuuccuccuaaaauu\n", + "uuuuccccccacgaccugaccgugucgcuauagugacpapacagauggcauuggcuauucuacagcgaagcaucuggcgagacuuggc\n", + "cucuuuuucuuucaaauuccucugucucgcuuaaaucuucccgcaucuucuccuuucuauuuaauucugccuuccccgguucuccuuagaaccuc\n", + "gucugccagucgaugccaccuccucggugaucagguuuggccggaacccupagcaaggcugcaguauguagugcucagg\n", + "agcggcaggcgaapcugaggaaaggaggupucuaggcapaaauupugccaccagacggagacagcuuggacuaccag\n", + "cuuuucagcggcaggcgaapcugaggaaaggaggupucuaggcapaaauupugccaccagacggagacagcuuggacuaccag\n", + "aauuacagaagagcaugaucguguuuuccuugguccucugcaaaagugaaguuucacuaaaguaau\n", + "aaucaagcacucuuuuggaagapuaaucucucuccaaaaacugaggacacuuaccuuccccauauauugaguccagcuguguuugguggcccag\n", + "cucacuuuucagcggcaggcgaapcugaggaaaggaggupucuaggcapaaauupugccaccagacggagacagcuuggacuaccag\n", + "cgaapcugaggaaaggaggupucuaggcapaaauupugccaccagacggagacagcuuggacuaccag\n", + "gacgcaagagcccgcucucacuuuucagcggcaggcgaapcugaggaaaggaggupucuaggcapaaauupugccaccagacggagacagcuuggacuaccag\n", + "uaauauguggucuuuugugacuggcuguuuucuuagcauaagguuuucaagguucauccauguugcauguauca\n", + "gugagagagguggaugcuuuggagcuuuuggcucagaaaugauaauguacauaacacaggcagccaugaguuaaaaugcaaguucugcuaucugcuagcucu\n", + "cagccucccccguugccccucuggauccacugcuuaaauacggacgaggacapcccugucuccucagcuucaggcaccaccacugaccupacagugaauc\n", + "ccucccccguugccccucuggauccacugcuuaaauacggacgaggacapcccugucuccucagcuucaggcaccaccacugaccupacagugaauc\n", + "agcagccucccccguugccccucuggauccacugcuuaaauacggacgaggacapcccugucuccucagcuucaggcaccaccacugaccupacagugaauc\n", + "aguuaacugaugauuuucaguuuugaaaacguggugcauuucuuuucugcuuaguucaaaccuaaaggcaauuguuuauuuagaa\n", + "agccggucuuuagguggcuggcgcagagcaggugucacuupagguagagcacaccuguucucccaccugaacaagg\n", + "gucagugagagcccaagccaauugcucuaggccccguggcuggcuacuuaupcacuguccugaccagcucugcuaag\n", + "acuugugcgcaugcuccpugucccggaguuguccugcgccgguguucccacgugcggccugaaccugagcgcauaauguuaugaggag\n", + "agaggcgugagcgagcccguuguccggagugcaccugcugccuguucugucccucccpagcccccgccgcugucgccgucgagucgcc\n", + "gugugaugccaccgccgcuacpaaguaaugguauccggccaauugagauucggaguuaaaacag\n", + "aagugugaugccaccgccgcuacpaaguaaugguauccggccaauugagauucggaguuaaaacag\n", + "gaggcggcucaucucgauuggcccagaaagaagacggucgcgcccuauguacuccpauuggcuagagcgagccgcguccccccucacgccaaccacug\n", + "acccgcccugcgcgugugaaapcgagagcagcgcgagauapccuagcgccucagaucuucguuggcggcc\n", + "gugcuccccacgugaaggcacccgcccugcgcgugugaaapcgagagcagcgcgagauapccuagcgccucagaucuucguuggcggcc\n", + "gaagcaucuugcuggcuuuaaaacuuugccugaucaaucaaugagacuccuuucucaaguugaacugcauugcgag\n", + "uaauaucagcauaaaaaaugaagaaccacagaauggcugcagauguuccuugucuuuuccaugacugacauuuuucau\n", + "paaaacacagcuuggaaaguaaagaagauuuuuuguuauuguuuuaucaugccguuuagaagcuaaaugaagaagacaaaguauuuauaguaucagauaagaaguugcucug\n", + "ccaucucaguggugaaguugacaagucaucuguccaguguguggaauaggaupuuugguagcaucucccucucugugguucucuugagccuuucacg\n", + "agaccaucugaagcaucuugcuggcuuuaaaacuuugccugaucaaucaaugagacuccuuucucaaguugaacugcauugcgag\n", + "ucccaggcauucuucuaggacugaagauggaagagaagcaagcagauacaaaccccugcuguucuggagcuucuauugcacag\n", + "gagucuccugcgcaccgccgccgaggacgcgcgcccgagccuaguccccacgccgcggcgcgcccpcucccugcugaucccag\n", + "gcagapaagguaguggcacggagugaccugcucuucccuuuuuucugcuugcagaacaaucaacc\n", + "ggcpuggcggcuggcpccgcpapcccugcgcucagcgcgcggcggcagcpcucgucccpugcaggcgcpcpcgcagcgcpccgauaag\n", + "cuuuggcgcguccugcucagaagccpagcuccuggccggcggcuggcpaagcgcggcgcpag\n", + "gagguauupagacaaaagaagcucaucuauaaacauuuuccaugaaucaagcagaaacuupuuuuaaag\n", + "gauucgcauagaacpaugccacaggcaaggacagauccccugaggcuguggaaugagupacauccccgcccaucucuggucuug\n", + "aguggcccauuuucucuuggcaggcaagguugugcggauaugaguguccagucuccagcuucgupugccuggaggcaggugcggag\n", + "aauguugccuggcaacapaapcggcucucgagaggagcccgupcugcuggaccggaccggacagcaccaggaagcccggcagg\n", + "agacpucuugcccuuuuacccaggcuggagugcaguggcacgaucauagcucacugcagccuugacguccugugcucacgcgauccucccgccucagccuuuggagcagcuaggacu\n", + "auuccucgcucccggccgaggagcgcucpcugucugcggacccugccgcgugcapucgcggccggcuggagcupagugaggcggcggaggagccaggugaggaggagccag\n", + "acauuccucgcucccggccgaggagcgcucpcugucugcggacccugccgcgugcapucgcggccggcuggagcupagugaggcggcggaggagccaggugaggaggagccag\n", + "gucgcpuacauuccucgcucccggccgaggagcgcucpcugucugcggacccugccgcgugcapucgcggccggcuggagcupagugaggcggcggaggagccag\n", + "acugcugugcapcaggaaagcuccaugcacauagcccagcaaagagcaacacagagcugaaaggaagacucagaggagagagauaaguaaggaaaguagug\n", + "aaucacugcugugcapcaggaaagcuccaugcacauagcccagcaaagagcaacacagagcugaaaggaagacucagaggagagagauaaguaaggaaaguagug\n", + "gucaggcaaucugugagaaucugaaaggaaguugcucuaaaauaaauuuuuuacgugugauuuauaugaaaaaucggapcagaaugucacuauugugauuacaucuacaug\n", + "guucaaucuuguucagcgaacagcacaagcuugcacagcucuggccuuuaaucuucguaggaaaucugaauuccuuguggcauuagcugauuauucuauuaaauguuuugauacag\n", + "ccaccuccgccuuuagugaaaguuauugaagauuugcccaagaauaaacugaguuccagugaucuuaag\n", + "caagcuucgccaugcagagcacugaccuaggcaacaaggagagcggcaagauauggcaccgcaagccguccccggccacgcpacgg\n", + "aauuauagugaacauuauucacaacacuuccgauuaccauccaaaaguuuugcgauuuuugaauguggcuuuugauggcacaggcgacugcuuaauugcupaccaccaaggaaauauuu\n", + "gcugauguccggccccaaacugauggcuguaacggucuaagauauaauuuaacuucugauaucauugaguccauauuuaggaccuauccagcag\n", + "guauuaucaugguccaacuccaauccagucacuacaguaugcaacaagucaggacauuauuaauucuuuucaaaguauuagacaagaa\n", + "aguucuccupaagaaguguuugccacucaaggaauacacucaagaaaaaccuggaaaucacagaaggcauu\n", + "auaauucgaauaccapcaggccgagccagccgugcgccgcgcuccapcccapcgccgcacacgcacccacccacccacccagccucgcagcgcc\n", + "pccupupaagagaggcccaagaaagccaccauagucuguagcgugaagcuuuuccuauagucuagugauaauccugcu\n", + "cpuuacaaauaggaagcuuucgccguuaagcagccgcpacacagcuccpaccpucugacucccuuaaac\n", + "cgcugcaccagcccgucuggccaccaacgccgcggagaaaggagccgccgccgccugcggcccucucccgcccggucgcpagcagcp\n", + "gcagccpaccgcgcucugcagccgcagacccgguccacacggccapcuacgacccuupaucugcccuccgcucagcucgagcuucccucguggccgacggaaca\n", + "cuugcugcagccpaccgcgcucugcagccgcagacccgguccacacggccapcuacgacccuupaucugcccuccgcucagcucgagcuucccucguggccgacggaaca\n", + "gcuuggccacaccgccugcuuucgcuuccagccgcgcgcuccgugccacugccgcucucugcagccccgcguccccgcagccucccc\n", + "aagcuguugugaaggcagagcagcaucugcugaagagacagaaaccagccccagaggugucacaggaaggcaccagcaaggacauuggucuuugauuugauucagcaguccugucaaguauaaau\n", + "ggaucacagcccuuccccgauccucuccgupagccagcgagccucucucccugaucuuacgugcucaag\n", + "aucacagcccuuccccgauccucuccgupagccagcgagccucucucccugaucuuacgugcucaag\n", + "aggaagaagugaauagaagaaaagapuguugcaaaucaaaagcacauagagauaucaucuuacaccagucagaauggcuauucuuaaaaugucagacaacaacagauauug\n", + "gauugccacaucaucaggaccacaccuucaucaggaaugaauauuccuacuacaauuaaagaagaaacaaaauuaauuuguuggugaaaaac\n", + "gacgcuugauguaaupcagaaucagaaugcuucaggaaucugucgaauuuguuucuuauaaua\n", + "gccccuggaggaauugcuacacccccaguguauggucagcuucuagcuuuauauuugcuccauaaugac\n", + "aucgcpcgcgacgccugapacagucupuuuggcuguccggacggugcagcggcgaggccggccgcgaag\n", + "acgucaucgcpcgcgacgccugapacagucupuuuggcuguccggacggugcagcggcgaggccggccgcgaag\n", + "cucugcuuucccagcacgcugccucaccaagaaagaauccagagaaggacugguggacuuggaauguuaaguc\n", + "agaaagcgacagguugccgaaagcuacagcccagccaucccgauuccccuggcgcggacucuggcaccaacaaaacuaucucuuugag\n", + "ggcagugagccaaggagacpacccucugcuuuguccuccugcugugcuguuggcaagaaacugagcuccggccgagaaccgugauuccag\n", + "agaacguccuucucccucagcuggapagcauggcagugagccaaggagacpacccucugcuuuguccuccugcugugcuguuggcaagaaacugagcuccggccgagaaccgugauuccag\n", + "gucucgagguucccaaaguuccuggaucugccagcaaaugaccuucuucacucaccugupaupacccggugagccagguagcag\n", + "cuccggcuccgacguccucggccugccpucccpuccuuugcggcgcuapupcgaacccagagcgacgcuccpacg\n", + "gguacguugcgcugguucauagcucauuuaucaagcccauccacuucugccugaucaucaaggccgccuucaaccuguccaccc\n", + "augucugagagccccaaggacgapcuccgaagagugucuguuucugcagcgccuaupaguppcaguppaacucapaagcugccuacaacuug\n", + "aggccuuccccaggcuggaggaggaggacapaaggccgapagcuguccuccggcugccaucacccugaugagg\n", + "cggcccugccccpcuguggucuccgcapcuggcaaccuugccuuuguccagcucucuccguggccaggccugccaucug\n", + "ccugcccacacuccuccccggcaaagccccuugcaaaugcuugcuuupacuggcagcuuucgccucugaaucaggaccu\n", + "cgcgcuupcggcggaggcugcagcuaccucggcgccggcucggcucuaggacgugucpcugcacpucpcggcucccugcugcuuccgagccuagccgccuggccuucggcauuugcag\n", + "gccucccagacugagcaggaacuucagapaacuggacgcccuucpacagugccaggcucaggcacuggcuggagcagagcugaggacgcggcuggagagucugcapaa\n", + "ggugugagauggcagacagguuugcaggaaacccucagaaapcuggaggauuuagccacucuguccuccccuuccggcaguccapccuccucccgagcacagcggcgcu\n", + "ccggagccccgcpcucuccpupcacapcgacagcucggcpcpccgagcacgcgcgugcgcagaaaggccggcgcggcaggcugaggagaaagcggcgcgcggag\n", + "guguuupccugcugucacagcacupagccuuggagagagaupagcupauccccaggag\n", + "gugaauguucuagcugcaagagaaaccggaguggucuggucacucaaccaaaaccugcugaagcagaccccupcacacupaacuucuaccaucccagguggaaag\n", + "ggucguucgugucuguugaacggcugupcgucuugcugccuupuapuuaaaaucguucuugagaggaacgucucugugcgaagagaua\n", + "gucguucgugucuguugaacggcugupcgucuugcugccuupuapuuaaaaucguucuugagaggaacgucucugugcgaagagaua\n", + "gupcgucuugcugccuupuapuuaaaaucguucuugagaggaacgucucugugcgaagagaua\n", + "ggccgcugaggucguucgugucuguugaacggcugupcgucuugcugccuupuapuuaaaaucguucuugagaggaacgucucugugcgaagagaua\n", + "guggcucccgcagccggcgcupacgcgcgcggccgagacucuggccugcagucgccgccgccgccgccag\n", + "gugguguuuggacucuagaccaugugccuagguagaaguuuuuccuuucuccgcagcucugcuccccuagcaacgcucgccacacccuuguuuugagauccucucuaag\n", + "aaaggcgcgcgagccgagcggcgaggugccucuguggccgcaggcgcaggcccpcgacagccgagacguggagcgcgccggcucgcugcagcuccpacucaac\n", + "ggugccucuguggccgcaggcgcaggcccpcgacagccgagacguggagcgcgccggcucgcugcagcuccpacucaac\n", + "gccucuguggccgcaggcgcaggcccpcgacagccgagacguggagcgcgccggcucgcugcagcuccpacucaac\n", + "gcgcgagccgagcggcgaggugccucuguggccgcaggcgcaggcccpcgacagccgagacguggagcgcgccggcucgcugcagcuccpacucaac\n", + "agugaggcupaauugccagagaaguguucgucagugacuuacapugguauuuaccucaacacacuuauuucggaaucucaaaaccucacag\n", + "ugcugaugagcgcuuugacgccacauuccacacuaacguguuggugaauucuucupcauugccaguaccugccuccag\n", + "gcauauucaagaguuccugcuacaucgauguacgcugguuucccuuugaugugcagcacugcaaacugaaguuupuccuggucuuacggaggcugguccuuggaucugcag\n", + "gugcucagagaguuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "ggaaggacagcacagcugacagccgugcucagagaguuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "ggacagcacagcugacagccgugcucagagaguuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "uccccuuuggagaucacuggaaacagcuucuggaccacaaaupugaacuacuguaucgagaaaggagagaguaagacuugagagcuaucuuuuuagcucapugcag\n", + "gcaguauaaaaacgcuggugucucuccgcggaaacuccgagaggagcagaggucuguagagguagagacguaggcuucggaucuuuuagaauucugcuggaagucuccaagucaag\n", + "acuauugaagaguggauuguguacugapcucccaagugcuuccagaagccaauaaaggaucacuucaguuuacuucacggcuaaggaguaacccuuaagaacc\n", + "ccucuaagcaucccgcccucuuuucccccaucgcccgcccuuuuugagcccgaaagcuugcagccaacuuccaacucccuguccuguccuag\n", + "ccgccggcucccccucccccgaucccucpucccpauppcggugaggcaggcacagccccccgccccc\n", + "cucuccccggcccgauccgcccgccggcucccccucccccgaucccucpucccpauppcggugaggcaggcacagccccccgccccc\n", + "gauccgcccgccggcucccccucccccgaucccucpucccpauppcggugaggcaggcacagccccccgccccc\n", + "cccggcccgauccgcccgccggcucccccucccccgaucccucpucccpauppcggugaggcaggcacagccccccgccccc\n", + "uucgcucacccucccccauuuccugaaggacaacggcucuauuuuacupuccgccaucgucucguccgccgguccuggcucuucuuguaagccg\n", + "cgguggagcugucgccuagccgcuaucgcagaguggagcpcupagcaaagcgcugapagcucgguacgccgccgccucgcacccgcagccucgcgcccgccgccgcccguccccag\n", + "ggccaggccguuuccgguggagcugucgccuagccgcuaucgcagaguggagcpcupagcaaagcgcugapagcucg\n", + "aucgcagaguggagcpcupagcaaagcgcugapagcucgguacgccgccgccucgcacccgcagccucgcgcccgccgccgcccguccccag\n", + "uuuccugaaggacaacggcucuauuuuacupuccgccaucgucucguccgccgguccuggcucuucuu\n", + "gguggacagaggagcggapacgagapaagcgcacgauagcugcgcggagagagagcgaagagcaggcggaggaacaaaggcgacccaagacacccagagapacag\n", + "gacaacggcucuauuuuacupuccgccaucgucucguccgccgguccuggcucuucuuguaagccg\n", + "ggagcugucgccuagccgcuaucgcagaguggagcpcupagcaaagcgcugapagcucgguacgccgccgccucgcacccgcagccucgcgcccgccgccgcccguccccag\n", + "uggagccgcccupugucagcggcucggcucccgcgcacgcuccggccgucgcgcagccucggcaccugcagguccgugcgucccgcggcuggcgccccugacuccgucccggccapapcc\n", + "acuuccuaaaaaacgauagcacgaagcauauuaagguagauauguucuaucguuaauuguaguuuugacagguggcaucucaguaaucaaaaggaagaaaau\n", + "gaaccaaaagaaccaaagapaaccauucauacuucaagaucucuaauaagaaguagcaauauuuaau\n", + "acaggaaccaaaagaaccaaagapaaccauucauacuucaagaucucuaauaagaaguagcaauauuuaau\n", + "gcacgaagcauauuaagguagauauguucuaucguuaauuguaguuuugacagguggcaucucaguaaucaaaaggaagaaaau\n", + "gugcuggcugcguaugcgucacpcgucaugaccucgcuguggccccggcagcggcugcpaaagucgcgaggugcauccgcuucggcugca\n", + "guaugcgucacpcgucaugaccucgcuguggccccggcagcggcugcpaaagucgcgaggugcauccgcuucggcugca\n", + "aucagucggaauuuupagccaaccgcgccgucugucccuggcaagccagcggcgguuuaaaggagguggcpaagccugugugugcuucaaaucgucacccucauggucgcuccg\n", + "cucgccgagaugaccupcaccucugcguugaaucggcaaauacugaucaagccgcauuuauucugcucucaggaacucuaagucuagcagagaagaugaggcgguagaaguucauca\n", + "auugccgccaccgaaggcggaggapaggaccgccaagagcgacgccgccgugugcccaacggucgguguccccggcugaggcagcgcggccgcagcagcccu\n", + "gaaacagucauaaccucaaaaaugacuuuuuaauucaaauauaagauuauacupucuuggccaaagaaaaguuucugucguauauuucuguguug\n", + "agcauuagugaggaggcagaggaagacugucuccagaauuacuupaaguaaaaaucugcgaggcuug\n", + "gauucggcgcgcuggagguuagagaccgagcugucggcccuapuucggaaagapagaggccpuggccccagagaagcaugcggauugcaa\n", + "auauugucgcuaguggccgcupcupapugugcuagagaggcgcagcuucucupcgugguuuuuauccupaaggaucgguggaaugugapagguggaggag\n", + "cuuaugaaaggauauuauuuguagcuguguuuucccuuguaaauuccaguacupcacuccugaaaacuucgcaagauauau\n", + "guaucugcccaucuuagauucuuccuagcaauaauucugagagacucuggauugupccgaauggagaaugaagccuuuucaaauucaccucccag\n", + "guaucugcccaucuuagauucuuccuagcaauaauucugagagacucuggauugupccgaauggaga\n", + "ugaaccacccucaaaauagaagugaaugugaaaccacagauauuucauuaaaacauaucugaagauaaaaacauaccucaagcuucacagauauaggacuucugagcugagag\n", + "agacpaggaagccacgcuaggaccucggcucgcucapcugugcpagcagcugcagccacgg\n", + "gucugucugugucuacpcaccguggccacaccugccugcacagccapccaggaggaggagaugcc\n", + "cugcagcgcccggcugccucgcacuccgccucccccggcucagcccccggccgcggcpacccgag\n", + "aguuucgcucuuguuguccaggcuggaguggaauggcgugaucucggcucaccgugaucucggcucaccguaaccuccgccucucag\n", + "ggucuuacucugucgcccagucuguaaugcagugcugugaccauagcccacugcagccuccaccucccaggcucaagcaguccuuccccccucgcccucaugaauagcupacuacag\n", + "gupcucagccuucuuuccuucaauuccuguuucagucucauuuucauggacugguccccaaacuugucugcauuggaagcaccupaguuucuagaccugagccugugcccaccucaugag\n", + "ggucuaucggaaguuuaaagcaaugcagcpaaguaccuugccuuuuugaagcgaauagcguuucagagauauupcggcucaag\n", + "gcagccgcggaacaaaacugucuugcuuupccugaacugcuggupauauppuppcagaggcguggagcpucucag\n", + "gcucpuccgcggccgcugcggcgccpcauuucuccgcagcucggcucgcggccgcgcccgccgccgcccggcccgcgccc\n", + "agcuagcacccggcpccagcgagcgucccugcagccagcgagcaggaggaggagcugcugccpcggapcagccgcpagccgaagapcgccccag\n", + "gcgugcuguupaguugcuuggagguuggcggcgcpcugaaggcuagcaaaccgagcgauc\n", + "ugagaagcaguuuggacccagcugaaaaauuuuauuuauggagacuuguaaucagccugauauacagagaacacucuggacuggaaauauagucag\n", + "gguuccpucgcugcucggcucgccggcupcggupuuggugacgcpccpcucacgagaggcccpaggcpcuuugcuggcuucccagagagaggcag\n", + "guccggucaaggcagccaucucgccgugagacagcaagugucggauccgcaggcgcagccgugcg\n", + "cucuuuuguccaccagcccagccugacuccuggagauugugaauagcuccauccagccugagaaacaagccpuggcugagccaggcugugcacggagcgccugacpcccaacagaccc\n", + "gaupcccacucuggcccgauccuggcaccagcaaupauguugaccugucugcugagucuuggagcccaccacugccaaggacacccagcuggagcuaauuugcupcugagucauagcaucug\n", + "cacuucucagaacuucuggaugaguuuucccagaacgucuupucagcuccugaaugauccuuuccucucagagaagaguguguca\n", + "aaagcguuacuuccggcggaaaaggacgcpagauucgauuggaaggcugccggcgugcuacugaguucggccgguccgagucacugugcgucgccupcccguuccuggucuucucccccag\n", + "ggucuugcucugucacccaggcuggagugccauggcaucaucauagcucacuauggccuugauccuccugccuuagccucccaagcagcugguauuacag\n", + "gauuggaaggcugccggcgugcuacugaguucggccgguccgagucacugugcgucgccupcccguuccuggucuucucccccag\n", + "aaggcugccggcgugcuacugaguucggccgguccgagucacugugcgucgccupcccguuccuggucuucucccccag\n", + "auapucuugcucugucacccaggcuggagugccauggcaucaucauagcucacuauggccuugauccuccugccuuagccucccaagcagcugguauuacag\n", + "aaacugucauggcgcugguggcaguguagcagugaggacaaccagaggucacucucaucaccaucuuaguuuug\n", + "agauucgauuggaaggcugccggcgugcuacugaguucggccgguccgagucacugugcgucgccupcccguuccuggucuucucccccag\n", + "aacugccacgupaugagauuugcupcugguagcggcggcugcugcpaggucccgcccacgugaagccagccuaacugagcucuggacuuupacagcugucaguggccuaggccgcag\n", + "aaucuucgcucugaggugcugucucaccggugagaccuggaagcpcgagucucgugcugugucggaccugcagccccuggccuuccgccacc\n", + "aguacuaaccagcuauuucauagcuguugcaugaggaaapacuagaguaggauuguaccccucagucuaugcuuuguuuacucugaguguacaaaagaug\n", + "gauaugaauugucucccacggcagcagcuaacuucacacgccgaaaccuggcugacugucuucggagucgg\n", + "accccauaucaugugaaccuccuccuggcuggcuaugaugagcaugaapccagcgcuguauuac\n", + "acagccacacugcaguaugucaggaacagucauggagcuguucucauuguuugccucuccuuuuccuccuuuuuaccuucuggccccucucuucauucagag\n", + "accauggagaaaaacugcagcucuucugucaggaggaupaaggucauuugcuggcuuugugagcggucucaggagcaccguggucaccacacguuccucguggaggagguugcccaggaguaccag\n", + "gagaaguuucaggagucucuaaagaagcugaagaacgaggagcaggaagcugagaagcuaacagcuuuuaucagagagaagaaaacauccuggaag\n", + "cugagucuuucggccupuggaggacgcggcugcuucaaguccuuggcucugauccaggccacagauuccag\n", + "gauucuacaggcaggaaacaucuuagaaaucapuupcaggcaggagccaggagaguagcuaca\n", + "ugagucuuucggccupuggaggacgcggcugcuucaaguccuuggcucugauccaggccacagauuccag\n", + "aagauuaguuuaaggugccuuggauugcucugaagagcuuugaccaccugauauugcuuacaucuggaacuucuuggcuucucauuccccagaugugcpucagagag\n", + "gucuuucggccupuggaggacgcggcugcuucaaguccuuggcucugauccaggccacagauuccag\n", + "augcuuuuacapuuaaaugauaccacaagaggcapcagcpcucgacgagcucuguucuggugcpcaggaggcpagcccggaucugugcgacugaag\n", + "gaagcccaggaggcugaugccugccaggaggagcuggcacugaagguggaacaguugaaggcugagcugguggucuucaapcuc\n", + "gagcgccggacaagcugagguccgcgacucgucgcuaagauuccccaaaacugagauuucaagaaaauucacccuuuccgcuuucuuuggcguccuucaaccgugaaggaaaugaag\n", + "uugcuuucuacccucacaucccauauauuuuuauguuucauaauuucugaaaaaggauugauuaaaaauuuuuaaugauuuccuuugugauuugacu\n", + "gaugguuguauacuguuaaugugccaggaguccaugacugcaggaccuaagaauuuacagacaagaag\n", + "cccggcccugaagcaggucucugcuccacgcuuuuccuuaguupaaucgagaguupaucaaagccccccacaucucccucacccgcugcagcu\n", + "gucucugcuccacgcuuuuccuuaguupaaucgagaguupaucaaagccccccacaucucccucacccgcugcagcu\n", + "augugguuuccuuauuggagcaapaaagaacccuggcupaaaapaagugaaaagagaucuguuuucag\n", + "uuucagagucaaguggugagaucaaagacuuuucaccaaaaaaugucauuuaugaugacucaucccaguauuugauc\n", + "ggucugcgccggauggccccpcggugacucgguccggagcccuggaacgcuacgcccaccuggcggaaagcaccacggaaacgcauccuucuguggccacuguuag\n", + "cugaguuccacguucuucguuucuccgcuaguugugcgcuuggccgcgagacacucuggcaguuauaggaacacaaag\n", + "pucagugacauucagagauguggccauagacuucucccaggaggaguggaaauggcuucagccugcucaaagagauuuguacagaugugua\n", + "agapcccgagccacccgguccgccgcguccccgccgccgccgccgcgucccccgccpccgaccgagccgagccpccggagcggcpcgcggccpccgcc\n", + "ggaccaaguuuugaggauuaaugucagaaauggagacgagaucagcaaauugagucaacuagugaauucaaacaacuugaag\n", + "gacugacuccccpacaugagguggauacuguucauupcccuuauupuccagcaucuguggccaagaaaaauuuuuugg\n", + "aaaaaacgcaaaacgucauaccagcuguacaaggauuuuccuguagcaguugcauugcaguaaaauugcuugg\n", + "gcggccgcucgcggucuupagagcupcgcgugccugaacuucccggcugccccuguccuuggagaccuaccugaupacgccaggugugcapcguggcgcguag\n", + "ucucuaccuggaaauugguacagagauucagagucuuuguccaggaagacacuuuggaguagaaga\n", + "gcggcpcgaagcgcacgucgagcpagcggcgcugccuguggagauccgcggaggccgacaggauucguuggcugccguccccgcugcugugcauugg\n", + "guuuguuuggacuggagaapaggcggcpcgaagcgcacgucgagcpagcggcgcugccuguggagauccgcggaggccgacaggauucguuggcugccguccccgcugcugugcauugg\n", + "ggauggagguuapaauggagauuuccucuaaugauucaaggcugugcacguugcuccuuaggaacucaaauugag\n", + "agacggucgccgccgcguuugcgcapagcuggucgccgccgcggccgccuggaauugupaguugugucugccacucggcugccggaggccgaag\n", + "gccagcuauuacuucucuacugaggccaacugugagcccugguguguuucauuggcaggagaagaggcuaauuaagugaaacugaaag\n", + "ggcauaucucuuguuggauggcuggacccaccaugguagauggaggcuucagaauuaucuagaagugguagaagacucguuauaccucu\n", + "auuacuucucuacugaggccaacugugagcccugguguguuucauuggcaggagaagaggcuaauuaagugaaacugaaag\n", + "uccaucaacauccuuugcagcuacauaggcaggaaaaucuagaaauuguaauuuauauagaauuuuaaaacucuucaauuaca\n", + "agaauuauuuuauuucaggaauccaucaacauccuuugcagcuacauaggcaggaaaaucuagaaauuguaauuuauauagaauuuuaaaacucuucaauuaca\n", + "gccgcggcpaaaauccgaccuggccgcgcaccaccgccccuucucggcccuccugcguuugcccapucggcccgcagug\n", + "agaaguuaaggcugguguccuggccccaguccaccucupagcgccugcgccgcuccgcggagaguccguggaucucaca\n", + "accauucuuccgguuucagaaguuaaggcugguguccuggccccaguccaccucupagcgccugcgccgcuccgcggagaguccguggaucucacaguga\n", + "auucuuccgguuucagaaguuaaggcugguguccuggccccaguccaccucupagcgccugcgccgcuccgcggagaguccguggaucucacaguga\n", + "aaaauguuugcugacccuugacauugacaaacugcugacagcucagaugauccaugauuggaaggauguggucaucaccaagaugucuuucuuucucc\n", + "guccuggccccaguccaccucupagcgccugcgccgcuccgcggagaguccguggaucucacaguga\n", + "guugcaugcuacugaaaguguccuucagaagauauuaaagagcagaaaaacaauuguuucaguguaacacagccagccucgaagacuucccucugaguugga\n", + "agcuggccccugcgacucgcpugugacguugaagaugucggccuucugagccgacugcgguggucaagag\n", + "gugcaacuggagaaggcacugaagcccuacgagauucacaccgucuucggucuccupucggcgccgagupaggauggcggaa\n", + "cugcugccgcccaccccucgucuucuggcugccucccucuuugugccccacaggcucccccucuccaccuccupcccauc\n", + "cagguguguggacccuucuagccugaggaguccugcaggugugaagcuccacaccugccuccauagcacuuugccugucccuaagapcucaucggagaagaaaga\n", + "cpcagccauuuupaagagcuuuguuaugguuguggacuagccgccucugccpucgacaagcupacgcguccucagacgcagcgucuagucccuggccauagcuccgccgcugcccg\n", + "gcagccauuuupaagagcuuuguuaugguuguggacuagccgccucugccpucgacaagcupacgcguccucagacgcagcgucuagucccuggccauagcuccgccgcugcccg\n", + "acuugccggaagugccuuuccaguggaccupcuguuguugcgguuguuuuccuucucuccgugcaacgcuggcaagucucaaagucgccacag\n", + "aaacaugccccugauucagugccucugcuuagcuguaacauguuaaucagaacuaccuggcaucuuccugaacaagacuuucaauapccagu\n", + "gcpagcgcgcccuapcpcacugaagcugcggcuugcgguucagcpuucuapcgccpcgcucpccucggcc\n", + "ggcauucuccacuccugucucuguguguuuaaaaaccggugupaagugugcacgccugugacgucagacuccagacc\n", + "ggcaaagaagagaaaagcuccuupaacuuaguuaccaggucuuauagcaccagcucuguguccucagagucgcugucaucaaggagaccucucacuggucaccgccgcagcccccac\n", + "gcaccagcucuguguccucagagucgcugucaucaaggagaccucucacuggucaccgccgcagcccccac\n", + "acccugcccuaugugucgcpaacacaugucaccccacagcucucuuugagugaccucccgaccacccauuccugccuaacccuagcauuccuuccucagccucaag\n", + "cacgccgccggccgccguuuagucccagagauagaaaaaaguagagguaggapcgcggcggcucacgccuguaaucccagcacuuuggaaggccgaggcpcggaucacgag\n", + "guagagccuuuguupaugaggagugucuupucgagaacaggccccuguaacccacugagcgccccuucauuccgucucucuccgcccuuuguagapucacc\n", + "ggcgaacgaaacgcggagcucpagcgacccggcpccaggcacpcagaapccaagapccacag\n", + "ggapaggcggaauuuucuuuuuuccaguucaaacuggagaaggapcagagauauccaguagacagaagaucuuggaccccaggaagu\n", + "agacuugccgcggccccagagcuggcpapagaggccaccagcagcgcgcgcpagcccpaacagcg\n", + "ggcuagugaugaggcugugugcuucugagcupcauccgaaggcauccuupaagcugapcacgaggapcugccagacuccpagcugcugccuggcupauuccuacaca\n", + "gcugcaugcupugagcggagauuccaggcacuggccapcagcugcccugacuccaapcugcc\n", + "gcugugugcuucugagcupcauccgaaggcauccuupaagcugapcacgaggapcugccagacuccpagcugcugccuggcupauuccuacaca\n", + "paggcacacgauccgagguccuuuuagucucagaggaupaagauccuggcagaagcagauggacugagcacaaaccacugg\n", + "acpaagupcggugcccagacagcuggapaaggaggugucaggcpagagacgcaaacggcpaccagcagcgacgguagcagcagcauggccgcgaucuaupuguagap\n", + "apaaggaggugucaggcpagagacgcaaacggcpaccagcagcgacgguagcagcagc\n", + "gaagupcggugcccagacagcuggapaaggaggugucaggcpagagacgcaaacggcpaccagcagcgacgguagcagcagcauggccgcgaucuaupuguagap\n", + "guggaguugugcucauaucuggaacaggcuccaacugcaggcucaucaacccugauggcuccgagaguggcugcggcggcupccau\n", + "cugaucpacagacaaguguguggagaggaucaaugagauggugaacapccaaacggaaagcapuggauccucugguaccgcugcgaagcuug\n", + "augcugcauccccuuuuuggaauugcucaaccaggugguaaccggcgccgcuuccuggccuupaggugguuccuuucuuaacccacaagaaccucucccaagag\n", + "paaaggupaapucccpaacguggupcapccuccgagcgugguuggacuuugaapaucggccgcc\n", + "agacagacgaacpagupcggagcpcgccggaugugacguuuccggaaccuccpugucauccgcpaaag\n", + "auagacagacgaacpagupcggagcpcgccggaugugacguuuccggaaccuccpugucauccgcpaaag\n", + "auccgcpaaaggupaapucccpaacguggupcapccuccgagcgugguuggacuuugaapaucggccgcc\n", + "gcpaaaggupaapucccpaacguggupcapccuccgagcgugguuggacuuugaapaucggccgcc\n", + "gcucuuuauugagaaacuaccaaaacaucgagauuacaaaucugcugucauuccugaaaagaaagacacaguaaag\n", + "aaauuaaaggagauugcauuucccaaagcagaagagcugaaggcagagcuguuaaaacgauauaccaaagaauauacagaauauaaugaagaaaag\n", + "ggaaccuccpugucauccgcpaaaggupaapucccpaacguggupcapccuccgagcgugguuggacuuugaapaucggccgcc\n", + "agacgaacpagupcggagcpcgccggaugugacguuuccggaaccuccpugucauccgcpaaag\n", + "pagupcggagcpcgccggaugugacguuuccggaaccuccpugucauccgcpaaag\n", + "paaaggupaapucccpaacguggupcapccuccgagcgugguuggacuuugaapaucggccgcc\n", + "pugucauccgcpaaaggupaapucccpaacguggupcapccuccgagcgugguuggacuuugaapaucggccgcc\n", + "cagaagaaaugauaacagcuccucuuuuuaccucugguagaauucagcuguaauccaucugaaccupcuuuuuuuccuuug\n", + "gucuccgaaccugaaaccpagcuuccugcucguguucgcuguugagaagcuacccgcpuuguagaccucggaccuc\n", + "agagaaggcuggcugaggagcgccuggacagcagcaguugcugacguucuauaucacgcgccupcccaag\n", + "ggccucugacuggaaauuagaccagccugauuggacuggucgccuccgaaucacuucaaaapaagacugccuauaucaaacucgaggauaaaguuucag\n", + "pagcucuuugcucaggcaccaguagaacaauauccugguauugcuguggagacggugacagauucuagccgcuacuuuguaauccggauccaggaugguacug\n", + "ggcgcagugcuuucauuggcauuggcuucacagaucpagaugccuucgacuuuaaugucuccuugcaggaucacuucaa\n", + "gcgcaacucguuugcagcggcgcagcccagacgcgccugcagcupcucaccccaaccucgcugccagccgag\n", + "uguuuggcaucccacugaccccacaucuguuucgcugcuaaugcucugcugccagaacuauccaagcugccucccucupcccapacuauugcugaagag\n", + "augacaucucuguauguuacccaggcuggacuggaacucupcucaagccauccuccugccucaccuccugaaguguupauuacag\n", + "ggcacacauggagagacgucuuucuauagacccaggaguacaaagaagccuucaccugcacccacagg\n", + "agacgcacaccugcuaacagagacagaaagacacgcauucagacucccacacggaggcacacauggagagacgucuuucuauagacccaggaguacaaagaagccuucaccugcacccacagg\n", + "guacagcggcgguuucugagguucuucacucgcgacugacggagcugcgguggcgucuccacacg\n", + "aguugcugcugcagcugagguacagcggcgguuucugagguucuucacucgcgacugacggagcugcgguggcgucuccacacg\n", + "gccacgcpacggccccagccuccaggaacuggugcpcggcpuuuccuccggcucggcccacuupcuccccacua\n", + "acuguccauagapucaccacgucggccacucguguuacugguggcucacucucacccuccugucgccuccuccuggcc\n", + "agacgcggapaaggagcuacgaguagccgccgagaggccgcggagccagcgacgaccgacccagccgagccgccgccgccgccgcgccccc\n", + "gccggcgccagacgcggapaaggagcuacgaguagccgccgagaggccgcggagccagcgacgaccgacccagccgagccgccgccgccgccgcgccccc\n", + "ccpcgcgccgguucccggcacgugucucggcacguggcagcgcgccuggcccupcuuggaggcgccggcgcc\n", + "aagugugccggcgucgcgcgaagguucagcapagccgupccpcgcgccgguucccggcacgugucucggcacguggcagcgcgccuggcccupcuuggaggcgccggcgcc\n", + "gaagguucagcapagccgupccpcgcgccgguucccggcacgugucucggcacguggcagcgcgccuggcccupcuuggaggcgccggcgcc\n", + "agacagaaaaauucgcugcaaguacagcacuuucuagauugcuccuggagugupaacaacagucucuccuguccacguuacugaauccagaaaaaaggugaacuuacgaac\n", + "guaaauugcagauaacugaupauacaggaaaaggagauaaaaggccauuccupauucacguacgacgccaucacgaaaguuuuuuuccccugucuu\n", + "aaagcucgcuuguccccggaaccgcccugcugccgccgccugcuuccucugcucgcgguuagcccgucagucccugcucugugcgcgccuccaucupccauggaugg\n", + "cpaucugaugagcuucuuucuucuggcaucauuaacggaccuuuuaccaugaauaguucuacuccuucuacaggugugu\n", + "aauagcccugccgcagcccauccagcuggcucagagccguuccccaugcccpugucuccaucaccccagaaaacaugcaaaacagcucggcgccucuguguuccugacugugaa\n", + "cgaaugacaacagagcugcucaaggcpaacucugagcuaagcaguggagguuucucuggaucuggagagaagagugaccuuggagccaaua\n", + "agaacgccgcgcccgugacccggaagagcauucuccuuagcaacugcpacugcggcggcgccggccuccpagaaacg\n", + "agcugcucaaggcpaacucugagcuaagcaguggagguuucucuggaucuggagagaagagugaccuuggagccaaua\n", + "gcgcccgugacccggaagagcauucuccuuagcaacugcpacugcggcggcgccggccuccpagaaacg\n", + "gaaaccuucccauggcugcagagcugccucuaaagcaagacuagaggcaaagccagccaacagccccuuccccucccaucccagcuuggcccacaucacccaguuccga\n", + "ggcguggaagcugcpucggcugcpaaapucccaupagccgcuaggcgcagcccguuucccgagcugagguggaggucgacpcacag\n", + "cuauugagauuaucagcacuaucaccuggacaagcagcggaupccgccccucuuggccaggucuucugugcgcacugacguugu\n", + "aggcggcggcggugguggcpcgaugcgccgcgcccggccgcgcuaggugagccggcaccpagcgcpccgcggcc\n", + "guggcagcpaccugcggccccgucgcgaaguuuccagcccugcgagcgccgccpucggccgaucgucccccauaccucggcc\n", + "accuugccugcgcccgcccggagccagcgguucuccaagcacccagcauccugcuagacgcgccgcgcaccgacggapac\n", + "gucucgccggcucgccgcgcuccccaccuugccugcgcccgcccggagccagcgguucuccaagcacccagcauccugcuagacgcgccgcgcaccgacggapac\n", + "cccaccuugccugcgcccgcccggagccagcgguucuccaagcacccagcauccugcuagacgcgccgcgcaccgacggapac\n", + "cugacaaacugcugaauuuagcuuagugaaggucaucaacugaacgcaguuaaauuucuaaugguuauuuucugguugauguugauggcaaggaaaaccuc\n", + "gcpcupcggcagccggagcggcpacuggccuggcgccggcggcggcggapcgccgcpcpcgaugugagcgcggcgcucuggacag\n", + "guucuugcuauauugccccaggcuggucucgaacuccupcucaagccguucucccgccucccacugcccgccugucacugccgucuguucccugagcugugcuuuacg\n", + "cupaaagacauagaagaacuauuaagaagauagaauuguuuugcugcgcaguacagcaacaguggauguucaagauuaagauuagagucaaguugugugauuaagacag\n", + "acagucuuccucugucauccaggcuggaaugcagugcaguggugcaaauuuggcucacugcagccucugccuucuguguucaagugauucuucuucugccucagccucucgaguagcupauuacag\n", + "ggcccagugcuccagagaaaggccggccugcagcacccgccaccgucgccggccgcccgcacguccguccg\n", + "agugcuccagagaaaggccggccugcagcacccgccaccgucgccggccgcccgcacguccguccg\n", + "ucgaggcgccaugacgagccgauuggcupcguuggaaugcccgccapcaapuapaggaggcggccgaaccgcgucgcupccgaaag\n", + "gauccagcaaugccugugagaaaaccuccuucaccuuccucaggcaggagcugccugugcgccuggccaacauc\n", + "uauacaggacggauucguauaggcuugcacccugguuccgaauuuugcaaauauucgcagucupucacugucauccggacupaauccccaagacccguuaapaggauag\n", + "cacugcaaccauugccucccagguucaagcgauucuccuaccucagccucccgaguagcupauuacag\n", + "uaaupaagcaggaaccggccpccucucgacpcugcugaupaauppcauuuacaaggacggucccgagguuucuucgupccucaugaapucuugaaga\n", + "agaggugcagccaucuguagagagaccuggacupcaugaapucagacaccccupcagagg\n", + "ggcggccgaaccgcgucgcupccgaaaggugcgcgagcgcugcccgcgcpaccacaaccaaagucgcggccgccgcagcc\n", + "gucaauggaauguuuccacauauuauaccaccaacaugagaaaaaaaugaucauuguuuauuugaagcuug\n", + "aguuccgcuuccggcagcgcgagauaaaucacgagaggaagcuuaaaucugucguuugaauuuaggaccaccucg\n", + "gcggcggcggccgcgguggcagcgaaggcggcggcggcggcggcaguggcaguggccgcugcagccccacacuccgccgccaaacuggaggagcgacggaagccagaccccaggag\n", + "gagcgugcaucauucagaagauauaagaagcuuagaagguagaaaaguggauuucuuugauuuuucagacgacauugcugaaaaacauauuaccacagacaauuugaaggacauugacu\n", + "augucaacugaupaccccuuaagccagaggcagaucucucapaagaaggcaugauuccugauaupcaaagugcugg\n", + "cuugagcgugcaucauucagaagauauaagaagcuuagaagguagaaaaguggauuucuuugauuuuucagacgacauugcugaaaaacauauuaccacagacaauuugaaggacauugacu\n", + "ugugcacuagccuaccucccugucgcucucugcgugupupugugcaugugugugugugugapuauacauuuu\n", + "ggcaguggcaguggccgcugcagccccacacuccgccgccaaacuggaggagcgacggaagccagaccccaggag\n", + "gauuuccacuggacaaagcgguugccuaugcaaaacucaggaauccauuuguaaucaaugacuugaau\n", + "aacaccucaccccugccuccpaugaaapuaaccuagaccugaaupcuugaccaucucacaacugcucgcgugacgaccgcauucguggcag\n", + "aaguuucugcgucgagcuccgaggaggcuggcgcaacccgcaccgcpccgucgcggcggcggcggcuugaccaccccucuugccccucucaagg\n", + "auggaguuucacucuuguugcccagacuggagugcaaugacacaaucucagcucaccacaaccucugccuccupuucaagcgauucucccgccucagccucccgaguagccpauuauag\n", + "gagcuggucccguugugcugcggcgccgcgcggccugcagucccpcccgcgccccgcgccgcccgcccgcccgcc\n", + "gcuggucccguugugcugcggcgccgcgcggccugcagucccpcccgcgccccgcgccgcccgcccgcccgcc\n", + "ggcggaggccgcgapapagcacgagcgaggaggcacgcgcccgccgguccgcacccggcccgccgcagccgccgccgccgucgccgucgccgcagcagcc\n", + "acgagcgaggaggcacgcgcccgccgguccgcacccggcccgccgcagccgccgccgccgucgccgucgccgcagcagcc\n", + "agguccggagcccggacuggcggaggccgcgapapagcacgagcgaggaggcacgcgcccgccgguccgcacccggcccgccgcagccgccgccgccgucgccgucgccgcagcagcc\n", + "aggcugcuggagaaggcgcaccugcugcaggugcucccggccgccccggaccagcgagcgcpcacugcggcpagg\n", + "auaugaagaucaaugaugcagacugaugguuuugaugaagcupcauuuauaacuagauucauuaaggaauacaaagaaaauacuuaaapaucaaua\n", + "agcccaauguuuccaaaggacauuaauuuugauuucuccaaugaaggcuuguggcuguccuuaugcuuuacaaaacauuaccaaaucagagccgaaaagaaaacu\n", + "ggagccpccggccugguccucpcggcugcuuggccaccgccaccgccguccgaapcucgagccc\n", + "cggcgaacagacguucuuucuccuccaugcaguuacacaaaaggapcuacggaaacuaaaaguuucpccucuggcucggugcguggagaaaagagaaaaccuggagacp\n", + "gccccgccggcggagccpccggccugguccucpcggcugcuuggccaccgccaccgccguccgaapcucgagccc\n", + "aaaaugaaucagauaaaugagccpcagcuuuuuuuuuuuggaguggucuaucauuucaggcuggugcuguguaagcaag\n", + "gcagccggacggaggcagccgcggcgaacagacguucuuucuccuccaugcaguuacacaaaaggapcuacggaaacuaaaaguuucpccucuggcucg\n", + "aaaapcpcgagcacggcccgcpcggcguucgcuggagcugguggaccpcggcugaccgapcggacgcgcggcpcagaccgcupacugcpcggcgcuguguccgucgcc\n", + "gupaaaacugaaacccaccuugauucguccccucuccccccuccccaccuucccucgcccuaaucccccaacgaggaaggaaggagcaguugguucaaucucugg\n", + "gcuagagugugguggugcaucucggcuuacugcaaacuccgucuccupuucaagcaguucuccugccucagcuucccaaguagcupauuacag\n", + "ggapapcugccgacucccuguuccuccagcaaggaaacucgaaagcucuccgguuuugcagaguggcaugugaa\n", + "ggccgcggcaggagcagcpagcuacagcaucagcaagagcaacaguagcuacagccccggcggcggugccuguuccagucuuugcugcugca\n", + "auggagucucauucucuugcccaggcuagagugugguggugcaucucggcuuacugcaaacuccgucuccupuucaagcaguucuccugccucagcuucccaaguagcupauuacag\n", + "uacuauggacuacaaauuuuggaaaaugugauaaaaacaagguggaagauucuuccaaggaaccagugcgaag\n", + "gguggagagcuupaupapapcugccgacucccuguuccuccagcaaggaaacucgaaagcucuccgguuuugcagaguggcaugugaa\n", + "aaguacugacacauuuaaaggagcauccugaugcuuggacaagagucgacacaauuuuggaauuuucucagaau\n", + "uagagacpuuuugccauguuggccaggcuggucuggaacuccugaccucaagugauucgcccaccucggccucccaaagugcupauuacag\n", + "ggagaagcggcugcagcggccgcggcaggagcagcpagcuacagcaucagcaagagcaacaguagcuacagccccggcggcggugccuguuccagucuuugcugcugca\n", + "acgccgaggccaugcugcauagagaaapcggugaacuuaaggcgccuggucuaaaugccuccuccgaguaapcp\n", + "gccucccgaggagcccagacagcugcagccacagcuccccguaucaagaaauuugccaucuaucgaupacccagacaaggcuggagacaaaccucau\n", + "guaccuggccaguggcucuggagacaccaccgugcgcuucupaucucagcacagagacaccacauuucacaugcaagg\n", + "gacacagacacupuccuuaguauauccuggucuccagauggcaggaagcuggccucaggcugcaagaauggccag\n", + "auucuccucupacccaagcacapaagcaggupcaggacccucgcuggccacagcaaguggaucacaggccugagcupagccccuccaugc\n", + "acaguaaaaaguccgagugcagccgccpcgcaggaupauccggcuccuccagcuaccggcccaaggccaucuaccuggacaucg\n", + "ccucccgcggcggcuggcgucpaaaguacaguaaaaaguccgagugcagccgccpcgcagg\n", + "aguggcagucaggccuccccgcucugugcuaccugcggcccggcucuccuccgcgcccccacucgcgcugcg\n", + "ggcagucaggccuccccgcucugugcuaccugcggcccggcucuccuccgcgcccccacucgcgcugcg\n", + "ggcaggcuggcupuaccggcugucgcugacccaggagaagcugccugucuacaucagccupcugcagcgcgcugccgccgcpccggcag\n", + "gccguggcaggcuggcupuaccggcugucgcugacccaggagaagcugccugucuacaucagccupcugcagcgcgcugccgccgcpccggcag\n", + "guggcagcggccguggcaggcuggcupuaccggcugucgcugacccaggagaagcugccugucuacaucagccupcugcagcgcgcugccgccgcpccggcag\n", + "ccguggcaggcuggcupuaccggcugucgcugacccaggagaagcugccugucuacaucagccupcugcagcgcgcugccgccgcpccggcag\n", + "agcggccguggcaggcuggcupuaccggcugucgcugacccaggagaagcugccugucuacaucagccupcugcagcgcgcugccgccgcpccggcag\n", + "guugccauagagaucgucgagcgcupccugugaucgcugapcgagcaguugcgacccupcuccupaccugagcguu\n", + "gguugccauagagaucgucgagcgcupccugugaucgcugapcgagcaguugcgacccupcuccupaccugagcguu\n", + "ccauugguugccauagagaucgucgagcgcupccugugaucgcugapcgagcaguugcgacccupcuccupaccugagcguu\n", + "cuuggcucgcugcgccucugccucccagguucaagagauucuucugccucagccuccuaaguagcupauuacag\n", + "gaggcggcuacuggcucaagaggacgacagaagccagucucugaugcccaccgcauucuccagcuucaggccucaagcccuguagccgagaaggcgaggccuaauguuacaccaccg\n", + "gccaaggaggcpuuuggugcggccacuccaaggccaaagcgagaaaaucuuacugcgcacgcgcaauagacagccg\n", + "cuuuauagaauugagagauugcugagccuaaauacauguugcugcauugccuccgagaauggccggaccuauccccacucucaccaaaacagagugupacucacugcucccucgccuacu\n", + "upaaguucgcgcaagugcggcucugcapaggapapccgapaaggcccucgagagaguggapcaacaguggccacgguuccucuguacuucguuucuucc\n", + "cucuuugccuggaaggugccugccugccugccugccggcccuugaacuuaaaucgucugaaguugu\n", + "gucaaauucaagauggauggaaucacagcggcagcggcggcugcggcgcgcgcgagccgagugugagcggaaapcccggcgucugccucgagacugaagaccg\n", + "aagacaugaaguagaaacaauccaggaaggcuuupaagcuauuugugugcgaggaucaaagug\n", + "upaugacgucaaauucaagauggauggaaucacagcggcagcggcggcugcggcgcgcgcgagccgagugugagcggaaapcccggcgucugccucgagacugaagaccg\n", + "gacgucaaauucaagauggauggaaucacagcggcagcggcggcugcggcgcgcgcgagccgagugugagcggaaapcccggcgucugccucgagacugaagaccg\n", + "ggcuccaggccuggcaucccgguagccgcagcugucuuuuccggcccccgugcacucuccgcccgagcggagccccccggcucgcpaucgcccccgagcgcugcguccugcpugg\n", + "pacaggcuccaggccuggcaucccgguagccgcagcugucuuuuccggcccccgugcacucuccgcccgagcggagccccccggcucgcpaucgcccccgagcgcugcguccugcgg\n", + "cccgguagccgcagcugucuuuuccggcccccgugcacucuccgcccgagcggagccccccggcucgcpaucgcccccgagcgcugcguccugcpugg\n", + "aggcuccaggccuggcaucccgguagccgcagcugucuuuuccggcccccgugcacucuccgcccgagcggagccccccggcucgcpaucgcccccgagcgcugcguccugcgg\n", + "gcaucccgguagccgcagcugucuuuuccggcccccgugcacucuccgcccgagcggagccccccggcucgcpaucgcccccgagcgcugcguccugcgg\n", + "uuucucuccagucauucggcucaguaccccgguuccggcgcugccpucucgguucpuucguugccccggugccpaccpccggucucuccggccgccccagccpcgcagcagccggag\n", + "cugccuguggaggaaccgauuguguccacagaugaggucaucuucccacucaccguuucacuggauagacugcccccapacaccuaaggccaag\n", + "ugagcacgcugcugacucugcugcccccuccgguucugagaugccggcaguucacuguggcuggaaaacacuugaccgugcucaagg\n", + "ugcugaacagcuccucucaggaggaaaucuccaucupauauccgaauccuccccaacuucaacgccaguuaucuaccuguc\n", + "gucacuuucaugaauucaaaggcaauuuaccagugauuucupugcupcugauauuuuuugugcauauuu\n", + "guggagguagaggaugauuucaauuagaaauaaugacagcaauagacgcuuccaaugaagauaucguggccaccaaaggacaaaggcaagaaguuaauuccugaagucgag\n", + "gauuauuaauccagcuagagaagaaauaugcuuuuacuuagcaagaaugaguauccaaagagcugauaauauuguuaaggcagcpuggaauggcagagcuug\n", + "gacuguuuugccggauucuaaaugacaacuuuuaaaucagagccuugaaaucuacagaaguccaauauauacugag\n", + "gccacggaaagguaugauauauuugauccaagacaguccauuccaguccpaaucuacaguggugacaaggac\n", + "guccpcuggugaupuuaauucccuuucguaagacucuuacuugcacccacccagccccgccgucgccccgccgcgccgcgcuccaaccgccuccuccuccucaguaacgcgg\n", + "cgguguccpcuggugaupuuaauucccuuucguaagacucuuacuugcacccacccagccccgccgucgccccgccgcgccgcgcuccaaccgccuccuccuccucaguaacgcgg\n", + "aguuuacagguacuauggaaagaacaucuccuuaacucuguaugaugaagcaaauaccaauacaaugaag\n", + "paaucggaucaaggcgagaggauccggcapaaggagcuucpccpuupccgcacauuuacgugcgcgaagcggaguggaccpagcuggugacg\n", + "uggcggagucpaaucggaucaaggcgagaggauccggcapaaggagcuucpccpuupccgcacauuuacgugcgcgaagcggaguggaccpagcuggugacg\n", + "gauuacgaaacgccgcggagcugaggcaguuccgcuggcuaguguguacgcggcgagcuucucccggcgccgcccgcucggcucccauagcgcccgcgacagcgguccggacgccgcccgaac\n", + "ggcgagcuucucccggcgccgcccgcucggcucccauagcgcccgcgacagcgguccggacgccgcccgaac\n", + "acgcggcgagcuucucccggcgccgcccgcucggcucccauagcgcccgcgacagcgguccggacgccgcccgaac\n", + "aguuccgcuggcuaguguguacgcggcgagcuucucccggcgccgcccgcucggcucccauagcgcccgcgacagcgguccggacgccgcccgaac\n", + "auuggagcuggagugagccuuccaggaauuuuggcugccaaauguggugcagaaguaauacugucagacagcucagaacugccucacugucuggaagucugucggcaaagcugccaa\n", + "uugaaauugcaggaggcgguugcuccggccugucucaagcucuguupugccgaupaaacugaggcucaggaagacaguugacuuguuccuggacuucua\n", + "ggaacaccucpucacccccgacaacgguggupapagagcggccuccuccucccuggupccugucupugaagccccucuguucccg\n", + "acacacccacaggaccugcagcugaacgaaguugaagacaacucaggagaucuguuggaaagagaacgauagaggaaaauauauga\n", + "cucugccggcuucgcccugaccuguuucugaccuguguucccuccgcugugccagaacaggcccc\n", + "gaggcpccguggcggcuggagguagcggcggcggcgacgcguccpccggugapcgcppcgccppcccaagcgucagcggcccgcgccugucpcugaacugag\n", + "ggccgcpapcggcgguggcugcagcggcuggagcpuagagaccgccpucucggcccgcaccaggagcggaacaa\n", + "cggagagaagcaggaaguagcggcggccgcpapcggcgguggcugcagcggcuggagcpuagagaccgccpucucggcccgcaccaggagcggaacaa\n", + "aggaaguagcggcggccgcpapcggcgguggcugcagcggcuggagcpuagagaccgccpucucggcccgcaccaggagcggaacaa\n", + "cgucpacaacggagauauuuucugcagaaagugacgaaagagcauucugguuccugcagag\n", + "acagagucuuacucuauugcccaagcuggagugcaguggugcaauuacagcucacugcagcuucaaccuccupcucaggugauccuccugccucagccuccuaagucgcupacuacag\n", + "aguuuucgucgccucugapcgccccgcggcuuuggauuugaccccgucaggcuaccgucgcggugaccggaacggcacuaaag\n", + "cucccuuaucccuucgcuuucgcucuuuuccgucgaggccgaccccugaguugugagucupucugguuggugaaaaagagcccuugaagcuggaagacpag\n", + "uucgcuuucgcucuuuuccgucgaggccgaccccugaguugugagucupucugguuggugaaaaagagcccuugaagcuggaagacpag\n", + "uuccuccccucccccuccucccuuaucccuucgcuuucgcucuuuuccgucgaggccgaccccugaguugugagucupucugguuggugaaaaagagcccuugaagcuggaagacpag\n", + "guuugcuuccpcguuucuuuugcuuccccuucccucuuucacgcuuccuccccucccccuccucccuuaucccuucgcuuucgcucuuuuccgucgaggccgaccccugaguu\n", + "uggcuucpcgccggccuccaggcccccpaggagaacuccuapcuacuaaauccucgcuggaggcgguggcuucuuaugcpaggacguggcggapccugacuuupagccp\n", + "gguugacuggauuggugaggcccguguggcuacuucuguggaagcagugcuguaguuacuggaagauaaaapaaagcaagcccuuggupaaa\n", + "gguugacuggauuggugaggcccguguggcuacuucuguggaagcagugcuguaguuacuggaagauaaaapaaagcaagcccuug\n", + "gauucccggagacagcupaugccagugcaguuaggcacucuccugucuucuuuucgacgcuucgcuguggucaagaggacaaa\n", + "cccpcgucguugcuccacpccugccuccacccgcpacaggugccccggcupucuguupaag\n", + "uuugugccugugauuggcucagcucugcgugugaagapaaaaggcuuccguuuauuuagcauaaugauggaccaaaacaaaagaagaaaucauuucacucaugcuuag\n", + "acucugcaggcgcauucccguagccuucgcgguuguacugaggaaaggugccgagugcacggauuuggagagccaucuuaggaauucccuuuucccguaucugca\n", + "ggcggaggcggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "ggaggcggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "ggcggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "ggcggcggcggcggcggcggcggcggcggaggcggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "ggcggcggcggaggcggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "ugccaccuauguguguaauuucauuacccacagcagucuuaggaggcuggucgaguuccuuauuugcagaugaggaaucugagguccagagaucacuucuug\n", + "cuggcagccugauaggcagauuccauuucaugaugucagauucccaccuccuguagguuauaauaaagauauaaaugaaagugaugaaguugag\n", + "ggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "guguauuccagagcaaaugaaaaagagccuugcuguuggugguuagcuaaagugaggaugauaaagg\n", + "gaggcggcggcggcggcggcggcggcggcggcupccucgagcgcccgcagcccaccucucpcpcucccggcgcuagcapcugaagagaag\n", + "gucugccugcccuccccacuggccpccucaaccucuucuccccgcaaccccaaccccagaggaaaagcccccucaccuggcgucccgcaacc\n", + "agccaucucuucccaaggcagguggugacuugagaacucugugccugguuucugaggacuguuucacc\n", + "agucpcccggaaguggucccuguagaaccacuguggcaccgcuacuccgugccgcgcccgucgagcauugcguugcugcauugcgccccaccgacuccacu\n", + "aggcgcgapaggcgagccggagcccgagcacuagcagcagccggagucggcguaaagcacccpcgcagccggagccggugccgcagcugcg\n", + "agcacuagcagcagccggagucggcguaaagcacccpcgcagccggagccggugccgcagcugcgauggccguggccgupagaccgucu\n", + "ucuacaucgguaaacucugcaaaacuccagcaguuacagagccugugcuaggagcuacapugaagapaagaagacucaagaaaccuguaaaacua\n", + "guaaagcacccpcgcagccggagccggugccgcagcugcgauggccguggccgupagaccgucu\n", + "gcuucccucccacccugucuuccuuggaguacugcagaaucuguaagcgucccuggaaugcacacguggaccuugucauucccaaacagacuuucugcug\n", + "cuucuccaggcuacuaguggccggaaaccpccgcggaggcacgaugagagccgugagagcccuagcacgacuugcccaaagacaauuucucag\n", + "cggaaaccpccgcggaggcacgaugagagccgugagagcccuagcacgacuugcccaaagacaauuucucag\n", + "uccuapacuacagaaggaaaaagacaagaggcaguaggauaucuguguguccucccgcugaccacacuuccuuuagugacccgauugccuccucaagucgcagacacu\n", + "aucccugagaucuuuuuauaaaaaacccagucuuugcugaccagacaaagcauaccagaucucaccagagag\n", + "auucacuccagugaccaucccugagaucuuuuuauaaaaaacccagucuuugcugaccagacaaagcauaccagaucucaccagagag\n", + "aucucugcaagacaaaagucagaaauggcuucccupacugagagcccauaguucucuucccacugcugcuucuacccuuuuguuuugcuuggcucucuaaaauugucucagcuccag\n", + "cucuucucacagacaguuuuaucaucuuaucauuuuuggcacaaaacaaacuauguuuuauucaguuuaccaagaag\n", + "gugugcuggugucucuaagccuuucupccgcagcuggagaaaguggugauugacagaagccuggupaagcucaucucagacaccaucagugaug\n", + "aaauuuuuuaaauaaauagacugguagagaacacugaucaguauccccuaauaaauccacuuuauccucggaugguuucuaucauguaaacauaggauuaaacucuuagcacaaauaaaaugga\n", + "auuccuuauauuacauggcaggappuaaacugapauagugaagacaacaauaaauuaaucaagagcuuuccucauaucucagaaccuauccucuguaaga\n", + "aagaaacaagaucuugagcugagcaagaacaucccagcaucuucauugacuuuaaaaguauauucuggagucuuccgugguucacuauuccaguacuacagag\n", + "puuuauugccccaggcugcuacuggcacaagccacagaccagcagucccagcccapaagcucggaag\n", + "ugagagacpaauggccgcugccaggccccaggaccuagaapaaaggaaauaccuucuucuapaacag\n", + "gaugcccgucgccagugacaccpacaacagcugcpcucugugcgagcggcccagcagcgcggagccucagcggagugagcgagcgcpcaguagcggccugcg\n", + "ucgcgccuggaucccagcgccccgaucccggcgccccaacccccacgcccgccuccgccaacuuucacgcugccucggcggcccggcccggcucgacgcca\n", + "upaaggapaggacugupaaggagaggaggaccgupaaggagaggaggaccaupaaagagagaggaggagccupaaggagaapacugcagcaucagcuccaguuuugagg\n", + "gcugccaagugaaucagagagacuugcaguucucggagagcacggaacuuauuccugcccagaguucagacacagccagaaauuaccauuucauacuucacaga\n", + "gaggaggaccaupaaagagagaggaggagccupaaggagaapacugcagcaucagcuccaguuuugagg\n", + "paggauuccapaguucupaccuuuucaaacugaagagaggaggcuggcugcaucaupagaagag\n", + "gcauuguuagaagcugagaaaguagacauacaauacuguuguuuuuucaauucagaagaggcuaaaacauuaugaagcugguaacucu\n", + "paaggagaggaggaccaupaaagagagaggaggagccupaaggagaapacugcagcaucagcuccaguuuugagg\n", + "uuuggucccaaguaugacucapuuaggcupuccucaggcuccgugcuguuggaaggaagupaggauuccapaguucupaccuuuucaaacugaagagaggaggcuggcugcauc\n", + "gaaauaaagaaagagaugaagaaagacccucucaccaacaaagcuccagaaaagccccugcacgaagugcccaguggaaacucuuugcugucuucugaaacgauuuuaagaaccaauaagagag\n", + "paaagagagaggaggagccupaaggagaapacugcagcaucagcuccaguuuugapuag\n", + "auuuggucccaaguaugacucapuuaggcupuccucaggcuccgugcuguuggaaggaagupaggauuccapaguucupaccuuuucaaacugaagagaggaggcuggcugcauc\n", + "gagcacggaacuuauuccugcccagaguucagacacagccagaaauuaccauuucauacuucacaga\n", + "uuggaggcugugguaaccgugaacuagcugcacgaacacggucccuccugccuuuccguccuccucccucuuagccggacucccuaacccag\n", + "aauuguugguaguggccacaggagcaggaagcgcuggacacagugacuucacauguuuacacaaaaaccugaauaag\n", + "gagcuuggcgguuccucuggccacuuucucacagugucuuupcgucuucuugacugaaucugacuccauuggaggcugug\n", + "gcagcugcacggugcccgcucuaccccgccgcagcggcupacguacggagcccgcaagucccggcccgag\n", + "paaagauaaaugaaguguuuggcaaguagaaagauaaucaugaaguucagucauuaaagucucgcccugaacaaaugccauggacuugacaucauaaaaaacauaaaauag\n", + "pcaugaauaucagacgcuapacagccacuguguugucugcuacccucauccuggucacugcuucugcuauaacagcccuaggccaggaau\n", + "puuguacagaagagguccgguuucuugaagcagcuggaaguccuggauaguucccaccugaaagucuguuugcaaaggcaaugcgcacucaggcaccagapcagag\n", + "agacagacapuuguacagaagagguccgguuucuugaagcagcuggaaguccuggauaguucccaccugaaagucuguuugcaaaggcaaugcgcacucaggcaccagapcagag\n", + "gcaccggcaucggcugacacugcugccuccagcuaguuauuucguccucuuccguucuucaccccuacaccuugga\n", + "gaggcgccgguguuucgagccguggcaccggcaucggcugacacugcugccuccagcuaguuauuucguccucuuccguucuucaccccuacaccuugga\n", + "gcccauccuuuuagcaccgcgagaggcgccgguguuucgagccguggcaccggcaucggcugacacugcugccuccagcuaguuauuucguccucuuccguucuucaccccuacaccuugga\n", + "auguucgguuccugcugccacugcugccgccgcccccggagcugcugguuucauucgagguuucpccg\n", + "ggauguucgguuccugcugccacugcugccgccgcccccggagcugcugguuucauucgagguuucpccg\n", + "aaggcaccugcggccgcpccccugaucuucgugcagccgccgcpuccgugcgcccagcgucccapcccaggccgagcag\n", + "caaugcaugagagcuggaaguggaagagcuuacaagaucaucaucgcucacuguaaccuugaacuccupcucacagaauccucccgucucaggcucccacauagccaggacuacag\n", + "cgccgugaagaaccugguggacagcagcgucuacuuccgcagcguggapucugcucaaacaggccaucagcauccpaccauaugaaugccagugcccapccacag\n", + "cccggaggaaccacccccgcccuccucagccugauccuggaagagacucpccccccagccuccgccaacccag\n", + "agccucggcccggacucgccgccaacgaggagccgagcgcccuggagaacgcgucpcugagccpuccagcagccgccgcu\n", + "agagacucugcugcuuuuccupcapccugcuugcuccagcucucaagucugacuugcaucuacacugcpcaag\n", + "ucuguagacuguguucacacugccuccguuuupaaacuugagacaugcauaaaagcgucuaga\n", + "gcuugaguuacugugcucucuuccaaggcuguaggaguucuggagcugcuggcuggagaggapuggacgaagcucucuccagaaagacauccugagaggacuuggcag\n", + "gugcucucuuccaaggcuguaggaguucuggagcugcuggcuggagaggapuggacgaagcucucuccagaaagacauccugagaggacuuggcag\n", + "aguucuggagcugcuggcuggagaggapuggacgaagcucucuccagaaagacauccugagaggacuuggcag\n", + "guaggaguucuggagcugcuggcuggagaggapuggacgaagcucucuccagaaagacauccugagaggacuuggcag\n", + "cuggagcugcuggcuggagaggapuggacgaagcucucuccagaaagacauccugagaggacuuggcag\n", + "aucuuucuuccguacuggaugcuuccugcccuugaacaucagacuccagguucuucaguuuuggaacucaaacuggcucuccuugcaccucagccugcagauggccuauugupaccuugugaucau\n", + "agaggaauuaagccaaacauacucuaguggagcugucuauauuacaccaaacaaauugaauaaugcugaaguguuggccag\n", + "cuggugaaugagcaacaagaaagcagaccccuccugagucccuccaucgaugacuuucucugugaaaccaaaucggaagcaauagcaaggccaguaacauccaauacagcug\n", + "acauucaaacacaacuggaaaaaupacgauguuaaguuucauggagaucgaaauaccaapacaucca\n", + "aaaaguaaagaacaaggauauggaaaacuaagcagugaugaagaccucgaaauaauuguugaucaaaagcag\n", + "acuauacacaaguggcuucuucccugcuaugcaccaguggcaugcacaaaccaaaaagaagcagaaugaucugaaaaa\n", + "aacauuagaauaucuuguaauaaauaauaaguuaaagaucucuccugacacagucauuguugauuucacuguuauapaaaaggcucuapcggcagauaaggcuguugcc\n", + "aucugugguucucuggucagcaaguucuggcaaggaagccacugccaguggcauaaagaauucup\n", + "gugcguaguuucucugaaaagcaucacccaggucagaaugaaaggaaacucucugugcagaccgcuguaugupaccuuugaagacagucaaauaguguucaauucuaua\n", + "gupcaggapcuggaaaagccggcgcuggagcpaacpaguagcugccupcgccaaaggccgcggcacucccacgcggaccccgaaguccgcaacccpaupcccgcggcugcgag\n", + "agccggcgcuggagcpaacpaguagcugccupcgccaaaggccgcggcacucccacgcggaccccgaaguccgcaacccpaupcccgcggcugcgag\n", + "gccucuuccucugccccgcuucggccgccucccgccucucapucpuugucuguccccuucgcugucacauccuccgcacccagcgcuuggaaggugcuccaucacggugacagacag\n", + "aguagcugccupcgccaaaggccgcggcacucccacgcggaccccgaaguccgcaacccpaupcccgcggcugcgag\n", + "agagcaccgcccagcagccagupuucccgcgcgugccgagacucugaggccuugcacccccacgaucccguacg\n", + "accgcccagcagccagupuucccgcgcgugccgagacucugaggccuugcacccccacgaucccguacg\n", + "aacccagccagaggcagcccggccpaggaccccagcpaaupcpaccucpcggagcuccuaacuccggcaaaacggagcucuugaccacgccuccgcaaguuccuauuaa\n", + "apugacguagauuuuuuuccuucgccagucucaccguuacccpcaacagcugagccgucupaapaugcaucu\n", + "uuucuucuguaugcuugagucaagaacucuaagucaucuugguaauaccpuuggaugcuuaaagcugcagcaaaaagaccagaacuuucag\n", + "acuuccgaauupucauggcggaapuguuaauagccuggccgcccgugccccapaaugcuuauuuuugaccuuaguugcaaagugag\n", + "cauugagccuuaccccuuacuggaggcugcaggacccucuacacacagacagcuguccagcacggaaggupcugaggcccapugaac\n", + "gagcccguggacaaggcccacugccugagccugaacuaggagcaccuccuapacugcccaggcuugcucugcucugacccuucugcuggccagucupcaccug\n", + "ggaccugapagcucapapagagaagccagaagaccaggcagagacugaagagagcuggcaaggccuggcuagaaaaacuccaggcaaggccugu\n", + "puuugaaugugccccggcpagapaagcugcagcgagagcgcgcggaucucagcgcpagcagugcuucugcggcag\n", + "gauugaagaaugcgccauuaaaaggaaagaucaaggaguaaaccagaagaagaagaaaaagaggacuucaaag\n", + "gucaaucaggcgcpcugagcucuacgaggcggagcggcggcgguggcgacggcgaupaccccagcgagagaucugcagcuaggcuggcugcacuugcuccacpucapaucggap\n", + "acgaggcggagcggcggcgguggcgacggcgaupaccccagcgagagaucugcagcuaggcuggcugcacuugcuccacpucapaucggap\n", + "gauacaagagcuggaaggcggcuccggcgcagaccuuggagagcacagcugccggcccgcgagccagccucgguucccgcggcccgccgaggcucggagccauccagcgacccggcgaccggccucag\n", + "gcggcagcaacugaagagcccaccccupcaggagaccccccaccucaguccaggcccaupugcagagaaggaggcagagccgccuacuuauccccagcucag\n", + "agcccagccccagccaccuccgcgucuacgccgccgccugcucuggccpccpucagagccggagc\n", + "gaauacuugcuggcupcagauaucauugaaacaaauacuuuuagcagcacuaguauugcccaagcugacuauggccuugaacacuug\n", + "cgcuggcuggcguggcccuuggccgucgucaccuguggagagcacgucuucucugccgcgcccucugcgcaaggaggagacucgacaac\n", + "agcaccaggcgcccggcggccgcugugccaggagccccgcgcugcccuccucccccugcgccgccgccgccgccacccccpcucpuggcccccgcuucagucccapcag\n", + "cugccuucaccagugagcacaaagccacauuucaaaggaaacugacaaauuauccccagcugccagaagaag\n", + "ccuuccugcuucccuccuuccagagcagaccucuuugucaccccgagcuccuuguuucuuaagcaguc\n", + "acugugcupuguacaucuacacuagacaccuuccugcuucccuccuuccagagcagaccucuuugucaccccgagcuccuuguuucuuaagcaguc\n", + "cguccacccgcccapagagucagaccuppcgapccccccaaacucaguucggauccuacccgagugaggcggcgcc\n", + "auugcagaagauucuuccauaaagaagugaucuguagaacacuugcuucuuuaucccaccauauagucuuauuaguugug\n", + "cucgugcccgcacgugcgugucucggucaguagcccugcgcuucuccuucacucucggcgguucaggaggcucugccgcagccpcccuccugugaccugcauguacupauucgcapagg\n", + "gugcccgcacgugcgugucucggucaguagcccugcgcuucuccuucacucucggcgguucaggaggcucugccgcagccpcccuccugugaccugcauguacupauucgcapagg\n", + "gccccagcuguggugaupuagcuaggaggccupccucucugccugcuguagccgucugccgcgcccuuguuccugcagcu\n", + "acggcuucggcgccccagcuguggugaupuagcuaggaggccupccucucugccugcuguagccgucugccgcgcccuuguuccugcagcu\n", + "guccaguuaucuuuugacugccacauauggaccccaaaagaucucaaaaggaaaguguccucauuacaggaggaaguggcuauuuugguuuucg\n", + "gcccgcaccccacauuccguccuguuuugagaggaggapaagagaaauaaacguggcagcgcauagaaggccagcapag\n", + "acugcuuuccagacaccuccggcccacacagccguucaccccccgucuuuucaguccuggaaaaggaauucgg\n", + "gucugucuuccuuuupcucugugcaacugcagcuacaguggaaaaaagcaaacugcucuugaucccag\n", + "gcccugccuaagccucagcagaacuuguaagccuaaacugaagagccucacccggacgagcaggcaucccuuaaccuuaagcaauccaguuccacgcccuggaucagugaauaaccccagcugcacc\n", + "upuaccaacucuauugcgcagcucgcugccgugcguuuaacccaggcgaggaggaggaggagaaaauucccccagauucpcag\n", + "gcuuucauugucuaacgucgacagucuauauuucugcucuucagucuguccuuaggaugaagcucuaacugaacugaaguaaggagaaacagccuugaaucuuuggagg\n", + "uauugcgcagcucgcugccgugcguuuaacccaggcgaggaggaggaggagaaaauucccccagauucpcag\n", + "ucuguccuuaggaugaagcucuaacugaacugaaguaaggagaaacagccuugaaucuuuggagg\n", + "cuccucupuaccaacucuauugcgcagcucgcugccgugcguuuaacccaggcgaggaggaggaggagaaaauucccccagauucpcag\n", + "cucuauugcgcagcucgcugccgugcguuuaacccaggcgaggaggaggaggagaaaauucccccagauucpcag\n", + "acucuauugcgcagcucgcugccgugcguuuaacccaggcgaggaggaggaggagaaaauucccccagauucpcag\n", + "gcccgcaccccacauuccguccuguuuugagaggaggapaagagaaauaaacguggcagcgcauagaaggccagcapagguupaaagg\n", + "apagccccagaguugguggcuggcuaacccaaggccccagcggcagccuccgcccggccagcucgcc\n", + "agagcagccuuggcgcuacggaggagccuapcuaacccucagccauaccupcugguccuggaguugcuacgcapuuguggcagcacugacugaaggu\n", + "auucugcuucucagaagaugcacuauuauagauacucuaacgccaaggucagcugcugguacaaguaccuccuuuucagcuacaacaucaucuucugg\n", + "cgccgcucggacggcccgagucgcgcccucccgccccgcgccgcggaacuugcucuaacuuccucggccgagccpccgcgccgccgcugccgccgccgcgcgcgg\n", + "agacgaacucuugcaauguugccuuggcuggucucgaacucaucuucupuucaagcuguccgucugccucggacucccaaagugcuaggauuacag\n", + "auuaaaggauuuaccugaagagaaagcauucuauucaucagagacuggacaagaguuacucuugcauuuggcaauuaaag\n", + "ccccggcaggacgguagaagucgugguuugugcgcggccaggcgcuggagccuccgcugccpagca\n", + "aucagaccuuccagcugccucucauguacuugucuguupcuuguguugaucaggagugaauucacagucuacc\n", + "gguucagcgacucgcccapuugcacagcgagcacaggcaccgacgucgcccuccgaggccupcuuccagcapagagacccggacaccugucaucgcuucucgguggaucccugaaau\n", + "cuuagucacccugupcgccugucagccucacucaagaauggagcugguggcugcauccccagugacg\n", + "auuuucugaauggucuugcuucuuugucuaucuugucugauuuucuccugucugaccuuuuccugguuaaaaaucupaaa\n", + "aguacaucaagauggcggaucauuacguccccgucccaggapcccaauaacaacaacuaugccaacguggagcugauuguggacauugccaagagaauccccgugcag\n", + "gcggugupcuggcupccaugcuucagaaaacccuaaacuuccggagcugcugugcaagaauggaguugcuuucuuag\n", + "gcccucccagugaggccaugupccuuaggagauaagaucgccuccaccguugucgcccagacgcuacaggucccaacccugcccuggaguggaagcg\n", + "gccugacaguggaguggacagaagaugaucugcagcapaaaaagaaucagugucccagaagauguuuaugacaapuugcgugaaagacguagaugapcuuggag\n", + "gcagcagaaagaauugguuuuccauugaugaucaaagcuucugaagguggcggapaapaauccggaaggcugagagugcggaggacuucccgauccuuuucagacaa\n", + "gcggagaaaccggauaucaugcuupugguaugcpccuugaacguggccgaugcgauguucagaacgugcaugacagauuucuuacacucccuggaaag\n", + "pccagguccucccagcggauucacuacugaaccucguagauguggaauuaauuuacggagguguuaaguacauucucaag\n", + "auagccaccauccuggacugccaugcagccacccugcagcggaaggcugaucgagaggucuucuucaucaacacccagagcaucgugcaguugguccagag\n", + "auaccgcagcpauccgcggcuauaugaaaacagugguguuggaucuccugagaagauacuugcguguugagcaccauuuucagcaag\n", + "cccacuacgacaagugugugauaaaccucapagcaguucaagccagacaugucccaggugcuggacugcaucuucucccacgcacagguggccaagaagaaccagcuggugaucauguugauc\n", + "gaugagcuguguggcccagacccuucccugucggacgagcugaucuccauccucaacgagcucacucagcugagcaaaagcgagcacugcaaaguggcccucagagcccggcag\n", + "auccugauugccucccaccuccccuccuacgagcugcggcauaaccagguggaguccauuuuccugucugccauugacauguacggccaccaguucugccccgagaaccucaag\n", + "aaauuaauacuuucggaaacaaccaucuucgacguccugccuacuuucuucuaucacgcaaacaaagucgugugcauggcguccuuggag\n", + "guuuacgugcggapcuacaucgccuaugaguuaaacagccugcagcaccggcagcucccggacggcaccugcgugguagaauuccaguucaugcugccguccucccacccaaaccg\n", + "agaguaagcagcuagcaggcuuagauucaggcccucagcaaacaaggaaccuggaaaauguaacccugaaugcacggupaggacauggcaagagaaaagcggcaggaauaaagug\n", + "gauccgagccpacpcugcaggcpugcugcagaggacacgaggcggcpcuggagac\n", + "gucugcugagaacagacccagucccugaggaaggagaagauguugcugccacgaucagugccacagagacccucucggaagaggagcaggaagagcuaagaagagaacuugcaaag\n", + "uuacaagaagacaucugaaaccuuaucccaggcuggacagaaggccucagcugcuuuuucgucuguuggcucagucaucaccaaaaagcuggaagauguaaa\n", + "pagucgccggcggaggcgaggaggagcucugcgcggcgcggcpcgauccgagccpacpcugcaggcpugcugcagaggacacgaggcggcpcuggagac\n", + "gcpagucgccggcggaggcgaggaggagcucugcgcggcgcggcpcgauccgagccpacpcugcaggcpugcugcagaggacacgaggcggcpcuggagac\n", + "gacuucgcpagucgccggcggaggcgaggaggagcucugcgcggcgcggcpcgauccgagccpacpcugcaggcpugcugcagaggacacgaggcggcpcuggagac\n", + "gucuucccgcgccugaggcggcggcggcaggagcugapaguuguapaacugapagcugcugugucccccgccuccuccuccccauuuccgcgcucccpacc\n", + "guguucagaaugccaggauucccucaccaacugguacuaugagaaggaupaagcucuacugccccaaggacuacupaaguuupaguucugucaupugcucccugcug\n", + "agucugucugcagcccgacuccaaguucuuuacaccacaccgccucccucaggugucuggaccauacuggcuucucuugc\n", + "gcgagguuucaagauggcgguagcugapuugaccgagagacccaguugaaggccuuuacgaagugaaagaggccpagucgcccccuacccgcuucucguaguccupagcacagcagaagu\n", + "gcuuaggugcccgagcuacugapucuaaguccpcagccgaagagugugguagguaacgguccucagcgcaapucauuucgucgcupaapacggcccucgcccgcggug\n", + "ggaaaugcguguucuagcuuucugugugcuuaggugcccgagcuacugapucuaaguccpcagccgaagagugug\n", + "gugugcuuaggugcccgagcuacugapucuaaguccpcagccgaagagugugguagguaacgguccucagcgcaapucauuucgucgcupaapacggcccucgcccgcggug\n", + "aguaaaaugucacacugcaaacucupccupucccaupacuucagugguuccaggacugauuucacugccaucacuuauauaug\n", + "gucacacugcaaacucupccupucccaupacuucagugguuccaggacugauuucacugccaucacuuauauaug\n", + "uuccuggcaagaaaaaaauuuaaauuaccuaaagaacuaauccauggaacaauucauuguaaagcuggagugccugaaauauugauagaagagguuuacacuuuauuaacacaucgaga\n", + "aucucuguaccgcacccuguguucuucaguupaaaaaaaapucugucgguaucgagugaugccuacacuug\n", + "aaugcaguagugacuucugaacuccuauaugcuggccaaaaaaagaaaaucaguuuuauuuugauuuuuguugaaugaacauucuucuuuaaaaguaaucuaaag\n", + "aagcacaggcucuggcguccaucucuguaccgcacccuguguucuucaguupaaaaaaaapucugucgguaucgagug\n", + "aauuccguguaccagauucuacugaagaaagguagccauggaagagaauauggaagapacagacacaaaaag\n", + "ggcauccaaacagaccaccupauuccucaguccgcuupccucugauagaagcauuugugugcuuguaugaucuuauuuucgcacg\n", + "acauaaauuucggcauugcuuacauauuaauccuupuuccuaggcuggcauuggagaaacuuuacu\n", + "gagagagcuuaugcccuugaaucaapaaaauagaguucacaaggagccagcggccggcagcaucacacuuuu\n", + "agcagguguucuguaagacagaccaggaagagguaguaaggcagccagaaagcuaccaugguacaccagagaagccaaauuauucuugagguacccacugagcuugucagcugcaauggcuaagag\n", + "gaacaauguacucagcugcaugccccagcaguaagacagcgugugucaggccaaggaaauaacuguuuccacccucccaaaagcaagagaucccaucacugacuuucacaag\n", + "gcpapuccgcgcguugguggugcucgccucgcagcugcgcccgccggcuucagcaccuuccgcuguccgccgcugcagccgccuccuccuccag\n", + "guguugccugaggcuccacugaagcuauggcauaauuugcagaauuugcacuucauuacuuuucugaaauucaaacaaauucugaaacugcacgaguucuggcugagagcuguggaucugugcau\n", + "gugaggcgcguguucpcucuugccguccccgcacccgcaccgcgguuacuggcuugcgguccgccguucgacaaccagcccuupuccccgcccgccacggac\n", + "agcccgcgcagcgccccgcapcgauggacggccgaaccccgcgcccgcaggacgccccagccag\n", + "gaaauuccaacuugcucccggcccacccccgccccguuccucucuccggcucgcugcuucccucgcucca\n", + "auucaaguccuggcuugagagccgagcggcaagagcgcpccpaapaagaguaggagaggaagccgcgapagaacaggcgagcuacugucuccuuuggaaaagaac\n", + "ugacgcgccgccupagcuggagcccgcgcagcgccccgcapcgauggacggccgaaccccgcgcccgcaggacgccccagccag\n", + "cuuucgguucagcuuccccagccggaccccaaagacccgaagcccupaaggaaauuccaacuugcucccggcccacccccgccccguuccucucuccggcucgcugcuucccucgcucca\n", + "gagccucgcapuugccgcuucuccauucaaguccuggcuugagagccgagcggcaagagcgcpccpaapaagaguaggagaggaagccgcgapagaacag\n", + "gagaaaaccaaaagccaaggcaccacuuccuccagcugagaccaaauauacugaugucucuucagcugcugauucuguagaauccacugcuuucauc\n", + "gucccaaaccaguugucuuccugcaacauggcuugcuggcagauucuaguaacupucacaaaccuugccaacagcagccupcuucauucuugcugaugcugguuuugacgugugg\n", + "uagguuuuuggucuuggugacuucaagaaugaagcugcggacucucgcugugagugcuacaguuguuaaag\n", + "agcuccugauucugcagaaaacacgaaacugagcuguacaaagaugcugaugapcugcagcaugcaauucacuucaccagcagucacuaag\n", + "gccggucguucggacgucuugccugucgcuggaggagagguccpcucuccaggaagguggcugcggcgacaaa\n", + "auuccugaggaggacugccggucguucggacgucuugccugucgcuggaggagagguccpcucuccaggaagguggcugcggcgacaaa\n", + "agccauuccugaggaggacugccggucguucggacgucuugccugucgcuggaggagagguccpcucuccaggaagguggcugcggcgacaaa\n", + "gcpagccgcuucpccuucupcaugucugccauauggcuccagguuuguuuuucuccccggcacucugacpapcucccggcaucuccuggcguccpuagaggacgcggagg\n", + "gagugaagauguuuucupcucccagugcuggcucaaacacacuucucccgaggugaccacacccugcuguaagcgcucagagaacuuugccugcacuuug\n", + "agucucgcuccugcccagcccpcggcugcccuupugcucccuucccugcccgacacccagaccgaccuugaccgcccaccuggcaggagcaggacaggacggccggacgcggcc\n", + "gupaagugauugcucccuggcuagcagagacagaggaaagcggauuguuggccccaggacccagcucugagaggcupcuuguuucccugacucugccuuggaggaaagca\n", + "gugacaggaaauggagcupagacaaaaauguggauaacaacaaaagaauuucaacagguaaaaaa\n", + "auucuaaaugcaaagcuagacugagcaapaagugacaggaaauggagcupagacaaaaauguggauaacaacaaaagaauuucaacagguaaaaaa\n", + "gacauucuaaaugcaaagcuagacugagcaapaagugacaggaaauggagcupagacaaaaauguggauaacaacaaaagaauuucaacagguaaaaaa\n", + "agcaapaagugacaggaaauggagcupagacaaaaauguggauaacaacaaaagaauuucaacagguaaaaaa\n", + "uuuagccguuuccaaggcuacgaagcccaucggccpauaagagagcaagaaaaugaagcucaagagccuccugcuccgguauuacccgccag\n", + "guuagucuccggcgaguuguugccupcuggacgugguuuugucugcugcgcccgcucuucgcgcucucguuucauuuucugcagcgcgccagcagg\n", + "gcugugaggcucggagucgccggaggagccaguaucugugucgccgccgcccgcggcguccccgguuugguguugcggcgcccaccuucpaggaucag\n", + "ccggaagupcugugaggcucggagucgccggaggagccaguaucugugucgccgccgcccgcggcguccccgguuugguguugcggcgcccaccuucpaggaucag\n", + "uuagcaucgcuccuuccucugccuggccccccuccucuaacuucuagacucuaguuuaaaaugaagcuauucggcucugcucagaccgguauguggaapagaaag\n", + "gaugcccccgcccccgccgcgucapuugcucccugcgcuuccgaguggcgacugcagcpuccggugcaggugapcgcgcgccugcccagcuuugcagcccccgaacgcggccucgcacag\n", + "gagucauugcaguuuucaguagagguguacuucugagaaguggcuucuupucuucaugcagcc\n", + "apuugcucccugcgcuuccgaguggcgacugcagcpuccggugcaggugapcgcgcgccugcccagcuuugcagcccccgaacgcggccucgcacag\n", + "cggccgapcgcccgagccgccgcggcggucgccuggaaaaguuuccccgccapcuccccagg\n", + "agccagaacuggaapccccgcccugugaapauaggagccugacuguugcagcugcagugaguggcpaagcagcagcggccaggaugaaucccaggugcucuggagcuggauggugaa\n", + "uuacauccuugcuaagccccacuccggcuacagcucuugcugucagauacgcauccaagaagucpugguagcuccaaaaaccucgguggaaagucaucaggcagacgccaaggcauuaagaaa\n", + "gguggagccgugagugapcguuugaagagcacuugucuuucuccugccucagcagcacggacpuuccuuggcgguupauuugg\n", + "apccaacgaaccpaauuucapacaupacagagaggaaugucucucuaccccccaacccccc\n", + "ugcuccucacaupucaacuguuccagugugcggupccacccpuucaagacaucuucacagcupaagcuccuggccuuggcccugauuaucauc\n", + "agaguagcagugguuccuauuucggaaaaggacguucuaauucaaagcucucucccaauauauuuacacgaauacgcauuuagaaapaggcagcuuuugagguugcaauccuacugagaagg\n", + "guggugauucagcagaaaccccagcuccagcagcuggcgcaggagcuaacaggauaagaaggaapaagagagagccaggaapaggapap\n", + "cucggcccccagagapupagaugacacaguuguucccccagcccuggcpcpcagc\n", + "ggcucggcccccagagapupagaugacacaguuguucccccagcccuggcpcpcagc\n", + "gguuugccuggcgcgcpaaguggagccagcguuuucuuucacccaguucccugcuuaguccagucccaccgugguucuucagagcuguucuuggcgugcuuccaguaup\n", + "cucauugaacucgccugcagcucuupuuuuuuguggcuuccuucguuauuggagccaggccuacaccccag\n", + "gucupagcgugcagccuccacacaggccuguupcuugcugaggcuupuucugagaaucucgucgaggcgagugugcggcuccuucuaccggcuuaaapccucaguuuucg\n", + "cacggaaaagucgagauaauugccaaugaucapaaaccgaaccacuccaagcuaugucgccuuuacggacacugaacgguugaucggugaugccgcaaagaaucaaguugca\n", + "guuacuuccuggagacuucaggugugguagccggcgccgcgcccauagccggacpaucugagcuggcag\n", + "aucagcuuuagagcuaccacaauuuuaaagauccgaguucagauaaucacugcugccccuggagucagagccaaggcuccaccuuucgag\n", + "acuuccuggagacuucaggugugguagccggcgccgcgcccauagccggacpaucugagcuggcag\n", + "gcuacguaugucuuccuucauacggugaaapacacccuuugagacuccugaccaaggaaaggcucggcuacugacacacupagcaa\n", + "agucccaguggcggaggcuacgaaacuupagugcacagaagaacuucpagcgcacgcpaccapaccaggcugagacucpcgccaguccpcapcagcpagccggccgg\n", + "aguggcggaggcuacgaaacuupagugcacagaagaacuucpagcgcacgcpaccapaccaggcugagacucpcgccaguccpcapcagcpagccggccgg\n", + "uguaggccuccaccauggacagaggccaggcccugccccucccaggcagccuggcuccuucugcupcccugaaggcagacpaua\n", + "gccuccaccauggacagaggccaggcccugccccucccaggcagccuggcuccuucugcupcccugaaggcagacpaua\n", + "cuacgaaacuupagugcacagaagaacuucpagcgcacgcpaccapaccaggcugagacucpcgccaguccpcapcagcpagccggccgg\n", + "agaugcccuguauccaagcccaauaupacaccagcaccgaguccpaccccgugaccaccuggcaagcgacccccugaccccugaguucaucaagcccacc\n", + "uuccugguguaagcuuugguauggaugguggccgucucccuacagacupagcuguuagapcapauccuagcugacacaucuauguccucgccuugguuggag\n", + "cccagacaaccggucuugcucgcugccuuuugcagaaucuucucacuucucccgagcucccuuccuugcguccguccpcaacggccgcguc\n", + "agcggcggcaacauuguuugguguuuauuuuguuuuacgaucgauagcuuucuucgcugguucpcggcugcugaacggcggaguggcguggaccucauguagca\n", + "cccagccccagccccagccccggccccggccccggcucgcpcgcugcgucuccgcguacaggaggcggcggcggcucccagucaccggcccccgccggcgagcgcacg\n", + "agccccggccccggccccggcucgcpcgcugcgucuccgcguacaggaggcggcggcggcucccagucaccggcccccgccggcgagcgcacg\n", + "cuggcpaggaaccuggacccugcuccagugcupcggaggcpagacgcpccgcpcgcaaacuupucguccucaggugcaccuccag\n", + "cuccagugcupcggaggcpagacgcpccgcpcgcaaacuupucguccucaggugcaccuccag\n", + "guuucugcagaaggagccccuaggcaaapaguggcgaccccagauuuauaggaaaugcacagauacggcaugguuauuccuguucuuucucuuuuggacugguuug\n", + "agugcupcggaggcpagacgcpccgcpcgcaaacuupucguccucaggugcaccuccag\n", + "agagcccgacuucagccccagccagaucccgcgucaacggaggcggaacggcggaccccguacccuggcagcaucggagcaccggcgg\n", + "pcggcccpcugcaaagcppccgccgccucccupccugccupcggccgccuccgcg\n", + "gaggcpacgcgcggcccgapcpcggcpcggcccpcugcaaagcppccgccgccucccupccugccupcggccgccuccgcg\n", + "gcuccaucuccauucupuucugaugaugccacuacuugucacauugugguccugaggcacacag\n", + "guaaupccaccugcuugacacauugugacggaaccgacaccaaagcugagguccccuugauc\n", + "aguuguaacggacuucaucacaucacaaauuguacucguucucauccuuuuaagaaaguucagacccaggaaaauuuccauaguaccuuaaugaaaaagauag\n", + "gcuuucaguuguaacggacuucaucacaucacaaauuguacucguucucauccuuuuaagaaaguucagacccaggaaaauuuccauaguaccuua\n", + "agagugucgcuuucaguuguaacggacuucaucacaucacaaauuguacucguucucauccuuuuaagaaaguucagacccaggaaaauuuccauaguaccuuaaugaaaaagauag\n", + "cagagugucgcuuucaguuguaacggacuucaucacaucacaaauuguacucguucucauccuuuuaagaaaguucagacccaggaaaauuuccauaguaccuuaaugaaaaagauag\n", + "gcacucccuccgcggccgcugagccgagcggacgcccccpccgcgucgcagcccuccgugcuccccccuaucaugcccggugcccaggcupccgcccaagcagccaggacacc\n", + "agaaggcaacagcucuaccauccuccaaacaucugaagccccccauagaaacuccucuuggaauug\n", + "aacuaaacuauaagagguaagcaguucucagaggagacagaaggcaacagcucuaccauccuccaaacaucugaagccccccauagaaacuccucuuggaauug\n", + "uuuagcguagaagcaauuuaauuuuaauuaguuuuuuuccaauuuagaagauaauacauggucacugagguaauuuuggaacucagcaaaaacuagaaguugccuugag\n", + "gaagucuacccaaggauccccagcgaaapagccauaguccgaggcucuggcugccugccuguuuggagcuuugauggccucgag\n", + "uuggcaaccagaacgccagguuccauuuaaugaaguuagauuaccaccaccaccugauauaaaaaaagaaauuagugaaggagaugaaguagag\n", + "cuuugcgguuccaacauggcggagcugacgguggagguucgcggcucuaacpcuuucuacaag\n", + "guguaguguuuugaguccggcuuccauuuagcguagaagcaauuuaauuuuaauuaguuuuuuuccaauuuagaagauaauac\n", + "pcggagcgagcuggacgguggacggagcuaggupcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucpugag\n", + "agacagguuuucacuguguugcccaggcuggucucaaacuccuggacucaagaaauccgccugccucagcuucccaaagugcupauuauagaugugaaccacugcacccggcccaauag\n", + "uaaaaacaaaaucaacggccaaaugacucaacugcgauugugccagugagaaccucaggagccuagcagaagauaacgcupaapuucaaggagcuaagccgagaguuuuggcugcccaccacag\n", + "ucccuuuucuuuggcaagauggcggaguacgacuugacuacucgcaucgcgcacuuuuuggaucggcaucuagucuuuccgcuucuugaauuucucucuguaaaggag\n", + "agugagcacagacucccuuuucuuuggcaagauggcggaguacgacuugacuacucgcaucgcgcacuuuuuggaucggcaucuagucuuuccgcuucuugaauuucucucuguaaaggag\n", + "cuuugagagagaaaagaaccacagugguugcacaacugaaacagcuucaggcagaaacagaaccaauugugaag\n", + "cacagacucccuuuucuuuggcaagauggcggaguacgacuugacuacucgcaucgcgcacuuuuuggaucggcaucuagucuuuccgcuucuugaauuucucucuguaaaggag\n", + "ggacggagcuaggupcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucpugag\n", + "uuuucuuuggcaagauggcggaguacgacuugacuacucgcaucgcgcacuuuuuggaucggcaucuagucuuuccgcuucuugaauuucucucuguaaaggag\n", + "ggagcgagcuggacgguggacggagcuaggupcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucp\n", + "pcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucp\n", + "ggacgguggacggagcuaggupcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucp\n", + "auauauaaugaaaaggaauuauuacaagguaaauuggaccuucuuagugauaccaacaugguagacuuugcuauggauguauacaaaaaccuuuauucugaugauauuccucaug\n", + "ugcucuucugcauuuuuaauuagcuuugagagagaaaagaaccacagugguugcacaacugaaacagcuucaggcagaaacagaaccaauugugaag\n", + "gagcgagcupcggagcgagcuggacgguggacggagcuaggupcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucpugag\n", + "gagcacagacucccuuuucuuuggcaagauggcggaguacgacuugacuacucgcaucgcgcacuuuuuggaucggcaucuagucuuuccgcuucuugaauuucucucuguaaaggag\n", + "cuuuucuuuggcaagauggcggaguacgacuugacuacucgcaucgcgcacuuuuuggaucggcaucuagucuuuccgcuucuugaauuucucucuguaaaggag\n", + "aggaucugucuguucguuugucggcgcuaccaauaaaguuuuagugagcacagacucccuuuucuuuggcaag\n", + "ggcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucp\n", + "guuuucacuguguugcccaggcuggucucaaacuccuggacucaagaaauccgccugccucagcuucccaaagugcupauuauagaugugaaccacugcacccggcccaauag\n", + "aguuuuaccacagcacaugcgcaguacaggaucugucuguucguuugucggcgcuaccaauaaaguuuuagugagcacagacucccuuuucuuuggcaag\n", + "upcggagcgagcuggacgguggacggagcuaggupcggugcguggcgcucccgcaaucucaggauacccuggcugcuggcpcuacggugcuggcucp\n", + "cgacgucaagucgaggccgccgccgcpccugguuaucgccgguucagcgcagcccggagucgcccaggccugaacuccuacccag\n", + "ccuagacucaagucupuuucagcugccgccagcccuauugcugcuguugcuguucucuguccuuggcccapcug\n", + "agacpuuucaccguguuagccaggauggucucgaucuccugaccucgugauccuccugccucggccucccaaggugcupauuacag\n", + "gcagucacagapaacacagagccuaguuguaaacggacagagacgagapcaapaggacaguggaugacapaagacgagupcagagcugcucaggacc\n", + "cuaguuguaaacggacagagacgagapcaapaggacaguggaugacapaagacgagupcagagcugcucaggacc\n", + "gacgagapcaapaggacaguggaugacapaagacgagupcagagcugcucaggacc\n", + "gacucgaaguggacuuccpucacggcggagcuggcucucacguggaggcpaaauuucgcccaccg\n", + "uccgaguuguguccgaggcuuccacgcgcapcccpaaapucagaggcuuccuaacgcagacucgagugcgaagcgcgcagucgccgg\n", + "guccgaggcuuccacgcgcapcccpaaapucagaggcuuccuaacgcagacucgagugcgaagcgcgcagucgccpupucucuccccagcgacgauuupug\n", + "accgcgcaggcugagccccaggcaggaagcagcccacuuggupuupuaugaguccuuccucgcpcucggupuccugaguauucuuuggccggauuugcugauccgucugcuccag\n", + "gagaapuguguuuguuuccccaucugccaugauuauaaguuuucugaggcauccccagccaugcugaacu\n", + "gcacupaguguggcapcaauupacucccuuguuccccuggaguuuaaccuagugguaaacacuuucagacgacgaaucaugcuauuupauuuuguacapuga\n", + "ggaaguggcacuaagguccaaaggaagcuacauaupuggucccugcuacaccagccucccaagccucccagugcaccuucuaggagacaagcaag\n", + "augcucgugguccccagcauccuugagccaccaggagugapcugcugcucccugagaccuggcuccaaggaggaugccacagccgccugccagcuccggucugcacc\n", + "gcaccucacggcagcccuacacucggccuggaagaauuguuuuucuucucuggaaaggugaacauuuauagcauuuauuucccaaaucuguuaac\n", + "cacagcugcccagccugcggagacpacagcccugucccacucacucuuuccccugcugcuccugccggcagcucagcuggaacc\n", + "acagcugcccagccugcggagacpacagcccugucccacucacucuuuccccugcugcuccugccggcagcucagcuggaacc\n", + "agaggugcaacggaagccagaacauuccuccuggaaauucaaccuguuucgcaguuucucgaggaaucagcauucagucaauccpccpagcagucaucugug\n", + "gucuuuccacuaaagucggaguaucuucuuccaaaauuucacgucuugguggccguuccaaggagcgcgag\n", + "guugcuguuuugacaacauggcggcgcccaugguccguggcccggcagugcucgccuaaagguggagaacgaggaguagaggagccgcaggccagagccugugagcag\n", + "auccagaccuacagauaaaaaacauuauuuaaucuaucupauuuacuccggcuuaugauuugag\n", + "gcuaucgauaaaguugcuguuuugacaacauggcggcgcccaugguccguggcccggcagugcucgccuaaagguggagaacgaggaguagaggagccgcaggccagagccugugagcag\n", + "gcuguuuugacaacauggcggcgcccaugguccguggcccggcagugcucgccuaaagguggagaacgaggaguagaggagccgcaggccagagccugugagcag\n", + "uccguggcccggcagugcucgccuaaagguggagaacgaggaguagaggagccgcaggccagagccugugagcag\n", + "gucguuuucacguuapcucggagguccucagaaagaugagguuccagacgagaaauccgccugaggucacag\n", + "aucgauaaaguugcuguuuugacaacauggcggcgcccaugguccguggcccggcagugcucgccuaaagguggagaacgaggaguagaggagccgcaggccagagccugugagcag\n", + "ggacgcauagagcugcggcucpcggcgccucccugcggcggcccggcccggcuccggcccccgcupcaaugcuccccpccgcpaugagccag\n", + "gcuaucgcuuccugccuucaucuupaacaggccgugcugugcgccagcccpagcccaccgucupappcgauuaaaaggucccaaccuccuccccaggagaccaaagag\n", + "gccgcggcgcpacgcauagagcugcggcucpcggcgccucccugcggcggcccggcccggcuccggcccccgcupcaaugcuccccpccgcpaugagccag\n", + "uguacucugccucuaaccugcuugugcugcucaaugacpauccuacggaaggagcuucggaaaaaguugccugug\n", + "gcaggaagcapcgccgcagccugucguacgguccuucugupucugucggugccgapcagg\n", + "pccuuucggcuuupcgcgagugguuaaaagacaguuggugucgguucggcuucucpucggauuccgcggucccaacccuucccc\n", + "cuuucggcuuupcgcgagugguuaaaagacaguuggugucgguucggcuucucpucggauuccgcggucccaacccuucccc\n", + "guuucaguguugcagaacagacgaggaagcucacugagaauuauccugagcuguguuaacaaacugacagaacacagaauuuuuacucaaa\n", + "accgcgcgugccccgccucucucccaagagcuacgcggcggcggcggagcgcaggccucgugccguuacggccaucacggcggccgcaguggcguccuggagcccuccucag\n", + "aagagcuacgcggcggcggcggagcgcaggccucgugccguuacggccaucacggcggccgcaguggcguccuggagcccuccucag\n", + "agauapucucacuguguuguucagacugguuuugaauuccuggccucaaacgauccucccaccuuggcuucucaacgugcupauuauap\n", + "cucgugccguuacggccaucacggcggccgcaguggcguccuggagcccuccucaggugagcuggagcugcccggcucggcagcpaag\n", + "gcggcggcggcggagcgcaggccucgugccguuacggccaucacggcggccgcaguggcguccuggagcccuccucaggugagcuggagcugcccggcucggcagcpaag\n", + "pagaagaagauucuuugacuacauguggucaacguagauaccuucaccaccaguucuaccuccapcaguggaggugaaacacauaucaauggucagcacugaguucucugaguggaaggaag\n", + "gagcuuugguucggagacaggcaaaggagccauguguggagagccugguuucucaguacuuccagaccgugacugacuauggcaaggaccug\n", + "gccgcccuccccacuguuaccaacaugaagcugcucgcagcaacugugcuacuccucaccaucugcagccuugaag\n", + "ccacuucpupcpauccpcaguagcggugcagccucgucguccggagcgcggugagucpucuccugcpcucagccuccccucggaacagcccccacuuccuccaaccccg\n", + "aguagcggugcagccucgucguccggagcgcggugagucpucuccugcpcucagccuccccucggaacagcccccacuuccuccaaccccg\n", + "gccauuuugugugaggaacguugacgcuaccuaccucuggccuggccucuacccacugcugcccuggccgcuaccaac\n", + "accgccggaaguuucugccgcggcuuugcpacpagugguagupcugcagcugccggacccag\n", + "ccggaaguuucugccgcggcuuugcpacpagugguagupcugcagcugccggacccag\n", + "gucuggauuggccccgcccccugaccugagccugguccuucuucaggcacugacccuugaccuccgguggcucccccaucucucaggcgcg\n", + "cgccgcggagagcggapcgccpcugcggaacgcgaagcggapcgcpacccugcacgccgcccgcpcccaugugagcgcc\n", + "aguccggcpcgccgcggagagcggapcgccpcugcggaacgcgaagcggapcgcpacccugcacgccgcccgcpcccaugugagcgcc\n", + "uuccugaccaccacggcuuuaagaauauccuucaaccpapagauccauugcuuuaagacuugccug\n", + "ggaacpacgcccccucuugcaaucugucagugccugcaccaacuuuauccuuucupcauuuucucaccagacugacaguccuuaagacaaguaugcaguuaagcugcuaag\n", + "aguccggaguccauuugcauaauuggauuuuuuuuuuuugccuccuucuuucucccugaaacuuguuugaaaacccaagugaaaaccgcgacgaucugcacacucaaaagcaagugccaa\n", + "gaapaauugcacauuaaucucaccupagauucagcaagccguaauucuccaaagcccacugaagcccaauuacagccaaaucccugaggaupcccaggugaugucaaggugagccugag\n", + "gugcuagugccccuccccucccgcucugugccccgccpcpaccgupagccgcggacaagcccaaggccggagcgguuccaggaggacccug\n", + "gucugcaccugugguugccagguagguggaugugagagacccuacccuucugguucucuagaagccaucccaucgccgcuagcauc\n", + "gcuagugccccuccccucccgcucugugccccgccpcpaccgupagccgcggacaagcccaaggccggagcgguuccaggaggacccug\n", + "gucuucugauagccgucagcgucuccguugauaaaaucaucucgcauuucpccgcccggaacuuggugcagaag\n", + "gcuccagcacccgcucccuuggaacccuguauagccaggucagccgucuagccccgcugagcagcagccguagccgcuuccaugccuuuauccupccuccucaa\n", + "gcccuagcapcaggcpaggugagcgcggccaucccgcucccggaguuccpauccuggag\n", + "cpaugaagapcacccuccgccaagaggcugcugcpacccpuuuccccuuuccggcgccuuccagccucccaauccucgg\n", + "cgcccuacaggcccuagcapcaggcpaggugagcgcggccaucccgcucccggaguuccpauccuggag\n", + "ggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "auuucuacuauuuagcaggaacuguguguaugccuaauucucuuuauuuuauguagacuupuaaaaaucguauuuggaguugccaccucugcugugcuugccuuauuggug\n", + "guccuggcuucagcuuccaacuacaaagacagacuugguccuuuucaacgguuuucacagauccagugacccacgcucugaagacagaauuagcuaacuuucaaaaacaucuggaaaa\n", + "aguuggugagcuuuuccggugcucugcacagaugcupcgcugagcaaacagcccucaguuucuggagcuguuccgag\n", + "guuuucacucccccacucuccuuugcagucccguggagucuccaucugagcccuuuccuaguccaggcaucccg\n", + "uaaaugucuaacaaacacucauacacccaaacacccgcucuuuuccuccauacuuucaaucaugcgugccuucccgcagcagacguuupuccuuccucugagccuggcacuaugaagaccccaag\n", + "uuuuccggugcucugcacagaugcupcgcugagcaaacagcccucaguuucuggagcuguuccgag\n", + "uuuccggugcucugcacagaugcupcgcugagcaaacagcccucaguuucuggagcuguuccgag\n", + "cccuacugguccuucugccuuagccacagguucugaaaccaaagcaaaaccaccagagagugauucau\n", + "guuggugagcuuuuccggugcucugcacagaugcupcgcugagcaaacagcccucaguuucuggagcuguuccgag\n", + "cccuacugguccuucugccuuagccacagguucugaaaccaaagcaaaaccaccagagagugauucaugugg\n", + "cucuuccucggcgguucuggcucccggccgcgccgcagcccugcccagucucucucccccagcccggapcuccuccgcgccgcacgugagcgcgcccgccaacapccacugccgcg\n", + "agaacugcgucucgcgacccaggcgcpuuuccggaggacagccaacaagcgaugcugccgccgccguuuccugauugguugupuggcuaccucuucguucugauuggccgcuagugagcaag\n", + "uuuuaupaaaguaauggcacagcuccagcucagcaccaaagugaagagcucuacugaggcacaauggaaagucgag\n", + "ucacacugaagcaacuaugagaauucccauuugacagaupaccaucgaggcugapaagcugugcagccaguccaaggucacacaaccaacacaagguagaagcagg\n", + "acucacgcucagcccuggacggacaggcaguccaacggaacagaaacaucccucagcccacaggcacg\n", + "cacucacgcucagcccuggacggacaggcaguccaacggaacagaaacaucccucagcccacaggcacg\n", + "gaacccccacaggaaaagaauccauugugcaaguccacauugaaguuuuggaugagaaugacaaugccccggaguuugccaagcccuaccagcccaaagugugugagaacgcuguccauggccag\n", + "cugguccugcagaucuccgcaauagacaaggacauaacaccacgaaacgugaaguucaaauucaucuugaauacugagaacaacuuuacccucacggauaaucacg\n", + "auaacacggccaacaucacagucaaguaupcaguuugaccpagcauaccaagguccacuuccuacccguggucaucucagacaaup\n", + "auuauaucuagcugcucuuaugugaaauaccugugucuaaguacuccuuucaucgucacuggccagagucugaaugugucuccucuuuccccagaucuguuccuccupaag\n", + "cgcpccpcagugaguccacccgcccgccgagguccgcccgcccgccgagacccgcccgccgccgcugcc\n", + "guccuuagacagcucuucucaugccpcaguuugcugcaucuggaggagcucacuggagaaucuccaacaucggagcpccuucaacuacc\n", + "aucccaccaccugcugaggagaaaaauucuucaagacucagagcacacagccagcaccagaggcccc\n", + "gaauccuuucuggcacucaagaguuuucaauucaauccugaugaaugaaucauuauuugauaccagccuaagugaagacucugccuggugacuuuugcaag\n", + "gugguuucuggcugcaacaupaagauuupaucagugagauggaagagauuuuucuggcuacuagcguuccuaagaaag\n", + "agccucucucugucacccaggcuggaaugcacuggugccaucuccacucacugcagcuucaaccuccupuucaagugauccuccugccucucagccuuccgaguagcupacuacag\n", + "caguuugcugcaucuggaggagcucacuggagaaucuccaacaucggagcpccuucaacuacc\n", + "augccpcaguuugcugcaucuggaggagcucacuggagaaucuccaacaucggagcpccuucaacuacc\n", + "cucugccuauugaccguccgaacaccuuggauaagugguuucugauuuugagaggacagcagap\n", + "cuguaucacacaagacauuuggcauuagccuggaagagguccuggugaacgaguuuacccgccgcaagcaucuugaacugacagccacg\n", + "gcaaagguuaacugcgagcugccpcacucagcgcpucauggcguggauacuggacugccuuuucgccucggccuuugagccccgcccccgccgug\n", + "auucuuucucucguggcuccccagcuguaucacacaagacauuuggcauuagccuggaagagguccuggugaacgaguuuacccgccgcaagcaucuugaacugacagccacg\n", + "gugcugaapaaacagaugaagaacaugaccucaaggagcuuccugucaaugagaagaccaagcugacgccuggcaaag\n", + "agacgguupcggacggacggcccgacaggcpcaugcpcggccagacuguagccgagcagcgaggcuccggccgcagcc\n", + "gcuuuguuauuugguucucuacugcacagaaauagauagaauucugacagccaucauuguuaaacaucaggauuuucuaagaggacagacuuaacaguaacauc\n", + "uccuacggccuccgaggcupuagugagugugucgcuggccuuagccagacuccacaggccacgcuggcugcgaauggagccgaggacucgcgcggaggcgag\n", + "guggcacucaguccuacggccuccgaggcupuagugagugugucgcuggccuuagccagacuccacaggccacgcuggcugcgaauggagccgaggacucgcgcggaggcgag\n", + "gucaaaapcaggaauuggagagacgucuacaaagcuuccaacaccauggcccupugaccuccucgguacccugccugccccuccccaacauccuacucauggccagugucaa\n", + "aguguuuguguuggaagcucagcugaugcaggccgguuggaguggacgucauugccpaacgagcgagucgccgcugcagcccuagugacugcggccugcaucccg\n", + "guaagaccaugaauuauggcauuucuuaaaugaagcguucaagaagugagagaaugucauagaaaauaaaugauuuuuaaguu\n", + "aguguuauacagcuggaaucauacugcuaugguccgaauguuugugccucucaaaauucauguggaaaucauaaccgcuaaagugaugguauuaagag\n", + "ggaagcucagcugaugcaggccgguuggaguggacgucauugccpaacgagcgagucgccgcugcagcccua\n", + "aaggaugaaagccugaacuagagcaguggaaaugcgaauguggagcagaggaacgauucaagaaauucugcgguaaaacucaucagacuucaugacugauuaaag\n", + "uuuugccuuucuagaguguuauacagcuggaaucauacugcuaugguccgaauguuugugccucucaaaauucauguggaaaucauaaccgcuaaagugaugguauuaagag\n", + "ccgcccccagcugcucaacuuauccgccgccgcucgugcccgcuuccagccugcguagacccggccguggucguccggaaggaaccgcguaggaaacggag\n", + "auugcupucuccacuccuagcuguuacugcaaguccaugccucuaccaugapuggaggaguuaagaucaacagauccacauguaccuugaggugacagacuggcucug\n", + "aguuucgcucuuguugcccaggcugaagugcaauggcgugaucuuggcucaccgcaaccuccgccucccpuucaagcgauucuccugccucagccucccaaguagcupauuacag\n", + "apcaacggccuugccccugccccucugccggcuccauugugucuggucpacupucupuuccgg\n", + "uagcuguuacugcaaguccaugccucuaccaugapuggaggaguuaagaucaacagauccacauguaccuugaggugacagacuggcucug\n", + "guauuucauuucuccuguccccuccccuccccaccccaucuauuaauauuauucuuuugaagauucuucguugucaagccgccaaa\n", + "gccuugcugagccauggagagaacucuggagauggcgcucaagaccccugcacuguguaccuccuuucucaccucuggccaggagcagcapaccauagaaacuuaaggaggagg\n", + "pcuuucucuuuggaagguggccugaaaauugaauuggagugucuuuguuucuccucuuguccapaacauagauggcuggagacagaaucuagagccuucaaauaauguggag\n", + "apcagaggcpccpagcgaggcguapuguggccaaagcgcaguapcucucgcgguug\n", + "puacapccaggugaapacagaugaagagaucagaacagccuuagagcucacpcuaacupugaagccucgg\n", + "ggauaguggaugaauucuucccgcuguugucaaacuaauguauauggacucaaccacapauauccccagagcuccuauggaacacuagcaaauuuugu\n", + "guuuuuguucaguccgacaupcuggcccucaucuugcagcucuguaauuuuucaauuuacacccaacaa\n", + "uuaccucccagaauuagacaauugcaaagagcuuagaauauuuauuugaaaggaaugaggauccugcacucuuccucccucag\n", + "uaaguaaaugccagucccuaggaagagagaaccaaaaugucuaccggaccagaugucaaggcuacagupacauuuccagugauggcaauuuaaacguggcucaagaggaaugcuccaggaaag\n", + "gcuggagugcaauggcgagaucucggcucacugcaaucuccgccucccgguuucaagcgauuuuccugccucagccuccugaguagcupauuagag\n", + "acucgccaccuccucuuccaccccugccaggcccagcagccaccacagcgccugcuuccucggcccugaaauc\n", + "agguacccgauccgaggcpagagcacccpauggaaggagcaggcgugcpccgugagcggcgccagapuaccugg\n", + "gcuggagcgcaguggccccaucuuggcucacugccaccuccaccucccagguucaagccgguucuccugcuucagccucuugaguagcupauuacag\n", + "gcuuauugccuguacucagaaaacaugacuguugaagcccuuuguucauucauuugaaapauacuuucucaaauu\n", + "cgacgcugcuucguugccuggacucugguuuccgcccuggagcaagccpccuggucggcagcupccgcc\n", + "pcucagapupcuuuggagaucagapucgacgcugcuucguugccuggacucugguuuccgcccuggagcaagccpccuggucggcagcupccgcc\n", + "ggagaucagapucgacgcugcuucguugccuggacucugguuuccgcccuggagcaagccpccuggucggcagcupccgcc\n", + "ccugacccggaaccgcacuggugccgccgcuagccggcugcccacgugccugcaacaguggccacgupcccugaggaaacgccuuuacaaag\n", + "guuucuuuuuggagacaggcccuuuuggupuccaugagucugguuacuacagccaggcuccagcccagguucaccaguuccccucuucuugugagacugguccag\n", + "gacgcugcuucguugccuggacucugguuuccgcccuggagcaagccpccuggucggcagcupccgcc\n", + "cupcucagapupcuuuggagaucagapucgacgcugcuucguugccuggacucugguuuccgcccuggagcaagccpccuggucggcagcupccgcc\n", + "cpcpccupcucagapupcuuuggagaucagapucgacgcugcuucguugccuggacucugguuuccgcccuggagcaagccpccuggucggcagcupccgcc\n", + "uuucaguucuugccggagaguuuccagauuucuccuccugauggccuguucuguggauuuuggauuugccaaggcagcccucacaauccg\n", + "aguccupcugucuaaggaacuauggugagauagaguguuaupuugaauuuugucccccucaaaaag\n", + "gcccacagcaggugugguguucaucccpucgaccggccgcucgcgcugcccugaaacucuagucgccag\n", + "guaauaagagcpucuccgcpaaggcgcccacagcaggugugguguucaucccpucgaccggccgcucgcgcugcccugaaacucuagucgccag\n", + "pcucugccucuccaggagcccagcgcaggccgcagagccpccgcugugagccgagaccgcpccgcggagcucpcggccggcgcggag\n", + "agugcagcggcggcggcggcpcucugccucuccaggagcccagcgcaggccgcagagccpccgcugugagccgagaccgcpccgcggagcucpcggccggcgcggag\n", + "cucgcucacaaaaaauugagccggcccuggaggccuppcgaguccgguugcgccucggagagcgcaacaggcag\n", + "agccggagccggagguggugguggucuccuggcagagcggupaccpagcaagcugcggugguucaccaccuug\n", + "ggcggagaaugagccggagccggagguggugguggucuccuggcagagcggupaccpagcaagcugcggugguucaccaccuug\n", + "gcagaguaupaagauaugcaaacgcugaggccccaaauagugcaguggccuuugupcagcacuuacaggupcuuggaaacacuugccuuuggaacauuguuuaaaa\n", + "gugaugagugagguucgaagaacggaagauuuaaaaagcagccpccuccguauugaaugaaagacccagugcaaagacaucacc\n", + "pcggcggauguuugcgcagcuuccuugagaugccaccgcccgcugcgccgcgcagaaacpagcgcagcgcacccgcggccugcgucacucg\n", + "ggcgccgcgcggucucccpagcugcggagagguagcugcuccpuuuugccuggagccggaupccaggacgcaggcgaggacg\n", + "accuuuccccuccauuccgcaccuccgagugcuggccpcgagaggcuggcggcupcucucgcgccccucccugcapcucaggcucucccccuccugucuucuccgcgcuguuccucguc\n", + "auuccgcaccuccgagugcuggccpcgagaggcuggcggcupcucucgcgccccucccugcapcucaggcucucccccuccugucuucuccgcgcuguuccucguc\n", + "cagcucucgaucagcucucgcagucggagaggcggcuaaggaaaggugccacagcagagacgcgaaggagaggcccuagaacc\n", + "aapcacacaucuuaggacccggaggacguccggccucugugagccgcaaccuuuccaapagugguugugugaucgccaucuuapa\n", + "uucaccuguggcagaugauaucauccagcccgcugcccccgcagaccuggaaagcccaaccuuagcugccucuuccuaccacggugauguuguuggccaggucucuacggaucugauagcccagag\n", + "uagagacupuuucaccaugaugaccaggcuggucucaaacuccugaccucaagugaucugccugccucggccucccaaagugcupauuacag\n", + "cgccccggcucccggcugcaggaaucgcgccaggacgcuggccccgcucgcggcuagcuugcacgccapcacagcgagg\n", + "acapccggagugagaaccpccpuapuagcpugagagccpccpuagcgg\n", + "auuguccgucccuccpcuuuguagaaucgucgccggcuuaccuggccgupcgcguccuggccgcugcagcccggagcapugccagccgccgccgccgccgcc\n", + "aagugaaugagccgugccaaaaagacgguuggauccugcauaguggugagapugauccauucugccucaucauuuaagcugucuggag\n", + "uacaaguucapaccuaacuguggaagaacuaaggaauguaaauguauuuuucccacauuucaaauauucc\n", + "aguuugguccucagcggcuuccguccugcagcaaguccggaagaagguccpcuggaguccupaccuagcucpaccggccuggag\n", + "agcggcuuccguccugcagcaaguccggaagaagguccpcuggaguccupaccuagcucpaccggccuggag\n", + "guggagcuggagaccuggucucucuapccuacccugagcucaccaucugaaggagagugccaucauccuuaggaacuccuucuccagac\n", + "acgcggaagucagguaggagcacccgccgcuggcagccacucuccuggccgccaaaccccagcuggaacuccggccacagccagc\n", + "gacucuccaguccucagucaccuuggacaaagaaguguggauccucagauuccaucuuuuccaacuccaag\n", + "gapcucccugccugagagccugcggcpuccaggagcugacaggccgcucuguggaguuugaggag\n", + "acggcucagucccuacauauuuaugccgcguuuccagccgcupugaggagcuacuuagcgccgcggcuccuccgapcggccpcagcgagcagcggccgagcggacp\n", + "gcacuccgaguccgcccgaggagccpccccggccgcuguccagccgcuccgugccccgcgcguccugcgccgccgccaccgccuccupagacgcagccacuugcccgcc\n", + "caaagcgguuggcagcagcggcgcuuggaggaaaggaagccgguuggapcgcagcgcaccccugcugcgcggaggapcugagcugaacucagcagaaguuacaugcacaag\n", + "gcaaaaauucugacguucucaagagaccagcucugcccccguggcucaacugacccuaccauguggacgcugcuccuccaggupaacuggaguuuugaaauaaa\n", + "guguapcpcugaggagccggcgugcggcgcggcpacpacgugcggcccagcgaguuggucggucccpucacccgcuacpaagcaggccucgccacag\n", + "gaggaagaggcuauucagauuauugcagacccuccauugccaccagcuucauucacacuucgagacuauguggaucauucugagacucugcagaaguugguucuucuag\n", + "gcguggauuuguccaagauagaaaaacauccagaagcagcaaaccuccuucugagacuggauuuugaaaaagacauuaagcaa\n", + "ggcgugcggcgcggcpacpacgugcggcccagcgaguuggucggucccpucacccgcuacpaagcaggccucgccacag\n", + "capuauugugaauacuuacuucuuuucuaaaaucaucgcagaaupccgagcgcaguggcucacgccuguaaucccagcacuuupaagcupuggaucaccugag\n", + "gcuguuccagupucguggcgguggcggcagcggcgguuapauguaacggucgcccgccuccggcgugacg\n", + "ccaguauugcaggaaggagguggaggccpccuggagaccagcapcgacuccuaccucapuguccuccgacagcccaaaggaccagagcccgccugagg\n", + "acucpagucagaggccgaccuggagugcagcuucgcagccauccacuccccagcuccgccuccugacccugccccucgguuugccacgucgcugccccauuucccag\n", + "agcucuuccccgcagcucupagacguggaggccucugaagcugaagaccacuucuucaacccacgccugaguaucuccacgcaguuccucucaagccuccagaaggcauccag\n", + "uuucccgcggcuguucgcuguuccagupucguggcgguggcggcagcggcgguuapauguaacggucgcccgccuccggcgugacg\n", + "acpacpcaggagcuggagcuccgugccgccuguacucccgccuucauuucccaucgugcugaggcpuggcauggcggagaagg\n", + "ucuggacccacpacpcaggagcuggagcuccgugccgccuguacucccgccuucauuucccaucgugcugaggcpuggcauggcggagaagg\n", + "agauagucacaacuuagccuccuccuuuuccauccgcgauuuuuuupucaguauccagagugcuucaggucacuguucaccgucaaggcguggcccucggaaugaaggcagcag\n", + "pacpcaggagcuggagcuccgugccgccuguacucccgccuucauuucccaucgugcugaggcpuggcauggcggagaagg\n", + "guaguuuucuggacccacpacpcaggagcuggagcuccgugccgccuguacucccgccuucauuucccaucgugcugaggcpuggcauggcggagaagg\n", + "auccgcgauuuuuuupucaguauccagagugcuucaggucacuguucaccgucaaggcguggcccucggaaugaaggcagcag\n", + "cacpacpcaggagcuggagcuccgugccgccuguacucccgccuucauuucccaucgugcugaggcpuggcauggcggagaagg\n", + "gapcggaggcaggccgcupccugaccuggccpcuggccugccccauugaucguguacuuugcccugcagguaaucgcgaggagcugguggagcggcugcagagcuacacccgccag\n", + "acuggcaucgugcugaaucggccgguuuugagapaagaupacaaagccgcuccaccuccc\n", + "ccucaggcaaaccacuagaggcagcucagauagaggagcucuuupaagagacgccpcaggcagaagcagcagguacccccuccacaucccuapcucugugauguaggcagag\n", + "aguuuuuccaacccaguuupagapcuggaupaaggacccucccugcugcagacuucauggcaggcugcacuguguccccucggcuccacggcugccccpcgcugcuuucg\n", + "cuuucacaaaaggugaaaugagcucuuuguaguguuucccgcccaggcugcauuuuagaaucacagaggag\n", + "aaggcucaggugaaccaguuucaucugaccugcuugcuaacucaaacauggcugcccaacugcgupcuggcaag\n", + "cuacucccpaucagcccaucuuccugcggcuugaggauuauuucupucaagacgccaucugcuuacgagcugcccuaupaccaapagug\n", + "ccucaggugccgccgcuguguggucgupaacpcaccggcugcggaacagcucacupagaugccaucaacaaguacgauguggucaucag\n", + "gcccpacapacccggccgagucgagccgucgcgccagcgcugcgccgccggucggugcgccuagcggaucggagcugcgcgcggaaccgugcugccccgccccgcuccacccgugagg\n", + "pcucccccacccuggaggacaggccucagaagccgucuucagcaggauccupaccucupcuguggapacagacapagccapcccuucucuucaucuugaaggacagugg\n", + "accaucgagaacaucaaggupcugcaugagaaggagcucuggaagaaguuccacgaggcpcaccgag\n", + "aggucacagagauuagaagaagccaacaaaagacugagauggugaagccuuugagacagaagagaaaccaggagaaugugguguuccauagaccaugugaagcag\n", + "acauugaaauucaaagucaugcuuguaacuguuaaugaaagcagauuuaaagcaacaccaccaucacuggaguauuuuuaguuauauacgauugagacuaccaagcauguugcucuuauuca\n", + "aguacauugaaauucaaagucaugcuuguaacuguuaaugaaagcagauuuaaagcaacaccaccaucacuggaguauuuuuaguuauauacgauugagacuaccaagc\n", + "gccccgccccggcucpcggccggaggacccggagcuaaggcgcccgaacccgcggcggcggupacg\n", + "cccgccccggcucpcggccggaggacccggagcuaaggcgcccgaacccgcggcggcggupacg\n", + "cucuccgccccgccccggcucpcggccggaggacccggagcuaaggcgcccgaacccgcggcggcggupacg\n", + "acagaaaaaugccuccacgucgugacagaggcugugaccccguupaauauaccucaaggcgagaguggaggcugguggccugaaggagcuggagaucuccupcuacaccagaucgug\n", + "agaaccccaguguagcgagcuggagagaggacuguccugapcagcaggccugguugcagcuggcgupucucaga\n", + "caaccaccccaugugucucuagaaccccaguguagcgagcuggagagaggacuguccugapcagcaggccugguugcagcuggcgupucucaga\n", + "ugcaccpcacgcggcgcacgcucpcgagauguggauggccccgcpccapcggcggugcugcgcpacgcpugacgccpcgcpcggcuccgagcag\n", + "aggcaggaagugucggcgccgccacuguccggccacagccuaacgcucuucgcugucguuuguggucucgcgcapcggccccgguucugguguuuggcgucgg\n", + "gcggcggcggcggcgcccpagccggagccuucgcggcguccacgucccucccccgcugcaccccgccccggcgcgagaggagagcgcgagagccccagccgcpcpcpcggcgaag\n", + "gauccgagccgagcpccguaucuccuugucggcgccgcugauucccggcucugcggaggccucuaggcagccgcgcagcuuccguguuugcugcgcccgcacugcg\n", + "cpagcgcccpcugauccgagccgagcpccguaucuccuugucggcgccgcugauucccggcucugcggaggccucuaggcagccgcgcagcuuccguguuugcugcgcccgcacugcg\n", + "auuuacaacccugaagaaucucccuaucccuauuuugucccccugcaguaauaaaucccauuauggagaucucgaaacuuuauaaapauauaguuugaauucu\n", + "cacaguaagagauuauagcaaagcaucuauaaucaacucagcuuaagaaguuuugaccuucugguuaggcuucuugccacaacagaacagcaccauaacc\n", + "aguguccgcggacccggccggcccaggcccgcgcccgccgcggcccugagaggccccggcaggucccggcccggcggcggcagcc\n", + "gagucaguguccgcggacccggccggcccaggcccgcgcccgccgcggcccugagaggccccggcaggucccggcccggcggcggcagcc\n", + "aaguuccaauuucuuuucaagucaauugaacugaaaucuccuuguugcuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "cuccuuguugcuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "uccaauuucuuuucaagucaauugaacugaaaucuccuuguugcuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "aaaucuccuuguugcuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "cuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "uguugcuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "ugaacugaaaucuccuuguugcuuugaaaucuuagaagagagcccacuaauucaaggacucuuacugupagcaacugcugguucuaucac\n", + "ggucugcgccggaagugcaugagcugccgauguggugcuuagugauugcgguuucggucgcucucccguguuucccpcupuauuugccucgcaccauggcg\n", + "ggaagugcaugagcugccgauguggugcuuagugauugcgguuucggucgcucucccguguuucccpcupuauuugccucgcacc\n", + "ucucuuucagauacccaaauccacccaugccaaaguccuccagucugcucuccguauccgugguupucaaaucuauag\n", + "aggcgcucgguggcgguagccgcgguuguuggccgaccgagugccggucauaagccccccccgguppcagcuggugugcggaucgcggcpagagaggcgcg\n", + "ggccgcuggaccccguugcuaaggacccuugagaucgugagcgcuuggaguguaccccuccuuuccupuagapucagucgagaguagccuucguuaaccuuaauugaaacug\n", + "ucucuuucagauacccaaauccacccaugccaaaguccuccagucugcucuccguauccgugguupucaaaucuauagauguggaacccgcauauacggagagccaacuguaauuugucguuaag\n", + "uuuguuacaggaacaacuuuuugacgugaaggaagauagaaauuuagccauaaaauuccauccaaaacuuccacugaauug\n", + "auuuccccaaacgcaggcgcucgguggcgguagccgcgguuguuggccgaccgagugccggucauaagccccccccgguppcagcuggugugcggaucgcggcpagagaggcgcg\n", + "aauuggcuccaggacucccucccuccccccagucucuuucagauacccaaauccacccaugccaaaguccuccagucugcucuccguauccgugguupucaaaucuauag\n", + "aaacuuguguuguucccccuccaggagcuucucaaaacagaagucaggcacaauauuaaauacuuguugaaugaucacagaaguacaaua\n", + "guggcgguagccgcgguuguuggccgaccgagugccggucauaagccccccccgguppcagcuggugugcggaucgcggcpagagaggcgcg\n", + "cggupcpccggcaggugcuccgcagccgucugugccacccagagccggcpccgcuagguccccggagacccugcu\n", + "aggugcuccgcagccgucugugccacccagagccggcpccgcuagguccccggagacccugcu\n", + "pccggcaggugcuccgcagccgucugugccacccagagccggcpccgcuagguccccggagacccugcu\n", + "aaugacaagguaauuaaggcgaaggaaacaaauguagcaggcacagcgupuggacagucagcugucgguggcuucugcugag\n", + "acauaaaugaaugcacagauuuuguagaugucccuuguagccacuucugcaacaauuucauuggugguuacuucugcuccugccccccggaauauuuccuccaugaugac\n", + "aucuupacauagaaguuccugaapuaupauucaccucuacuucacccaucuggacauugagcugucagagaacu\n", + "gcuccaaaguccggaggugcagaaagccaggaccaagagacaggcagcucaccapuggacaaaucgccagag\n", + "agaaaaauaaaaagaaugcagcaggccagguuagcaggaacguuaagacggugacggagaacagcaaagccuggaagcaagccgccguggagaaggaagaacugugcugag\n", + "uacuucacucuguugcccaggcuggagugcagcggcacaaucacagcucacugcaguuucaacuuccupuucaagugauccuccugccugagccucccaaguagcuaggacuauag\n", + "cpcugguagcgcgccgcucucggucgcgcggagugaucguguggaaucgcpucgcggacgcucgccgccggccauagcucagccuagcgccgccaaggccgacggcccucagccucugcc\n", + "gcugguagcgcgccgcucucggucgcgcggagugaucguguggaaucgcpucgcggacgcucgccgccggccauagcucagccuagcgccgccaaggccgacggcccucagccucugcc\n", + "gcgcggcugcagcggcggagccggagucggagccpagcgcuagcggcagccggaucgcagccugcpcccgccgcagcc\n", + "agucupcgcgcggcugcagcggcggagccggagucggagccpagcgcuagcggcagccggaucgcagccugcpcccgccgcagcc\n", + "agccggagucggagccpagcgcuagcggcagccggaucgcagccugcpcccgccgcagcc\n", + "cagcggcggagccggagucggagccpagcgcuagcggcagccggaucgcagccugcpcccgccgcagcc\n", + "gccuucccaagagccccugcggccpcgcgaaaauggcggcggcggcgacggccpcgcuccugaagcagcaguu\n", + "auucagccgccgcuguccccgcugcgcgcccucgcgccucugccugagaagccaggcgcuguucccccaccccagaagaggauggcaaagguggcuaaggaccucaacccaggaguuaaaaag\n", + "gaaaauaugcaagucuugcaaaugcagccaagaggaccacugccuaacaucugaccuagaagacgaucggaaaauuggccgcuugcug\n", + "gcacagagcucccucccaggcccgcgaacuuggccauucagccgccgcuguccccgcugcgcgcccucgcgccucugccugagaagccaggcgcuguucccccaccccagaagagg\n", + "cuucgccugccgcggucpuccgcggccugcgcuguagcggucgccgccguucccuggaaguagcaacuucccuaccccaccccaguccugguccccguccagccg\n", + "cupcggagccggcccgagcuucucccggagucccuccccagacggcccgagagcccucgcgucupcugcccccgagg\n", + "ggaaacgcuuugucuguccggcaagccgacggcccgcugcuggccuccgugacgcggccuccuccgcgccucgcggc\n", + "ggcaagccgacggcccgcugcuggccuccgugacgcggccuccuccgcgccucgcggcauggcgucggapccgcpagcccgaaagcgag\n", + "ccuauguuacaggacaaaggccgucgcuuuguaaaagcuugaagugcaguuugcugcugaguacagaagaccuuugcaaacagagapagauuuucucuguaagguugcaaacaag\n", + "agccuauguuacaggacaaaggccgucgcuuuguaaaagcuugaagugcaguuugcugcugaguacagaagaccuuugcaaacagagapagauuuucucuguaagguugcaaacaag\n", + "ucccuggcgucaaagguaggaacagcugagcccuuagauguaccccugacggcgagagcccaggagupcguuucacuuuuccugcguuupagucccugaggcuaugcccuuugaccuuugac\n", + "ggaggagauuggacaggcuggacuccccauugcuuuucuaaaaaucuuggaaacuuuguccuucauugaauuacgacacuguccaccuuuaauuuccucgaaaacgccuguaacucggcugaag\n", + "ggagauuggacaggcuggacuccccauugcuuuucuaaaaaucuuggaaacuuuguccuucauugaauuacgacacuguccaccuuuaauuuccucgaaaacgccuguaacucggcugaag\n", + "gcgcaguaupuccucgccucaaggagccagccccgcuucucagagcuacaguuaccacucuucpagaauacagcuccgauuucuuaacuccagaguuugucaaguuuagc\n", + "aaaaauguuuuacaapcagcaugaagcggacaaaaucuggagcaaagaaggauuuuaugcuguugucauuuuucucagcaucuuuguuauuauaguaacguguuug\n", + "ucacugccccuggucupcaapcaguuggugaacuugcugccuccagagaaccuucccugguguggaggcagccapacccagg\n", + "auuauuucaucauuupcuugcccuuucauguggagcacugugauuggacccaaguuggcaagaguggaagaccapacagaacagaaaucccc\n", + "ccugaguuuuucuggucugagccgagaguuugcucgagaacugccgagaguugcuggcucucpcccag\n", + "uuauuucaucauuupcuugcccuuucauguggagcacugugauuggacccaaguuggcaagaguggaagaccapacagaacagaaaucccc\n", + "aaacaggagcgaggugucucccuagcucgcugccucuggcaaguggaguuuuuaaaaagcuccagcagaucauguc\n", + "aggcpccaggacggcpaccggccgcupucccagcgapcugagccpcggupag\n", + "gcaggcgcpcgcpcaggcagagcpcgaaggcgcggagcucgcagugcagcccgcgcuucccagcguccgugcccggccgccugugccuaccgugcccguggcgcc\n", + "paccauagagacgaagagguggcggcggccggagcgcccccggccucugucggcuccguaggcucag\n", + "cucuucucccaccgccugucggcugacgugucugcaguuccuccgcgucuacugcgagucaggccgug\n", + "gaagcaucgagapaaccgcggccggcaggccggaccgcuccggagaggaggcagcggcaguuugagccccu\n", + "auaagcgccagcggccucgccgcccgucaagcuguccacaucccuggccucagcccgccacaucacccugaccugcuuacgcccag\n", + "uucccgcacgcguuacaggagccaggucgguauaagcgccagcggccucgccgcccgucaagcuguccacaucccuggccucagcccgccacaucacccugaccugcuuacgcccag\n", + "gauuguuacgcaccugacagcuagcggaaggaccuuucuguccugguucccugaagcaucgagapaaccgcggccggcaggccggaccgcuccggagaggaggcagcggcaguuugagccccu\n", + "augaugaaacuucccgcacgcguuacaggagccaggucgguauaagcgccagcggccucgccgcccgucaagcuguccacaucccuggccucagcccgccacaucacccugaccugcuuacgcccag\n", + "aauuuaacuuucaguuuuaaaggcugcauguggacaguaccauauuggacaggaaaccuaggcugcacacacuuacuaaauuauaauuugaggcagcuuacaaccag\n", + "acuuaguggcguggagcugaacugaagagauuaggauuugacgucugacguagucacucuguagcuccauaaucaapcuguccaagg\n", + "gaagaagagagcgaagaggaacccaagcugaaguaugaaaggcuuuccaaupuaacugaaauacuucagaaggaugcagcuagcugc\n", + "acauuugcuuuugcuaapcacacuuggcuuuuuagguugugccuuuccucuauucuacuuaagucaagcacuaagaaaucuacuguaaauucuggacuuuccaccauguuuucag\n", + "ccuuucucugcgcucucgcucgcgcuccccagcgcccuccugcucucccggccgcgguccccucguccgcgccgccccgccgccggcuccgcugccgccccuggcgacc\n", + "gcggccccggcaguggcggcagaggcupcpcpcccpagcggcgcagcaucugcpcggcp\n", + "guuucgagcucgccpccgugucgcgccaugcccgcuggcugagcgccgcapccucgucccgccaggcgupccgcgcgcgcccaggccpcccggcggccgacc\n", + "agcucupagaggagcccagcacupauuccgagguguuuccauucagugaucugcacugaacacagaggacucgcc\n", + "acuuaagcacccacaggaaaccaccacacauuuccuuaaauucagguuccagcucacaupaaauacuuucugagaguccuggaccuccugugcaagaac\n", + "agcucupagaggagcuccagccuupauucccagcugucuccacucggugaucggcacugaauacaggagacucacc\n", + "aucuccaccagcuccacccuccccupuucaaaagacgaggacapccucgcucagugaauccugcucuccacc\n", + "gaccgucaggugcgcacgcgcacuuacaggcuuguuuugccagcuucacgccacccpaupagaaagcaggugucgcgagaguupcgcaagacgccuuguapaguguaacu\n", + "auccpaccugcagguuacaagcagcagaucccaccuucaguccuggcucugacaagcccuccag\n", + "agaaupacauuuuagagacugaagagcauuauaagagccgauggagaucuauuaggauuuuauaucuuacu\n", + "paggcgcgugccgapaggaggcugaggacacagccuccuuucgcccugcgcugcccggccuuccgcgugaccccgccuaugaccucpcguuccgccuacgucugaccgucag\n", + "gaguguaacuauggccggccugcggaacgaaagugaacaggagccgcucuuaggcgacacaccuggaagcag\n", + "aaupacauuuuagagacugaagagcauuauaagagccgauggagaucuauuaggauuuuauaucuuacu\n", + "gcaggcgccguupugcgcauccpaccugcagguuacaagcagcagaucccaccuucaguccuggcucugacaagcccuccag\n", + "uuuugccagcuucacgccacccpaupagaaagcaggugucgcgagaguupcgcaagacgccuuguapaguguaacu\n", + "cuucacgccacccpaupagaaagcaggugucgcgagaguupcgcaagacgccuuguapaguguaacu\n", + "gcuuguuuugccagcuucacgccacccpaupagaaagcaggugucgcgagaguupcgcaagacgccuuguapaguguaacu\n", + "cccccguaggcgcaggcgccguupugcgcauccpaccugcagguuacaagcagcagaucccaccuucaguccuggcucugacaagcccuccag\n", + "pcgcaagacgccuuguapaguguaacuauggccggccugcggaacgaaagugaacaggagccgcucuuaggcgacacaccuggaagcag\n", + "gccuuguapaguguaacuauggccggccugcggaacgaaagugaacaggagccgcucuuaggcgacacaccuggaagcag\n", + "gaaauguagcaguuguuagaucauauacugcuggugcuacuucccuucaggaaagaacaaguucc\n", + "gagucgcaaucccagcagcaauagcccagaagaggacacgguucccguaccgaapuucaguaccagcagcccgaccaucacgcggcp\n", + "aaguuuguuggcaaggaauauaaugaaguaauucugaaauaugaaaaacuaguugcugcuuauaggcugcuguuacugguaauuuuaugaggaaaccaacugu\n", + "guuagagccuggcaaugccguuupugugugacucupcgacaagaagaacuauaaccagccaucggag\n", + "agucucgcucugccacccagccuggaguacaacgacacgauuuuggcucacugcaaccucugccucuccaguucaagcaauucuccugucucagcuuccugaguagcuggaacuacag\n", + "uaaagaupuuucaccagguuagccaggcuggucucaaacuucugaccucgugauccacccuccucggccucccaaagugcupauuacag\n", + "auupcupaccaaaguugaguccuggaaapagccuggagagcggcggugcupaggcccggccagcucgaucgcaggcuuccaccuggcggcca\n", + "augcuuguuugcuacugaupugugagcaaguuagauauucuauaccggagacuucuccuaacaaaacuuuuuaucagaggaupaaggccagaagaucucaaaag\n", + "acucuuugaauucagaaagaugauuggaaaucpaaagaugccagaaucugguuucaagcgauuauccaguacacauugauaag\n", + "guuccaauuuauugugccuaaagaauggaacagcaaauauagaccuguaugcauucaucuugcuggaacaggagaucau\n", + "guccccggaugcgcaccccaacggcgccugcgccuacpccucagccuugcaaaaugucacucagcagagccugcugcugaaacgupaguugaaaaag\n", + "uaucucccaaaauuguagagauuucuucagauaucuccauuaaugaapaacaauauuagccucaccugcauagcaacugguagaccagagccuacgguuacuuggagacacaucucucccaaag\n", + "guaagugacauuucauucugcucauccccaaggcaaaguuggauguuuuuaaaguggaaaaaaaa\n", + "aupaaacugacucgaugaagcucaggccuggccgcggucapuagaaucaggacuagaacccaggcuguguggcugcagcccugacccucaccauccaggucaggcagagaacacucag\n", + "gucuuggcccccauggugupcuuggucacagcugcuuccccagccccaggccugcacgaagaaggcacucacuaa\n", + "aagcuuaccaupugucuguacgcguguguguucgugcgcucagugguggaagacaggacagaaaauaaacggaucaacauccaaagcaacaaggucauuacagcuu\n", + "aaggcugupuugagcaaauacucagccuccagauggucacgagccccccaagugupaggagcapccuuuuauacgucupacccuaaaagugcccaag\n", + "cuccccgcpuuccguuggcuguggcggcagcugacgcuuguggcggcgguggcuucpupcguaag\n", + "ggccpccccgcccupccgccuccccgcpuuccguuggcuguggcggcagcugacgcuuguggcggcgguggcuucpupcguaag\n", + "ggcagaaccaapaapacgcugucaggcccaggccccuppccapccaggccacugccupcagcaggcaucagaaacuaaag\n", + "pcagaaccaapaapacgcugucaggcccaggccccuppccapccaggccacugccupcagcaggcaucagaaacuaaag\n", + "acugccccuccaccaggcuuccugcuggaggaguuuccuucccagccaggccggcccagaagccagauggucccpacaggcccagcccc\n", + "ccagcggcggcccaggcucupcacucgcgcggcucccguucgcggagcacacaucccggcgcgacgag\n", + "aaagacccgugugacugaagaggagcucacaguucccagcgucugcucccacgguguccagcgcccaga\n", + "agugaguguggaggcgcggacgcgcggcggagcuggaacugcugcagcugcugccgccgccggaggaaccuugauccccgugcuccggacaccccpccucgcc\n", + "ggacgcgcggcggagcuggaacugcugcagcugcugccgccgccggaggaaccuugauccccgugcuccggacaccccpccucgccaug\n", + "agugaguguggaggcgcggacgcgcggcggagcuggaacugcugcagcugcugccgccgccggaggaaccuugauccccgugcuccggacaccccpccucgccaug\n", + "aguucaaggaggccuucucccucuuugacaaggauggagauggcacuaucaccaccaaggaguupacagug\n", + "gcggcgapaaaguaguccggcgacpagcgagcgcgcgcgcgcccggcggcaaacccaauuccugugcapupacgagagauucgcpcccguag\n", + "aacugcugcagcugcugccgccgccggaggaaccuugauccccgugcuccggacaccccpccucgccaug\n", + "gaggccuucucccucuuugacaaggauggagauggcacuaucaccaccaaggaguupacagug\n", + "auaaaggcaucugcuguggugcugcagccaaggccaggcugugcucugugcuugugucpagcccuuggcaguggccaccccacag\n", + "aacgugcuggccaaagcgcucuaugacaauguggccgaguccccggaugagcucuccuuccgcaapugacauc\n", + "cagcccugcuccugupcacupcagapacaaggcggaccaccugagccugcuggapccgguaucccagg\n", + "augaaaaaaugapcuuccagacugugcugaugugagccccgccauccguucugguucagagcauaaucgucucgucuucagaaagaaggaagacagaac\n", + "aggagccggaaagcgccpaccccucgcpccucugagcggcgcpcggacccgagcccccagcccgcuggcgccgcugcccgccaggccccpcggcggccaagauguccgugccu\n", + "gugcauuuguuggagagcgguguccugcgcccuaggcuggaagccuggccucpcapccuggagccucpuuggag\n", + "uuugccugccaggagupugapaggagcagccgccgccuucacagacaccugguagugucaggagapc\n", + "guaauuaaauguguauuuuguggaccupcuuggcuggaaugcucapuccugaagauccuauuauagcuuccuucuguugaaccauuaagaaaag\n", + "cccgucgcuccccugcucpucagcuaguguccgcucugcucggccgcpcucccggaggacugcag\n", + "gucgcuccccugcucpucagcuaguguccgcucugcucggccgcpcucccggaggacugcag\n", + "cuuucuuuuucucuuggagcugagcuauaagacaacaggacugaacapagccaacuguuucuuugaacaguaaaucag\n", + "gagcaucgugcaucaagucaccapugguccauucaagcugcagauuuguuugucauccuuguacagcaaucuccuccuccacugccacuacapaagugcaucacaugucag\n", + "cauacuggagcauagugaaagagucuauuuugaagcuucaaacuuagugcugcugcagaccaggaacaagagagaaagaguggauuucagccugcacggauggucuugaaacacaaaugguuuuug\n", + "gucuaggcguuuuacacugagauucuccacugccacccuuucuacucaagcaaaaucuucgugaaaagaucugcugcaaggaacugauagcuuaugguucuccauugugaugaaagcacaugguacag\n", + "gcgcguuugugugugugugugugugugugugugugugugcucgugcppccpcugcgugcucacgcgcuccaggcugcgcccagagcucagcugcupuuggagaaaaagagg\n", + "gacuugacacagcaagcaaaagacauacagaacauaacaguccaggaaaccaacaaaaauaacucugaaagcauugaaugcagcaaaauaaca\n", + "gguacccagucuggapagcuguugucapcguucuggcugcucacucgugucaacccgccgaacupa\n", + "aggcguuugcgagaggagauacgagcuggacgccuggcccuucccucccaccpuccuaguccaccgcucccggcgccggcuccccgccucucccgcu\n", + "accacaccucugagucgucugagcucacugugagcaaaaucccacaguggaaacucuuaagccucugcgaaguaaaucauucuugugaaugugacacacgaucucuccaguuuccau\n", + "ugagcaaaaucccacaguggaaacucuuaagccucugcgaaguaaaucauucuugugaaugugacacacgaucucuccaguuuccau\n", + "guugcuccgacuguguguuccaggagugguggcucugaggugugacccugcccacguuupcccagccagguucagccccccaauaaggapcagcuugauaacacaaagaaaacag\n", + "ugucaacgaguacuaccaagagaagaagacaagaggucaacacagacucauuuucuacuccgugugaaugauagcuacagcapaaaguuucauagucuaucagupucagaaaauggag\n", + "auuccuuuuccggaacaaguuugcaucucuccucggucucucccugaagcccaccgguccccaacgcaucaugccapagccaagcguccugcccggcc\n", + "gaugaagaguaacgccauuaccgccggagccgccgagagccuuagccgacggaaacuggacacuggaccggcagcgcc\n", + "aacgccauuaccgccggagccgccgagagccuuagccgacggaaacuggacacuggaccggcagcgcc\n", + "gccccucgcugcccggagcccggaugaagaguaacgccauuaccgccggagccgccgagagccuuagccgacggaaacuggacacuggaccggcagcgcc\n", + "ggaugaagaguaacgccauuaccgccggagccgccgagagccuuagccgacggaaacuggacacuggaccggcagcgcc\n", + "cggagcccggaugaagaguaacgccauuaccgccggagccgccgagagccuuagccgacggaaacuggacacuggaccggcagcgcc\n", + "ggaugaauaagapaacccccacacggagacacugcuggagagagucguacupaggcagcuggagcagcaag\n", + "aacgcgaucucugcpcaagauggcggcgcccagacaggccuggagcacguagguggcpcuggapacggauuucag\n", + "cagcgccgaccgacagacgagguuugcgcuuggcupcauguuccgcggcuacucugcggcgcgccaggcccccgcuuuccgcaccccgcgacccuagaagccaccgaaccgccggcpcc\n", + "gacagacgagguuugcgcuuggcupcauguuccgcggcuacucugcggcgcgccaggcccccgcuuuccgcaccccgcgacccuagaagccaccgaaccgccggcpcc\n", + "cucuugcaggagaacucucuuguagcucacccugucugaaaacauacuggaaaggaauucaaggaaauguaguucagccuagccacguugacacaucaugaagccgucacaaaag\n", + "guauucuucagcggaaauaaggaaacaguuuacucucccaccaaaccuuggccaguaccaucgacagagcauaaguaccucuggcuuccccucucuucaacua\n", + "ggucccggccacaagcugucggcucgguucggucgcguuacapcaggcgccpccaaggcapapaucuuaggagagaucguagg\n", + "gaugucauaauacuaacaaaacaggaapcaucuccaaaucagcaguucagugcaaccagagucacacccauggaugaagucaaugaaguugauccagcuccauag\n", + "apuauuaugauaaacucugaucupaggaaccaggacuacauagaucaaggcaguuuucuucuuugagaaacuaucccagauaucaucauagagucuucugcucuuccucaacuaccaaag\n", + "gcugucauuuccuugaagacauggaucccauaacauuuauucuagugcuuuaugacaaguuggaauucaaugacuauuuauuaaauugaguucuuucagcagaaaaacaucagcgaagcagcaggcc\n", + "aggccapugcccgccaggcugccugacacccacagaupuggagcucagugcugcuccagcpcgagacpcpagaggacuguggcccaccacgupcacucuug\n", + "gcagagucuccagagauuupccgcuacaaaaagugcauuuugcccauucggcuguggauagagaagcaggaagagcacuggacuuggagucag\n", + "auagcaucagguccugauuuugcuugcccugugupagauggaauuuggcaagaugaugcuaugaacauaaaaucagccucpaaccaaaagagaaag\n", + "gagaaauugucguaaaugaagucaauuuugugagaaaaugcauugcaacagacacaagccaguacgauuugupaaagcugauaugcaguaacuucaaaaucuccuuuauuacagaugaccca\n", + "gagcuuuacgcccggaggcgucggcgcugccacuggcccgcgacpaacpcgaaaaggcggcggcacc\n", + "gaaapccupcggccgcacugagagcuuuacgcccggaggcgucggcgcugccacuggcccgcgacpaacpcgaaaaggcggcggcacc\n", + "aguccgcccggcucggcuggccgcagaaapccupcggccgcacugagagcuuuacgcccggaggcgucggcgcugccacuggcccgcgacpaacpcgaaaaggcggcggcacc\n", + "cgcagaaapccupcggccgcacugagagcuuuacgcccggaggcgucggcgcugccacuggcccgcgacpaacpcgaaaaggcggcggcacc\n", + "aaacaguauuaugucucaguccugugcaaagugagaugagcuguagccuuuggagaccuauaauuuugaacauagauguuccuuaaaagcuaaaucuuuuugaacagaugaugauaaaccuggaag\n", + "agauucaccaacaauagcaaauuacacacuggcuuggaaaguacucccauguuccguuugaucuuggcaauuuaaug\n", + "acgacuccuccaugauuggucagagaaggaaggcguggagcggacugacpagacuggcccgagaauuaucgcgauagcagcagcggccpcag\n", + "aaacaguauuaugucucaguccugugcaaagugagaugagcuguagccuuuggagaccuauaauuuugaacauagauguuccuuaaaagcuaaaucuuuuugaacag\n", + "cgagaagauuaguguuguuuguugcugauggccuucgagcagaugcacuuuacgaauuagaugaaaauggaaacucuagagcaccguuuauuag\n", + "gaguuaaaguuccucguaauuuucgcuuguuggaagaacuugaagaaggacaaaaaggaguaggcgacgguacaguuagcupccuugaagaugaugaagau\n", + "gaagauggcggucuccacaggucgguucccpccpcugcgugauuuuccgcuccgacccggcucugccccuccgucugcugcuggcgcccgagcgcugaccgugcpagaagcccga\n", + "gucuuccacuuucgccuuggugccugucuucgcccaccugagcauccuccagagccucgugccagcugcuggugcagccucuccuguugccaucagugcccagcaccugugcuacagcc\n", + "agacgccgucpcggagccpucgcgaggcugcaucccggccggcgguuccggagccucgcggcupaggcgcggcccpacgcucgagcuuapag\n", + "cgcaucccccugcuggucugcccgccgaccugcgcgcccucgcugccgcccgugugcgccccucgaccccagcggcacc\n", + "auccuuauccugcuggucccccuccucccuaugguccuccucaccagauguacuuugaaggcccccaaguuguucag\n", + "accauupcagupcuuucaacgugcuguacucucccuuaaaguguugcaaggaagucgccaaaugagacuaaugacucccccacaucag\n", + "cccgccccggcuguggcccccggcugcggaggaguccgagacgcagcugccgcgccpccugagcugccgccuccuccgccgcccgaaaacccggagugccccgcacag\n", + "guuuagacccagugugccuggupcugugcccagguucagagucaugccacucugupugaagcuugaggcaaaa\n", + "cuuccggugcpccccgccccggcuguggcccccggcugcggaggaguccgagacgcagcugccgcgccpccugagcugccgccuccuccgccgcccgaaaacccggagugccccgcacag\n", + "guugugcagccugacucugaagaagcugguggucuucaaggagcuggagaaggagcugaucuccguggugaucgcugucaag\n", + "guguauuuuuguacaauggacauccaauaaaacagguagaugucuupaacugucauuggagugagagaaagagaugcuuucuacaguuauggag\n", + "uggaugacagcacuggaguuauaaacugcaucugcuggaaaaaguugaauacugagucuguaucag\n", + "pagagaupcggagccguggcgaggcgcugcagcagaaaggaaaugcgcuggcpagaccp\n", + "gcgccpcpucgucgccgccagcggcuccgagcgccggaapccaggucucapcuccuggagcugcaggcggcpapcuacaa\n", + "pucgucgccgccagcggcuccgagcgccggaapccaggucucapcuccuggagcugcaggcggcpapcuacaa\n", + "gaccucagccaacugcuccugcgccpcpucgucgccgccagcggcuccgagcgccggaapccag\n", + "gaggccgcgccapcgcuguugcugccaauacagcugucauggcguccaaggcgcuggcugcggagaaguggccgcggucuccauagagcupcpcggcccggu\n", + "gcuguugcugccaauacagcugucauggcguccaaggcgcuggcugcggagaaguggccgcggucuccauagagcupcpcggcccggu\n", + "acagccacagagcuccuggcgupcaaggcuggccaaggauggcgacgcccapccupcccugcuccugcuccuccugcucccgaccucag\n", + "agcucagcagagccupccagapccagacagccacagagcuccuggcgupcaaggcuggccaagg\n", + "gccacucuccauccaggccccaggcaagcagcaccucccugcucuccugcacuccuggacacaaccagcagcuccugcc\n", + "agacacucuccaaaaagcagagacagcaggaagapaguggaggcagcccauucaccupaa\n", + "ccagccccgcagcugcuccccaucucucugccaacugccagaacgacacaggaagcupccggugccucag\n", + "ugugaagapagugccacucuccauccaggccccaggcaagcagcaccucccugcucuccugcacuccuggacacaaccagcagcuccugcc\n", + "ggagacgcugcgcgugcgcgcapcagacgguagagcggagacgacgcucccagacuccuccggucuccccpcagc\n", + "pcguguauccgcggccguagcagccpcugguccugcugcgagccggcggcccggagupcggcgg\n", + "cauguaccuuccacauugaguauucagaaagaagugaucugaacucugaccauucuuuauggauacauuaagucaaauauaagagucugacuacuugacacacuggcucg\n", + "gcaagcugcgcagcgccpccugapcguguauccgcggccguagcagccpcugguccugcugcgagccggcggcccggagupcggcgg\n", + "aucacuuccpcgccagguucpcuuucuccugcagcgauaapcagucgacagucuuuaguapaaaggagacaagugcuagcuacugccgcccaaguggaag\n", + "cuuucuccugcagcgauaapcagucgacagucuuuaguapaaaggagacaagugcuagcuacugccgcccaaguggaag\n", + "uauupaauugaaacuaguugugaugauacagcagcugcugugguggaugaaacuggaaauguguupagaagcaauacauucccaaacugaaguucauuuaaa\n", + "agcccgcguuagccaucuacauacugaaucggaugugcacuuccaaauuugagauguaggcauuucugccucaacuugcuagcugcgauuuuaaaag\n", + "cuuauguuccugaggaagaauugaaggcagcagaaauagaugaagagcacguggaggaugacpcugucuuuggacauucaggaaagugaguac\n", + "agaucagauucuucaucugaaagccacugugcuacuggauuauccaaaaguacaguuuauuucacagcacugaggaggaccagc\n", + "gcagaaacggcugcupcagcugaupcaggagcuuaccaggcuggcuugcucugagcugcgguuacuguguccaggccccpuucucag\n", + "guuggcauugcuccagcaucaugcccuguaauuucugaugaagauagucauaggcagaugauucguaacuaucaacaucagcuuuuacaacaaaacag\n", + "agugucpcgcagacggcggcagugcggcuugcucuuggaaguucaggcucgguugucuuuupagcc\n", + "gccgugacucagcacupcggagcpcpaccacccuuauaaggcucggaggccgcgaggccuucgcuggaguuucgccgccgcagucuucgccacc\n", + "gcguuccauuggugcccugguuacgccaccuguggcucaguugcacagcugccugguaggugacuggaggcauugagcagugcucacugguauuucgcug\n", + "gguggucgccpagccgccagcacguggcggcgaggaapcggugugcuccuguugucugcaccugagapcaggagcucucggcgcuugcgccucccgccgcggugcccucccgac\n", + "gaaauccaguuaucaaaauugacucaagaagagagaaccuaacagaacaauaacaauggaagaaauupaacauuaucacaaagcuaucauccugccaaacuccaggcucagaugucacag\n", + "gucguugguguguugcgcgacuggccuugapagagcupccugcucccggagagauacggcu\n", + "aaaaaugucucaaauupuauaacaaaucagcgugauugccuuucaccuccacuuuggagugcuuugagccaguuuggacacaaggagguuggaguuaaaaugacuccugaaggaaguaagcaagc\n", + "ucccuaaguaaacuupaucuaacuguucuugcaacccuuugcacuguagaaugaagugcccacuuuaacuuaaagagcapcuaaucagaucuucggcaaauaauaa\n", + "gaccauuucagcuugaauuugacggcgaaguguuguagagaccgucuccuugaaucauugcaaapaccpaaagaugapcucccucuguggauuuaucuugcugagg\n", + "accugugaagcuugaggccacucaaguuccaaauuugugacaaaucccccapcucacuggaguggca\n", + "ggcaguuggaagagagaagaagucacuacapuacugaggaaaagcuuugcugaaauuggagaucaaauaccagcucugccaguaagaaguugcaucucccagugaa\n", + "acugugcccagcgccugcauacaagcacugccaguguuaagaguccapaggaggapagaacaguucpcugccaggauguuguuuggap\n", + "agcacuccgcugguccaggcggcaacauguccaugcuuuuagugaugucccugccucuaauccagaagccauggaggagauaagguagccccccucgaucgg\n", + "apaagucagacgagagugcaagapuguggagapuacugauaucugaauuauuapcagguguccugccaaggaaucccuccuuuaacagagcuuca\n", + "caapaagucagacgagagugcaagapuguggagapuacugauaucugaauuauuapcagguguccugccaaggaaucccuccuuuaacagagcuuca\n", + "ggagapuacugauaucugaauuauuapcagguguccugccaaggaaucccuccuuuaacagagcuuca\n", + "puguggagapuacugauaucugaauuauuapcagguguccugccaaggaaucccuccuuuaacagagcuuca\n", + "agacgagagugcaagapuguggagapuacugauaucugaauuauuapcagguguccugccaaggaaucccuccuuuaacagagcuuca\n", + "aaucuacaggagccauuuuaacagcuaaaacuugucggauugcuuuuuauuuucaagcucaaaagacgauagagaaagaauacuugaag\n", + "guucaauuaguaccgcagaugguucugcuuuagugaaguupaaauacuacaguaaucuguggaguuaaagca\n", + "auuccggucuggaccuccuggagaagaggcccaaguggcuagccaguucauugcagaugucauugaaaa\n", + "cuugucupuucuauacugugaucucauuugccucgacuacgauggaaacauuuuggaugccugcacauuugcuuugcuagcggcuuuaaaaaaug\n", + "uugccugaaguuacuauaaaugaagaaacugcuuuagcagaaguuaauuuaaagaagaaaaguuauuugaauauuagaacucauccaguugcaacuuccuuugcuguguuugauga\n", + "cacuuugcuuauaguugacccuacuggagaggaggaacaucuggcaacaggaaccuuaacaauagua\n", + "uagcuucuuucaauaggaaacauuucuuugcuacuauaggaauuugcagcaccaucaacagaugccccugauaaaggauacguug\n", + "uuccuaauguggaucuaccaccccuguguucaucgagauuccggucuggaccuccuggagaagaggcccaaguggcuagccaguucauugcagaugucauugaaaa\n", + "uacaguugccugaaguuacuauaaaugaagaaacugcuuuagcagaaguuaauuuaaagaagaaaaguuauuugaauauuagaacucauccaguugcaacuuccuuugcuguguuugauga\n", + "aguccccaaggcpcauupacacapaapaaagcacupupagcaggagaaagccagauucccapaagcc\n", + "cucagccgacagccucagccagccuaguccccaaggcpcauupacacapaapaaagcacupupagcaggagaaagccagauucccapaagcc\n", + "acaguuuacaguaucugccagcugugaguaacagcaggcugucaugaupauauagcagaagcagcagcagcaacuccugauuuapcaaucgau\n", + "agcaaaucaguugccuggaguucccagugaaguuguaccugugcccgugcgauaacgucaguggaagcugccccga\n", + "guuupcuuuagccccuuggagaaaacapccacauagcugccuuucuaucaagucucccuacaaaacugagaggcucupaaacucagccugugaccccagcgupugaagauaggaucaag\n", + "cagagcaaaucaguugccuggaguucccagugaaguuguaccugugcccgugcgauaacgucaguggaagcugccccga\n", + "ggcaguuggcguaggugcauucggagugcggccgagguaacuaccgagucuucggcpcucgcgagcccggccgcggccugcugguuucag\n", + "auucggagugcggccgagguaacuaccgagucuucggcpcucgcgagcccggccgcggccugcugguuucag\n", + "acggagucuuacucucucucccggucuggagugcaguggcgugaucucggcucaauguaaccuccacucuccpuucaapuucuccugccucagccucccaaguagcuaggaccacag\n", + "agcaacuagcaggugucucagcagagcaagaaguuacauguaucgauggaggcaagacccuccccaaacag\n", + "ggcguaggugcauucggagugcggccgagguaacuaccgagucuucggcpcucgcgagcccggccgcggccugcugguuucag\n", + "aguuggcguaggugcauucggagugcggccgagguaacuaccgagucuucggcpcucgcgagcccggccgcggccugcugguuucag\n", + "gugaucauuucaaaccaagcaucagcaacaauuaaaaauauucacuugguaucuguaguuuaaua\n", + "cugcaaupuugcuacugcugcggcuaaccaaacagcucaugcuucucugaagacuugcagcaaggcuugcugaggcucacagaagauagccccag\n", + "aguaaagccagcagccugcaaupuugcuacugcugcggcuaaccaaacagcucaugcuucucugaagacuugcagcaaggcuugcugaggcucacagaagauagccccag\n", + "uguuuuggagugguuuugaaugugauucugagaucagacugacugagcuggaauccuggcuuuauaucuuaccagcuacacaaccuugg\n", + "gauccucccggcccaggccgagcugcccacgcugcugcccpcucggugcccggcgcggccucugccggcuccggcpcgcpacugcgag\n", + "aacaguguuaccuuggagccuacaaugagagguauuucaaaaugagugaagcaugacucucacagaugaaggccuagacgcag\n", + "gaucuuuaaugaaaaaacacuupccacuucaagacgacaaacgcucacupcaaaacaccuucacugaaaagagaccucauauuaugcaaaaaaaaucuuaaaag\n", + "cucuuuccgccaucuuuccgcgccggugaguagcacucucugagagcuccaauuucauccgucugccaucggcgccauccugcaaucuaag\n", + "gcgauagcucucccgcuucccauaacuccgugcgcucuccccucccguccucuuuccgccaucuuuccgcgccg\n", + "aaaaguccccaggagaggcuccagcaauaccapuagcgguuugcccgacaccgcuccpcgcugcagccuuccggcaacccggacguugg\n", + "cuaaauagccgcagccucugcgcgucgcccuccacgguuaccccggcucuccgccccuccuucucgcggcgcucgapacc\n", + "acgcacacugaguccagguccuccugaaggucaccagcacagcpcccuguguuacuguagagagaagucaguugcuuaguuucagccuccugccggcaccag\n", + "ucuaaaucaagacaggagcaacaggaaagaaccuacugcggcugagaggugugagcggagapapacaaagcccccaucccpcccuuuucacacuggcugucaagg\n", + "ucaacgguccucaccccccpuucpcuuccgccgcaccugauacaggapaggagugcggcucgagcaggcuggaggucaccauccccaucag\n", + "aacuugcaauguuuuucccccaugcaauuaguucuauuacuuauguuucuccuugucuuuauaggcaauacugcaccugcauucucagugaccuuggaaucu\n", + "uaagaagaaagcauaacccauagaccaucuucuggcagaagaugauacauuuggaucagaaacpaggcauuggaagccaggaaucaaaagugaagaaacucugcaagcccuuag\n", + "auucuuuauacaauugcauauguacgaguggaugaacguaccauuggugaucccgaggauuuuugucaagauuggauaaacc\n", + "aggccpccgcccgcacaggccgccgcgugucgaguccgcgcpagcgcacgcpcpcggcgacag\n", + "gcuaacpcggucggccgccuccuuccucucuuggcuaccacpcucugccccuccucugccgcccgcpcapcuucaccuuucucucu\n", + "gcccucupcccacuupccgagcgguucucacccgcccucuccgcacguccgccggcgccucagguuucccccg\n", + "accggcgcpccucuccuccucccgcuaacpcggucggccgccuccuuccucucuuggcuaccacpcucugccccuccucugccgcccgcpcapcuucaccuuucucucu\n", + "agacugcauccgccgcggcgucuccauggcacgacccuggccuccgacuucaacgacuucauaaggcggcguuucupcgcagccgugucgcuccug\n", + "guuuccaucgugupaagaacggaguaacgagucucacgcagaaaaaggucuugagagcaccuuguggcgcacccaguguaacugugacg\n", + "uggcpcpcaucucugugacgcuapcupccucgauggcgaaacccaagcggcucccppuuugaacuggcca\n", + "cagacugcauccgccgcggcgucuccauggcacgacccuggccuccgacuucaacgacuucauaaggcggcguuucupcgcagccgugucgcuccug\n", + "agagccagacugcauccgccgcggcgucuccauggcacgacccuggccuccgacuucaacgacuucauaaggcggcguuucupcgcagccgugucgcuccug\n", + "ccgccuccuuccucucuuggcuaccacpcucugccccuccucugccgcccgcpcapcuucaccuuucucucuaupcagaaaccgguacccuccugccugcug\n", + "agugucugccapagccacagcaggugcaccugccacauaaguucuggccpcuuuguuguaugaaggucuaagaggugag\n", + "gcaaagccaaagcuaauugagccacucgacuaugaaaaugucaucguccagaagaagacucagauccugaacgacuguuuacpag\n", + "gaaccaggapuupacccauaguucaugaucgaaagucucagacauugccuguuucccguaacagaacagga\n", + "cuggcaugccugugccuugcacggccapacucgcagcuguuccaguugcagacuuucugacuugcguuuucagccgaga\n", + "gucaggucggaggaguagcaccugccaggagcacgucccgccggcaggucgcaggagcccupagccgccgcc\n", + "ccccgucagcagccggcugcugagaggccgguaggcggcggcggucccgapcggcggccgcgcugcucccugagaacpucccgcagcupcaggcpcggccugapcgcggagcc\n", + "cupaggagagccapccccagccucuccuuugaggaguguugcagccuuucugugugccagaugccuagugaagaaaagcugaaacccuggagcuuugugc\n", + "apaacagagagaauugupcagcaccgcuccuupuccccacuccccauuucucauugcuuggaaauccaugccaag\n", + "agagagaauugupcagcaccgcuccuupuccccacuccccauuucucauugcuuggaaauccaugccaag\n", + "uguguggcugugaccuggcacaapcuucuucauaaagaacggagaguaucucugcacccuggacuaccagcgg\n", + "cacugcguggucgcacccuacccpcugccuuggaagucguccccgccgccccuccgcaccggc\n", + "cuugugauucacugcuaaggaucuuaagcccaccuuggcccugaccucguuggaaaacgaagcuccccgcapucccggccucuapcugcugugcpcpugg\n", + "uuggcccugaccucguuggaaaacgaagcuccccgcapucccggccucuapcugcugugcpcpugg\n", + "aaauuuccaaggaaacuauauuucuuacauugauggaaauguauggaaagcauacaguuggacugagaaacu\n", + "uuuccuucucccuuuccccgccagcuucgcauccaucucccccaccccguaacccccuccugccuccauccaccpcu\n", + "ccugcccugaaacaagugauucuauuuggaagguugaaucuauaugaguuccaccugcccuaaaaacaagugaaucuauuuggaag\n", + "uuuacuaauuugugaagcuuuaccuaacucauauccaccuuguuuucucauuuuuaguuguuaauccugauguaaaau\n", + "cccagucuauccauucugccuuuccugucuuugagguuccuagcaagcccaapuauguuagaagaaaagaccacagauuauuguacu\n", + "ugcugccaccauguaagaagugccuuucgccucccaccaugauucugagaccuccccagcaauguggaacu\n", + "gcgccggaaccggaacggagagcpuugccapcccgaagapcuggcugcggcggucucgcucg\n", + "accgaccugcgccggaaccggaacggagagcpuugccapcccgaagapcuggcugcggcggucucgcucg\n", + "gupcaggcgaggagcpaagaccaucucugcaagugcagcauagccucggccuaggacagcpagugcguggccaaagcugugagcagaggcacaggugguggcagacaguagaggcgcccc\n", + "agcaaagaagacaaaaacucaaggaacaucuguugagaagaaaaacgcuuuuugcauacaagcaggaaaaugag\n", + "gcagacugcggcggcgguggucugaggaaguucuaucuuggcgcuaaagcggagacgcaucccccgacccgaggcuacg\n", + "agcaaagaagacaaaaacucaaggaacaucuguugagaagaaaaacgcuuuuugcauacaagcaggaaaaugagauguuauccag\n", + "ggagacggcagccgcgccgucugacggcuuagccgcggugcagacugcggcggcgguggucugaggaaguucuaucuuggcgcuaaagcggagacgcaucccccgacccgaggcuacg\n", + "uuagccgcggugcagacugcggcggcgguggucugaggaaguucuaucuuggcgcuaaagcggagacgcaucccccgacccgaggcuacg\n", + "auuauuugcaagagacacagcuaucuucuacaacuucucugcuagcuugccacacacacucuagaagcca\n", + "gucuucaguuucuuuacucuccaugguggugccuggcugcugcgacucuapuccuuugccupauuaguagugaccauu\n", + "acucuaggucuucaguuucuuuacucuccaugguggugccuggcugcugcgacucuapuccuuugccupauuaguagugaccauu\n", + "agaupuuucaccauguuggccaggauggucucuaucucuugaccucgugaucugccugccucggccucccaaagugcupauuacagaccugagccaccgugccuggccaaaaucuug\n", + "agaaupaggagacacagcagaggaauugagacauaaauagaguaaaucgcuaaugacauuuccuacuaauagucacugagucug\n", + "gugucugaccuccuaacacaagagcaagcaaaccuaacucaccagaaaaagaaacuggapacagaucucagcccggcaacaagcagaagaagcuucacaggagucagaaaacgaacucaaggaa\n", + "auaaaauuugaugcupacucuccuucuuaguacacaccgacugauuuggagagaucagaaaaaucau\n", + "gacccuucucccgccauuuucggcpcupagacugaggcccgcggcgcugagccugcggcgccccggaagaggcpcggc\n", + "auuuucggcpcupagacugaggcccgcggcgcugagccugcggcgccccggaagaggcpcggc\n", + "uacugugagauaugcagacuupacguugguuuucauaggcuggugaagacagaaccauuucccauuucagcaag\n", + "ucccgccauuuucggcpcupagacugaggcccgcggcgcugagccugcggcgccccggaagaggcpcggc\n", + "gccauuuucggcpcupagacugaggcccgcggcgcugagccugcggcgccccggaagaggcpcggc\n", + "agucuuugagagucacaucucuuauuuggaccaguauagacagaaguaaacccagcugacuuguuuccupacaguugaguuaap\n", + "agcuugucccacagcgagcuguggagcupapccauucagagcucugcauggaggcapuggccggccuucguccccucaggccagcapcaaggcagcuccccucaauagag\n", + "ggcucuguguaugaaugacaaggauaccuucagccagcucauucuggaugaaugaaugauuacacuaaguguccuccacauuccucugugg\n", + "gcucacuucauggacucacuuugcgugcuuguuaaaugugcuguguugcucccaagaccauguaaagccuacugaccacuaaccucccucacagcagaaacuagacgucag\n", + "gacagaaugacuuggaagauaacggagcuucgaagcuucuagcagaauaugaagucuuucgucuucagcuaccupuuaaguuuaagcag\n", + "auugccupaugagapagagacaacgugugucuuacacaucucccaacagccgacuuagaugugauccguucucccagapagcagguuucuuugaacuuuuccuuuuu\n", + "uggcaaagaauuagaaacuaaguggaugcuuucgacagaggaacaguuggauaagaugucacacguccaugccuuggauuucugcacuugaccuggaaggauucccaugagaaaagaaaag\n", + "agcgagcuguggagcupapccauucagagcucugcauggaggcapuggccggccuucguccccucaggccagcapcaaggcagcuccccucaauagag\n", + "acacacacacacacacacacacacacacacaccugagaupuagaucauuguauuuuugugucuaccagcaagaaaaggaaggaaaaacuaag\n", + "acuugaucuccagcuuccaacuuaagcagaacuugagagcauccgaacuccuggauuucaggacaag\n", + "ggacpccuggcaguugugaacucgaaccugccgcugucgccgcggcpcpagcgagagupccgcggaggccggccuucpcucc\n", + "aguugugaacucgaaccugccgcugucgccgcggcpcpagcgagagupccgcggaggccggccuucpcucc\n", + "ggagcucagugucuguuuguccagcuucucagaguugcugugcagcucggauguggcauaggaaacagcagacacapagapcagcauaaggcacuguapagcaguggccacauuuucug\n", + "cuucuguuuucucuucccuccccacagguaaggcuggccucucugcagucagaggucugagcucugcc\n", + "aguugugaacucgaaccugccgcugucgccgcggcpcpagcgagagupccgcggaggccggccuucpcuccauggacpcgccgcgucccugcacagcccgccgcagag\n", + "cggcppagguupacpccuggcaguugugaacucgaaccugccgcugucgccgcggcpcpagcgagagupccgcggaggccggccuucpcucc\n", + "papagaaacapcagagugaguuggucucuggagugacugugcuuuuccacccucagcagaggaagaaccg\n", + "ggcacauggcuauguucuagcuuugcagugaauguuaaaggugcucacagugaaacupugacuaauaggauauagcagcuggucacucaacaacccucacaggacagcauugccugg\n", + "agugcccugcucaucaapucupugaggccccaggucauaaggaagcccucgcucgacugccccpcccaucgcagcccccaaccagccccgagcggucugaug\n", + "pcgcugugccaggcggcggccgugcpcpcgcgcugcuccuuccgccucgcggaccccggaagcgcgcguggccgcc\n", + "ggagaacuucpugaaaugcaucccuccugugacuggauuggagacacaagaacagaaacauccugaucucucuacucuacugugcaggcuuauguacucauaaa\n", + "ugupagcugacucupuagccggcugcgcguggcupaggcgaggccggacgcaccucuguuupuccucag\n", + "pugcggacugupagcugacucupuagccggcugcgcguggcupaggcgaggccggacgcaccucuguuupuccucag\n", + "acccucaggcaguuugauugcaucuacacaagauaaacccaaccagcaggauauuguguuuuuugagaaaaauggacuccuucauggacacuuuacacuucccuuccuuaaagaugagguuaag\n", + "guaaaugacuugcucuggaaugcagauuccucugugcuugcagucuggcuggaagaccuucagagagaagaaagcuccauuccgaaaaccugug\n", + "uucagcucuggacuguuggaaacuaucacugguaucucaagcaaaguuuauccuucagcaccugupaagagcaagauugugucucug\n", + "acgaccagcgugcugcgucacggcggugcgccggaaguggcugcggauuucgccggaaaucccggaagugacagcuuupuuugcugcuggcucugacucccguccugcg\n", + "gccggaaguggcugcggauuucgccggaaaucccggaagugacagcuuupuuugcugcuggcucugacucccguccugcg\n", + "gcggauuucgccggaaaucccggaagugacagcuuupuuugcugcuggcucugacucccguccugcg\n", + "agugcugguuggapacgappugcggagccagccaggccgcccucccguucucacagcagccgagcagagcgcagagcpcugcc\n", + "auuccugagcaggcuccgaaggaggcagcupccaggcapagcucugccuccuccccacuuccccagccucagugcccgcccaccacucucaaccugucuggapc\n", + "agccuuagccauccuuaaacucauccaaccgauucccauuuccgcpugcuuggcuuagugcugagacpauuccgccguugguauucagguccaacacuaagacugugucc\n", + "ccgacuccugcucaupuacccccauccugagagacuccupupaccccccuccacgacgcagcagagaacpcagauggag\n", + "gugccccugcugaugacgcccccaccaccaccguuccccccaccuccacuguuggccacgaggcgcucccuggaggauggaagaagaggaggcccapccapaaccccagcc\n", + "ccaugucccucagcccggccuggccuggccauccugaccagccucuucccapagcagaugaccagcccggccccuccgaggaucaucaccagugccacggcugaccccgag\n", + "agagccggcagcuucauccacgucugaaacaggaagccccagccugugcaugagucgccacugagagcccpccagagg\n", + "gacuuggugaauuuuauucaagcaaauuuuaagaaacgagaaugugucuucuuuaccaaagauuccaaggccac\n", + "aaaagauguccuuucpcagccaggcucagcaugaggaacagaaggaaugacacucuggacagcacccggacccuguacuccagcgcgucucggagcacagacuugucuuacagugaaagc\n", + "cuccgguccccgccgcuccccguccccgcugcuccuagccccugccgcguccccggcggagcpc\n", + "gcggccgcpcagcggapcgccggcacuccgguccccgccgcuccccguccccgcugcuccuagccccugccgcguccccggcggagcpc\n", + "gcggacggcupcugcugcupcggccgcpcagcggapcgccggcacuccgguccccgccgcuccccguccccgcugcuccuagccccugccgcguccccggcggagcpc\n", + "acccucaucccucccgupagcccccuuuggacacucuaugacccuggacccucpaccugaacuugaugcg\n", + "aupaacacgcpugcugucacgugauccgacaaacggccucugcauagugcagaacauucugcugcucuuaaag\n", + "aucucagagagcgcpuccggacagccgcgcgcugapucucpcpcgccgcpaccucuccpcc\n", + "cagccccugucaaapaacaggaagcaguccacggapugacgcccuagacccaccugcaucccccaaaccugcuggcaagcagaacggaauccagaaccccaucucgcuggag\n", + "gacucccccgaggcaggcpagcpaggaggagcaggagcpaggaggagcaggccuuccuggucagccucuacaaguuc\n", + "caucgcupacaaacucggcagcggaggcaaaguuauuuccccucccaggcagcpauuccgacuggcaag\n", + "uuaguuacaaauucccaggucaaaagaaauuaugaauuauaagagguauacagaacagaagcagcauuugg\n", + "ucauuupaccuuucagaaguguaguauccugaaacaccaagcaaauucagaccuucaugcugaggugaauuuguaaapucauupcguacccuuupagaacugauacggccuucagaccu\n", + "aaaaucaucagucuuggaauacagaagagaaacuagaaauauacguauuuuguuucacauuugaacagucauucuugaggaauacuccauaccugaguagacagcc\n", + "aaauguuuaauuugguaaauuggaggaaaaaaacauggauuuuuagcaauugaagagcaaauuaag\n", + "ucuuggaauacagaagagaaacuagaaauauacguauuuuguuucacauuugaacagucauucuugaggaauacuccauaccugaguagacagcc\n", + "agaaagcggacaggapcgacuuuucuccgucaggcuggaacuggugccgcuggaggcpagcpcuggaggacggacapucugg\n", + "ugacccagauugcagugagaguucccgcaggccccgccucuuucupccucgugucucccagccgccpccpugcgaggccuuaccccucugaucugcugcagg\n", + "ggagcggcupagguucgcgcguuucucapuucggucggaggcpaggccggagcugcpcguapaccuggcggcuccugaagcgcacgcpcpcggcag\n", + "gccgccgcggagcaagcgagccaagcgcggccucauuagaccacpuugcagccggagcggcupag\n", + "cucuuuuccugguuucucaagagugcugcugcuaacgcgguccccggcacgcaccaucuguugccaucccggccggccgaggccauugcag\n", + "auggaaaagacuaagguggcuggacgugguggcucacgccuguaaucccagcacuuupaggucgaggcpaggaucauuugag\n", + "cpacacgaccuugupugagguccuuggcccucggcccugcucagugcccaugagcupugaauuugauugucacuuaacucaccupuuaagacggap\n", + "acgcgugcgcuuaggcgccgcugagcgcugacupugcgagupaagcugcuaacccgacccggauuggcgcugagguggcccgupcag\n", + "ggcagaugauucuggaccagaugaagccugaggagccuuccagcucuaagauagcaggauaggagacuucuaagauuggagcugcagaagacuugccagcccaccagcaca\n", + "gccacgcgugcgcuuaggcgccgcugagcgcugacupugcgagupaagcugcuaacccgacccggauuggcgcugagguggcccgupcag\n", + "ggcagaugauucuggaccagaugaagccugaggagccuuccagcucuaagauagcaggauaggagacuucuaagauuggagcugcagaagacuugccagcccaccagcacaaugucag\n", + "aaggaagagucagcagagcaaccagaguucuacuacgaugaguuugguuuccguguguacaaggaag\n", + "cuucuguccacacacagcucugcaaggagagugucuucauucuuuccgccaucuugauucuuugucacugaccgagacucagccg\n", + "agaccagcccagauccaguggcccggapccugagcuaaauccgcaggaccupuaacacgaggaag\n", + "cccggcuccuaggcugacagaccagcccagauccaguggcccggapccugagcuaaauccgcaggaccupuaacacgaggaag\n", + "gugacagagaupuggapcupaaaggcuguuuacuuccuccugucuagucgguuuggucccuuuapcuccggauaucuuuggugacuuguccacuccaguguggcauc\n", + "acagaccagcccagauccaguggcccggapccugagcuaaauccgcaggaccupuaacacgaggaag\n", + "auugugagaguaaccaacgupuuacpagaaucuggagagaagagaagagguuaacaacccucccacuuccuggccaccccccuccaccuuuucug\n", + "agccccggcuccuaggcugacagaccagcccagauccaguggcccggapccugagcuaaauccgcaggaccupuaacacgaggaag\n", + "guuuacuuccuccugucuagucgguuuggucccuuuapcuccggauaucuuuggugacuuguccacuccaguguggcauc\n", + "guugagauccguagcauuuuaguguccgagaggauaauugcuaapagcagagaccucuucacaccuucaugcgcuuagaccugccuagaggcucag\n", + "gagacapucucauucaggcuggagugcaguggcaccaucauagcucacuauagccucgaacucuuggacucaagcaaucuuccugccucagccucccaaagugaugagauuacag\n", + "gaauacaggaguuuccagaaaauauaaaaaauuguaaaguuuugacaauuguggaggccaguguaaacccuauuuccaa\n", + "gcucccugauggauuuucucagcuguuaaaccuaacccaguuguaucugaaugaugcuuuucuugaguucuugccagcaaauuuuggcag\n", + "caaagugacugaugaapaaggaaaucaugucaagcgaagccuugaaaaagcugcccugagacggugucccgccgaaag\n", + "acacucgccucgccguucpaccagccagaucgcggcggccucgcpcgguuuggucggugaggucuuggccgcgcgcggca\n", + "gaagauuuuggagcccagcugugugccagcccaagucggaacuuggaucacaucagauccucucgag\n", + "ggcggugcccggacgcaggugccggccggagcggagcuaguggcgccgacpccpccpccpaccpccgaggcgaaccgapccugugcggccgcccggcccggccgcggaucag\n", + "cucgucucaaacuccuggccucaagugauccuccugcuuggaccucccaaagcgcupauuacag\n", + "ggacgcaggugccggccggagcggagcuaguggcgccgacpccpccpccpaccpccgaggcgaaccgapccugugcggccgcccggcccggccgcggaucag\n", + "caggagugcccgagacccuaagauguucggagugguuuuuucgcacagacccgaauagccugccccucagccacgcucugugcccuucugagaacaggcugau\n", + "ggcugccucacugcuucaaacagccuacaauuauauaupagcaaaaaaaugacuuaaaguuggaauuuauauuuaaaag\n", + "accuagcauauccaaacucuugcaucaaaggugcapacuugcucacaucgagaaucugguugcuuucuuggagaccaagaaaaugaguuuuuguuucuacauuuacuccagcaauccaugag\n", + "acacaaauuagcgucaguccacugacugucgccuacaauaaauuaggcugagucuaaaagaaaucagucugcauagaaagaccaacaaccagcaccacuuccuugcuuuuuccagcc\n", + "gaggcucugucgguggugagcgacgaccagucccucuuugacucagcguacggagcggcagcccaucuccccaaggccgac\n", + "acagucucuccaucugcauccccacuucaucaccaucccaccgucucucccucgcuccacucgcpuaaccgaggcuucucccucccaggcugguucuupcguucccgacccuuagcuacccacg\n", + "agacupuccaggcupcugupugagapugcagugcucagccuggcaguuggucucucaguggcc\n", + "cgcagaggccgccgcuuccaggaagcucuccpacgccgcgcccucgccucupcgccugcgagucugcggcccgcaggugacggagcucacggu\n", + "agucaccuuaucucucuaagccgagaaaaguggccuccuggaggucccucaggacggcapagc\n", + "apaaggccccgaggcugcpcggccapcugcccgcggauucccagacccggacgcccgagccagcaacccugapcggccpcagcgccgccacc\n", + "agcpucgcpccggcgccapaaggccccgaggcugcpcggccapcugcccgcggauucccagacccggacgcccgagccagcaacccugapcggccpcagcgccgccacc\n", + "agaggccgccgcuuccaggaagcucuccpacgccgcgcccucgccucupcgccugcgagucugcggcccgcaggugacggagcucacggu\n", + "agcauuuccacuuucgucagguacuggagapcugccggccggaugccapcagapcapcggacggcuaggaguucaagaaacauccuggucugapaaaggcugcagccugcaccgcc\n", + "agapcugccggccggaugccapcagapcapcggacggcuaggaguucaagaaacauccuggucugapaaaggcugcagccugcaccgcc\n", + "aacaccuuugcaccuagccugugcuaauggacauacagauguuguacuuuuccuaauugagcaacaaugcaaaauaaauguccpauagugaaaacaaauccccauugauuaag\n", + "auuuccacuuucgucagguacuggagapcugccggccggaugccapcagapcapcggacggcuaggaguucaagaaacauccuggucugapaaaggcugcagccugcaccgcc\n", + "ccaugcuggaggcggcggaaccgcpaccuaggacggaggcggcpcgcupcggcccccggcacgcugagcucp\n", + "gcacucgcucccggcccaugcuggaggcggcggaaccgcpaccuaggacggaggcggcpcgcupcggcccccggcacgcugagcucp\n", + "ucccggcccaugcuggaggcggcggaaccgcpaccuaggacggaggcggcpcgcupcggcccccggcacgcugagcucp\n", + "aagaagagugacugucucagugccgagugccucagcagcuucuccacaugcucuucaguccccaaaguuggagaaucccaucaaggagaguagcccuguaaggaauucgaauuuccagcau\n", + "gaugcgaguguguaugugcpcgagaagauggcggcggcpaagcagcgugagcagccggaggaucgcggagucccaaugaaacpcagcc\n", + "ggcggcpaagcagcgugagcagccggaggaucgcggagucccaaugaaacpcagccauggcccuccacagcccgcag\n", + "guguaugugcpcgagaagauggcggcggcpaagcagcgugagcagccggaggaucgcggagucccaaugaaacpcagccauggcccuccacagcccgcag\n", + "cuccupccaugaucccauuuucaucagaugacuugagaacccagaagcucuaccagcacugccauucugucccgucuugaaacauc\n", + "gaguguguaugugcpcgagaagauggcggcggcpaagcagcgugagcagccggaggaucgcggagucccaaugaaacpcagcc\n", + "augugcpcgagaagauggcggcggcpaagcagcgugagcagccggaggaucgcggagucccaaugaaacpcagcc\n", + "guguaugugcpcgagaagauggcggcggcpaagcagcgugagcagccggaggaucgcggagucccaaugaaacpcagcc\n", + "ggcaggacagccgaguucaggugagcgguugcucgucgucpcggccggcagcggcggcuccapcccagcaugcgcpaccccgcggccacc\n", + "guccgcgucgucauggcgacgcuccgagcpcgccggcgcuggcgccggccgaauccggcccpaaccaccuccagg\n", + "acggcauugacccuaccguugucugugaugcccggauuaagcaggaugcccuagacuucucugaccuuccucu\n", + "cccugcccugcuuggauagaggccuccgaacaggaguaaagaauggcuguugaacauccacaaggcaccugcaag\n", + "upcuuugugagauagcuapucgacuuguguggauucuaguagaacggagcugacccuauccgaacaggc\n", + "ggauuupcaagcggccuupcuuugugagauagcuapucgacuuguguggauucuaguagaacggagcugacccuauccgaacaggc\n", + "auuupcaagcggccuupcuuugugagauagcuapucgacuuguguggauucuaguagaacggagcugacccuauccgaacaggc\n", + "gacccuaccguugucugugaugcccggauuaagcaggaugcccuagacuucucugaccuuccucu\n", + "ggaggaaauuuggacacacagagagaugccaaggauacacacagaggaaagaccaugugagugcauagcaagaaagugaccaucugcaagccaag\n", + "gcgcaugcagcccuucccaagcacugguapcacupcaugcagacagcccaccagaapaagaaucaggagaaaapaugcaagaucccagag\n", + "augcagaacccapauauggagagccaauuguauuuguaaaacacuuagaauggugccugacacgug\n", + "ccagaaugcuggagcguaggugaaaggacaaaagccagacacauuucaacaugapacccacugacagauuguccg\n", + "ggcaaaccuggaaauuagcuaugccaaaggacuucagaaacuggcaagcaagcugagcaaagcauuacagaacacgagaaaaag\n", + "acagaugcagaacccapauauggagagccaauuguauuuguaaaacacuuagaauggugccugacacgug\n", + "aauagaucagcuucauuuuugaaaaguucuccupucuuucauauccagguagaagagacuucaucuuuauuuuaagaacucauccaaaag\n", + "uauaauaaaguauacaagaaccuaaaggaguuuucucaaaauggagagaauuucugcaaacaggucacaucuguucuucagcaaag\n", + "cuaucugcucuaugcaagcacuuagacaaccuaupaagaacaccguggcagcgugguccuguuugccugg\n", + "ggaggaugaggccpcuccpacaggccagaupaagcugcuguccacgcagcaaggcggcugcugapaaapagccucugcaucaccaa\n", + "ggcuggcggcggugagupccccaggcaapcggapcggaacuuupuucggcacugccpcggccggaag\n", + "gugcaupcuuccucacuuuuuuccucacgaagaggucucuggucuccccucucugagcacucugag\n", + "ggaccpcupacuguacacupccucagucccucaaauccpaccpcguccgcagcucggcuggccpacucccuucpacgcugaggaggaapaag\n", + "auuucccaagcugguuggugcaupcuuccucacuuuuuuccucacgaagaggucucuggucuccccucucugagcacucugag\n", + "ggccpcuccpacaggccagaupaagcugcuguccacgcagcaaggcggcugcugapaaapagccucugcaucaccaa\n", + "cgcuuccagagccagaacugagcccagugagagcgcacccupcagccuggauuccupuguccccggcagccacacacagcc\n", + "cccuauucaggcaggagcugcucuucupuaucgcgauccacuuaaggaugaggcagacuuggugacaagcuggucugagcag\n", + "aucccucggcgccccgcccggaaccggcgcgcgcguapcupaggccggcgcgcagaucuggcggugagcgcugccgccccpcccccagcc\n", + "aupagacugaggccguggcugugugucccucugagaguuggagcpcupcccgaauucgaccgcagcaggauucucucucauuucugagccccggagguggcagagcggcagacccgg\n", + "cccuccagugcccugguagccgccaguccccgccuggcguuuugagguuccacaaucaacuuuggcauguuuugacuggcagg\n", + "gcucccucaccacccugccuggcuuggcaggagucgucugagaapacuccuccapacuuggucccuagguccccag\n", + "gacacggaaguagcuccgaacaggaagaggacgaaaaaaauaaccguccgcgacgccgagacaaaccggacccgcaaccacc\n", + "gucaauauccaacacagccaaccuacccugugcagccuccupaauccaguauacccucagaccuugcaucuuccucaggcuccacccuauaccgaugcuccaccugccuacucagag\n", + "gugacacggaaguagcuccgaacaggaagaggacgaaaaaaauaaccguccgcgacgccgagacaaaccggacccgcaaccacc\n", + "acucucauguaagucaacaacauccupauupacacacuuucupcacugcuggccagucccaaa\n", + "gaaggcggcggcggccgcggaggagcaggacgcuugguccggacggagcucggcgcupaagaagccpagcuucccug\n", + "gaguccagcaagucugucaaucggacgugaacgucccgacgagacaacuugaaccucapcccucgcgccagccggacaccgcag\n", + "guggugcaaacgccccugcucuccggcgcccccugccpaagapaaggcggcggcggccgcggaggagcaggacgcuugguccggacggagcucggcgcupaagaagccpagcuucccug\n", + "cccugccpaagapaaggcggcggcggccgcggaggagcaggacgcuugguccggacggagcucggcgcupaagaagccpagcuucccug\n", + "cgcuuccggaagcpcgacucgcagcuccacgcgacgccgapcuccgcgccpaccpcpugcucggaguuucpaccgcacpaccgapcag\n", + "cuuuucauauucacguguacucuuaagaaagcgucuguucuccaaacuggcuuuccauucuccccguccuaaaug\n", + "uuucuuacauuaucuuuguuaacccauccgcuuuuguguauaauauuaaguuauuuuccacuacugcaauggcuaguaauuuacuuaggcucagaguuuuacucuguauggacagagaaauaggag\n", + "gcauaauccuguggcuucgcugucuucacccagcaccagcggacapaapcagagaaggccacc\n", + "cgcccucccuucuugcgccaggccaucaagauaaggcgccgcagagucagagaucuacaggaucccccgccccaa\n", + "cuagaaauuaacaacaacaaugagaagaaaugaaaapcagugacuagcagaagcucuacaaugaugauucauucau\n", + "ggcaguuapcaacuggaaggcupagcugaaaucaccugaagucucauucacucacaugucugaugguugauauugucuaucag\n", + "auucuuuuuugucuccuucucugcaagaggcuggcaccagaucaccuccugaguagagcagacauuccaaaggauguccugccaacaauaauggaaagcuggauacaacugaauauguaaaaug\n", + "guuccuaaaaguggaauugcuggaucaaapuaaaggcauaggcaauucuagagcauuuagauuuaaugugauggacaggaaugaaccaugaagccac\n", + "gaguguuugauuuuuaaauugugauauuccacuaaaugagaaaugaccaggacuucacagagauuucaugaaaggapccacaaaggaagaacccagagcaggccggugagaggcacucuaagag\n", + "gaguaagguggccacuuugacagucuucucaugcugccucugccaccuucucugccagaagauaccauuucaacuuuaacacagc\n", + "acuuugacagucuucucaugcugccucugccaccuucucugccagaagauaccauuucaacuuuaacacagc\n", + "aauccugaguaagguggccacuuugacagucuucucaugcugccucugccaccuucucugccagaagauaccauuucaacuuuaacacagc\n", + "agcuaaucucccuuuuaucagacagaaaagaauagccacuuguuugagaguagcauuuggcucccggcaag\n", + "agagcgcgguugaccucccuuucucugcucagcuccagcgucauuucggccucuuaguucuucugaacccugcuccugagcuagguaggaaac\n", + "agagauacagagguugupcpagacagaaagagagagagauccagagaccgagucuuacguugacacgcagagagaaagacgcagagacagacaaacaaacagauaggagag\n", + "gacapcccuccuccccuuauuuguaaagagcgccggagcggaucgcggaguuucaccgcggaccugucagagauacagag\n", + "augcaapucuccaggcuccauuucagcaaguugguuucaucaagaucacgaaaagaugcaugcguccccgagaccagagaggaguuapaccccgacacggagguggcaucag\n", + "ucacuucuaaguuugcggcggagagaauaaagcagaaagacaggaagaggagguggaguucuaca\n", + "acuaaccugcucugaagugagccaggcagcucuggccaucuuuucccagccacagaaucaggugaugguccagaauuaagag\n", + "guucugaagapucacucccucacuggcugccauugaaagaguccacuucucagugacuccuagcupcacuggaugcaguugaggauugcuggucaau\n", + "acucccucacuggcugccauugaaagaguccacuucucagugacuccuagcupcacuggaugcaguugaggauugcuggucaau\n", + "gagagcgaggcuacggagcaggcgagaggcgacggcgagagcuagagcpcgcagcguuapuggccgugcaapagccguggcccpcccpcgugcgagacggcggaagcag\n", + "aacuauacaugccugguguuapaauuuaauccaugagaagguuaggacaucuagugaccaaauggccauagaauuggccccpucucacugugagacgcaucccauaguggcuucag\n", + "aagccucccupccucuccapauucuugagcccuggcugacaaagaccaggaagaucugagauaccpaagccugugacugccc\n", + "cuuuuucguccuuuuccccgguugcugcuugcugugagugucucuapugauacgupugagaaag\n", + "gcuugcugugagugucucuapugauacgupugagaaagguaaucupcaauccacugccag\n", + "aaagaucugccagcauugcaaaugcccgcpaggagcaugcagugcacgcggugccuguggaccuggaacgcauc\n", + "ggacgcgcgguggccugacggucgcaaggauuacauucgccugacccggcccggcuugacccugcccpcgcgcc\n", + "cucugccucgguugugucccgcucccccgcacucupcgcugucccagccugcccagcgcugcccag\n", + "ccuccagaggcagaggacccagaccpccagcccugcaacuccuguapagcagugcccuggcuuccugcuccacggcuggag\n", + "cccgccucugccucgguugugucccgcucccccgcacucupcgcugucccagccugcccagcgcugcccag\n", + "auugguugcaaaaccuugaucugugaaagcpcguuuuggaagauaccggaaguagagucacggagag\n", + "accggaaguagagucacggagagguaggauccggaagupcugccucuuuaaauaacaaaaaucugag\n", + "cggaaguagcugauacucucauugguugcaaaaccuugaucugugaaagcpcguuuuggaagauaccggaaguagagucacggagag\n", + "gcagagucacgguggcagcauugagaguuggacacccpuccuugaagugaucucuaggccccag\n", + "aggccgcggcgcpcccaggagcggcaggacucpccggagcguggccggacccccacccgccgapcccapaggacgcg\n", + "uccpaggccgcggcgcpcccaggagcggcaggacucpccggagcguggccggacccccacccgccgapcccapaggacgcg\n", + "agcggcaggacucpccggagcguggccggacccccacccgccgapcccapaggacgcg\n", + "cgcuccpaggccgcggcgcpcccaggagcggcaggacucpccggagcguggccggacccccacccgccgapcccapaggacgcg\n", + "aaacauaauguccagcuuuccugcuuaccccucugcccuccacagccccaaauccgccaccauuccgugcugcpacacc\n", + "ggaggccgcggcgcpcccaggagcggcaggacucpccggagcguggccggacccccacccgccgapcccapaggacgcg\n", + "ggcgcggcgaaacuucccucuacccgcccggcccgcggcgcgcaccguuggcgcuggacgcuuccuccuuggaagcgccucucccucag\n", + "gucucaagaacuguuuugagaugcaggaauucaucuaauuuucacugccpcgaggugugagagcccuagcaucugaaaguggucgacuugcgaguug\n", + "gagcugcaggcgcggcgaaacuucccucuacccgcccggcccgcggcgcgcaccguuggcgcuggacgcuuccuccuuggaagcgccucucccucag\n", + "agcgcugagcugcaggcgcggcgaaacuucccucuacccgcccggcccgcggcgcgcaccguuggcgcuggacgcuuccuccuuggaagcgccucucccucag\n", + "guuacgaggaaauccuucaaaaugcguucuugugaaaaacgugagagugcaaggaaagapapauaggaagaaggaaagagaagcaaaag\n", + "cucccuguucagugguuucuccuggccuguucaguucaagcaacacuagcaguauuuuccacccaaugacau\n", + "aggagagagaaaggauuccccugugcuuggagcccgcacucpcgcggapagcggcggcaggcucucgcuuucggcacc\n", + "gcccauggapagugagaggcucaggcauggcggacugcaggucccgagaccugcccgcpaaggcagcuaaggccag\n", + "aucuguuuuguggaaaggaaaggaguggcucuacugaacaucugugauacccagcugcacauuggcauuugg\n", + "gauuaugagaaaaagcaauaaaggaagacaucaauucucaagcgaauaauuucuucuauagagccugcuaaacaacaccaacggcaagugaugagga\n", + "aggcugacaagauguuucccagugagcuuugccaggugucggcauauucgugaagucaccauggauacaaguucuguuccucaauuuu\n", + "agguuuuuaacugaagacucuaugcucuguaguucuuuccacaaagagcugacugauauuugaagaaguguuuucaucuauccaagaaaaau\n", + "gugaugcucccupccuccugaccgcgcccucgccupaggcpcpccpuucucucugugacgucacaaaggccccgcc\n", + "gaucaaucccgaggcugcugagagacgguggcgcgauupacagucgccapauggcugagcgugaag\n", + "auuugaagaccaggaaguugaucaaucccgaggcugcugagagacgguggcgcgauupacagucgccapauggcugagcgugaag\n", + "gaagaccaggaaguugaucaaucccgaggcugcugagagacgguggcgcgauupacagucgccapauggcugagcgugaag\n", + "gcacggapcaaccgucgacpcuuagcgccucaacugucguugguguauuuuucuggugucacuucugugccuuccuucaaag\n", + "gagucgcacggapcaaccgucgacpcuuagcgccucaacugucguugguguauuuuucuggugucacuucugugccuuccuucaaag\n", + "aagccgcgaagcgcpcgacccpucpcpccagguccgcgaggccgcggcggcagcugugcaggcccpagcagccggccpcgagccucgg\n", + "aguuguaaaauacaguuugcuguuuauacuucgcagccauucauuuuuuagugugaaguuuaaugucuuucauuuuuaucaguucuuuuuuucuuaugguuaagccaugugaaa\n", + "gcggcccgcagcggcggcggcagcggcggcggcggcuacagcagcuccgccggcagccgcpagcacggcgacgccagcggcgg\n", + "aaaaucagucaccauaacuuucuuuuuacagacaaaacaaaaccaaugaggapaauauaguuugaagcuguuuuguauuuuuuuccaggaggagaaggaccauauaauucca\n", + "ccgacgaccagcggccagacgcugcpagcacugcupcuggaggapcucgagcugcgaggacggcacggagcagcp\n", + "ucuuggaggaggaacuuuuuuuggucucugcugucuucuuacuggcuguaccacuuuugaagaagcucuugaa\n", + "augcupapcuggcggccucgacggcagcugcggaacuaggccgapacaaaggcuaag\n", + "ccgcgcgcggacacuguccccgcacgguggucccucguuggugcguggccugacauccggcuggaggccucpugcuccgaaagcgguaccuucpcccccccgcacccauug\n", + "cggaacagacaaagccagcgcucccgcccgcuccccgacuuaggauccgaugccggcagcguccupcccccguagcpcuggacc\n", + "gugcgcgcapcgcaggcgcgcpucccggcagcccgugagacgcccgcugcuggacgcpuagccgucugaggugccggagcugcpagg\n", + "guggauuugagagauaccuccccuccuucugcucagcugccuugcaguaauuaaacucuuucucugcugcaacaccccuacuguucuccguguauuggcuuuucupcagcag\n", + "agugcggccuuguagucggucaggaggaagcggccacggcagagccuggugccugaagaggagucggag\n", + "guucccgcaaggucgcuuugcagagcpagcgcgcuuaaguaacuaguccguaguucgapugcgccguguccuuuugcguugguaccagcggcgac\n", + "guaauaaccgcgcgcggcgcucggcguucccgcaaggucgcuuugcagagcpagcgcgcuuaaguaacuaguccguaguucgapugcgccguguccuuuugcguugguaccagcggcgac\n", + "auagcugagccccagcupuggaagcugagccapacagucacggaggaacaagaucaagaugcgcuguaacugagaagcccccaaggcggaggcugagaaucagagacauuucagcaga\n", + "gagccapacagucacggaggaacaagaucaagaugcgcuguaacugagaagcccccaaggcggaggcugagaaucagagacauuucagcaga\n", + "aauaccguagcaguaggcaggacaguuccaauucaacaaaaaccucuuuacccuggcacucaaaacuguaaugaugaugaacug\n", + "gauuuuaaacaauuugaaccuaaugacuuuuauuugaaaaacacuacaupaggauguaggacugupacccaucacuuacgaaaaaccag\n", + "gguuaugcccuguacuaccauuuugaggaucuggacuccguuuccugccuugcucuuuggaccacauugucaauucacaccg\n", + "gcgcccgguugcagcguggacgccggaugaguugcuuuuaggcuugcuggcccgcpcuguccaggcacgcgaggccccucag\n", + "gugcgcccgguugcagcguggacgccggaugaguugcuuuuaggcuugcuggcccgcpcuguccaggcacgcgaggccccucag\n", + "agcgcguugcaucaccuccgugcgcccgguugcagcguggacgccggaugaguugcuuuuaggcuugcuggcccgcpcuguccaggcacgcgaggccccucag\n", + "acuggaucccgcauuuucagcgcguugcaucaccuccgugcgcccgguugcagcguggacgccggaugaguugcuuuuaggcuugcuggcccgcpcuguccaggcacgcgaggccccucag\n", + "gcccgguugcagcguggacgccggaugaguugcuuuuaggcuugcuggcccgcpcuguccaggcacgcgaggccccucag\n", + "cuuuaagauuuuuuaaguuuuaccaguuuuccucaaagagaagaugaaguuacuucaagagaacugauuucugucaugugaguguag\n", + "auuuaccuucuaugaugguccuccuuuugcaacuggacugccucacuauggacauauacuugcpuacaauuaaagauauaguuacaagau\n", + "uacaccccucggcccuuuggaggaccggagagccggacgacgccgcagcccuupaguccagcgccagcuggcgaaaa\n", + "gaagcuucaucuuccagaucauccpaaapcagagguggccgguuguugcgacucauaaacaaccucuucagcacaacccgguuga\n", + "acuccgagcugugaccgcgcaccaacaacagcaacaacuccacugcgccpcugaggagcaggaauuaggagcucgcgaauaau\n", + "gccucucuaggccggcagcgccucuccuccaugguccugucugucagcgcuguuuupagcccgccggugaggccpccacgcucagacacuucgaucgucgagucugucacug\n", + "guccagcuggagacagccccgupccagccagcgcupccaggagcggccaccugguuccugcgugcuacggcccugupccupagcugccucugaggaacacgccgcag\n", + "acaaaupcuugupuccuupuggcapcugagcaupaaagugagcuucaggccagagaagccacaaaagg\n", + "agccccgupccagccagcgcupccaggagcggccaccugguuccugcgugcuacggcccugupccupagcugccucugaggaacacgccgcag\n", + "gacugauuucgaguuuccggucagguuaggccppugcgguccuggucggaaggagguggagagucpucaccaggccuauccuuggcgccacagucggccaccpcucgccgccguc\n", + "aauccauuccaauauauggccauguggcucuuuggagcaauguuccaucauguuccaugcugcugacgucacauggagcacagaaaucaauguuagcagauagccagcccauacaagaucgu\n", + "auuguauuguaggaggcauuguggauggauggcugcuggaaaccccuugccauagccagcucuucuucaauacuuaaggauuuaccguggcuuugagua\n", + "gaggcauuguggauggauggcugcuggaaaccccuugccauagccagcucuucuucaauacuuaaggauuuaccguggcuuugaguaaugagaauuucg\n", + "aaaccacauuugagaaguauuuccauccagugcuacuuguguuuacuucuaaacagucauuuucuaacugaagcuggcauucaugucuucauuuup\n", + "augcagcuaauauacccaguuggcccaaagcaccuaaccuauaguuauauaaucugacucucaguucaguuuuacucuacuaaugccuuc\n", + "auugccccuguaaccugucaaagaagagcuaapagcuuucpuuggcuucuuggaggcugcuuucuccuuuacuuggaag\n", + "gacgccugcgcccugccugugagcguguggcgcccgcuuucccugagccggcpcagagcgcapagcuggaggucggcgcuuccucucgugcuugguccacugacgcgcggccccgccgcgag\n", + "ggcggcpuggcupccggcggcggcggcgguacgaggcgcgcgcucpucccggucgcgaggaggaggagg\n", + "uagccaggagaguccpaggccggcaccccuaccuuccucauccccapagagccucccucuacucagugaccagccccucuccucggcuaagcc\n", + "ggaggagugaagguccucaucacaggcccguggcaagaagccagcaauaacuacagcugccuguuugaccagaucucagugccugcaucccugauucagccupugcugcgcugcuacugcccag\n", + "guugupaguggaggaggaagaggcgguapuacpcuggucccagaagauggcggaggcp\n", + "gcaguggagcucpcggaguugupaguggaggaggaagaggcgguapuacpcuggucccagaagauggcggaggcp\n", + "cugugauupuuauuauaccccugcauugacagacaucuaggagaaccacauaaauuuaaaagagagugguccaguguaaugcgguguguagcagucuuuguugguauaaauc\n", + "uuaucuguggccacaaagaaaguuauuugucucugucuuggcaaggcupaggaaaguuuuagcuaa\n", + "ggcauuuguccccgcgacagcaccgcugccgccgucucuaaggucgcccpucccaccgccgccacc\n", + "cuuuuuugcgccggcugugacaagcgcugcggcauuuguccccgcgacagcaccgcugccgccgucucuaaggucgcccpucccaccgccgccacc\n", + "acggacuugucugaggaaagacaggaaagcgccagcaucuccaccuuccccggaagccucccuuugccaggcagaaapuuuccc\n", + "aguaggacugauucuucccuaggagacggaguucuccuuucaucaucuuccccuucugugcaugguagccgcuugaacuugccccuccaagagucaaggacaagaccacccc\n", + "ccccacccagccccagccccaggaggaggagccugucuggauggacgcagccugaacugacccacaaacagaccaaaaaagucacucucaaagagcucucg\n", + "gcacacagaccccagcuuuacaaggaccccagcuccuuaacacagaucccagcuccgaggaaacucgucccccccacguuaauccugaccgacuuugccac\n", + "agccccacccagccccagccccaggaggaggagccugucuggauggacgcagccugaacugacccacaaacagaccaaaaaagucacucucaaagagcucucg\n", + "guuguugugucccagccuucccaagcuuccaggugucccagaaacccaggaaaucgagacucaugacucccagagaggauggcaucuagaag\n", + "guucagccucccgcgcggccgccagaagccgcgguucuaaagcugcgaggcccgcggccgccgacugcugcgag\n", + "caccagcgccuugagcguuuuccugccgucuccggacacagcuggcccupuggagcuucucagacuucapagccucagaccacgapaaucuuguucagcugcag\n", + "pcucuggugaupccccucuccuuucagcaggagaagcuupacaucugcuucucccuccgcuauguccccacggccpaagcucaccgucaucguccuggaggcuaaaaaccugaagaag\n", + "cacupagacaaccagapapcagcagccugaagcggagagacapaucupacgcgagacag\n", + "gcguggccucccguagacucapcucaaguuggacgupcccaaaucuggaccggcupuuugcupugucuugagguccccuccaccgucgucuccgaaucccccucc\n", + "acaguucugcagccacucgguacggcgcuaacgccgcgagguagcucggugcgucucgcaguaccagugcgaaccuuupcucuccagguccgagauccuagucuccugucggcucugaggagg\n", + "gcuaacgccgcgagguagcucggugcgucucgcaguaccagugcgaaccuuupcucuccagguccgagauccuagucuccugucggcucugaggagg\n", + "acucgguacggcgcuaacgccgcgagguagcucggugcgucucgcaguaccagugcgaaccuuupcucuccagguccgagauccuagucuccugucggcucugaggagg\n", + "cucacuuccgcccaggugaggcapccgacaccgagcccgcccgacccpcucccaccugcuccuccagcgcaccag\n", + "acuuccgcccaggugaggcapccgacaccgagcccgcccgacccpcucccaccugcuccuccagcgcaccag\n", + "agucuguggugaggauuugagcugcguccagcauuggauauuugucaggaaugcagauacccugaapaacacaaca\n", + "uapaggcgupcacuuggaguugucuuaggacugaugucugaauuaacuaaaugaacuugucugguuugcagagugcug\n", + "pugcgccuucccggcgucuapagcgaaggcugagguggcagcggcaggagaguccggccgcgacaggacg\n", + "ccuuucgaaaguuguupaacguggacuuucccaacaauuguguaugcgcucgaucucacucagupagccgccgcccuggapaauuucacaauagccug\n", + "ucagaaacuguuaguuggcaaaggauguaccaucuccuauuaaacpcaaggacaaguucccuuuucugag\n", + "gcuucuuuggaccuuggagcacacagaggauucuacuuucuuuaaaacuuuguuuucaggcaauuucccugagaaccguuuacuuccagaagauugguggagcuugaucugaag\n", + "ugucuuupccucuacuguuacaacaccaagauuaucacacacuaauccaugugaauguguaccupaguuaagguguuaaupaaggaacuaaucucaccucucuccucagcuagcag\n", + "gcgcuccuccguacgagaacuaguuuuguuccgugcccucuggacuggaaccuuuuggagagaacccccggcaggaccaaccccgcacccgccagcaccgcggca\n", + "ggaagcgccugcgcgcgcuccuccguacgagaacuaguuuuguuccgugcccucuggacuggaaccuuuuggagagaacccccggcaggaccaaccccgcacccgccagcaccgcggca\n", + "gaacuaguuuuguuccgugcccucuggacuggaaccuuuuggagagaacccccggcaggaccaaccccgcacccgccagcaccgcggca\n", + "cgccuggapaucuaccaucucggacucccgacccgccgccggcuccggccgcguuucccpuaaap\n", + "pacuaggaagupaaagagcucuapaaccugapcuupuggaagacuggagagccaggaggagcaaggagcaggaagcaag\n", + "acacgugaguuguuuccaguuuuggugacgaaugcccaaauucauaggcgaugauaaauaaugugccagacguugaugugcaaguuuuggugugagg\n", + "guucagucauccuucugucucccucupuuuccaagaaucuuaccuuggaacuccaauugaacugagcccupcuugucugcugaccuucucaaca\n", + "agaguucucugccauggcupacuaggaagupaaagagcucuapaaccugapcuupuggaagacuggagagccaggaggagcaaggagcaggaagcaag\n", + "ucauccuucugucucccucupuuuccaagaaucuuaccuuggaacuccaauugaacugagcccupcuugucugcugaccuucucaaca\n", + "acagaguucucugccauggcupacuaggaagupaaagagcucuapaaccugapcuupuggaagacuggagagccaggaggagcaaggagcaggaagcaag\n", + "gaacuacaacucccagaaggccgcgcggaagcggaacgugaaccapaggacuuccggacgccaacauccpccgcgcpaapagacgupuagag\n", + "ggcccuuccaccuuuugupcacucaaguucggaccucupaucggcgauuccccucuggccapcugguuuua\n", + "aagugcugucugugauguuuggcaagccugguuuauauccaucuacaagguuugcgaacccauguugcc\n", + "gauuuuuuuuucugcuacagaacaacucccuugguacaauaaaaaagacgaguauuuacuuuucauugaaag\n", + "uggagaaccugaaaaggaaccuggaaagaagcagcuggaaaaggugagaggaaaaccuagaguguguguuauccugcaagccaauugag\n", + "aauggagcuugcuugauauuucacuagauaaagaauuuaaggcgaguaucuaucuuuguucuccuuggcaacugagagucugcccuuggaaacaucaggcacc\n", + "auuuaggaaccucucagaauaaaaucuggaagccuguuccauuugcauuaugagauuugcauuacaaugcag\n", + "gcugaagugcaguagugcaaucauggcucauugcagucucccagcuccucggcucaagugauccuccugccccagccuccugaguagcpagcuacag\n", + "acacacaaacacaggauacugccagaaacupcaagaggcuguuugugaaucucagaaggcacccg\n", + "gaucuugcucugcuguuccugcucaggcuggagugcaguggcgcaaucauggcucacugcaggcuugaccacccaggcucaagcaguccucccgccucagccuc\n", + "pauaggagugacuuaaauucucccagucgguggagguauaaauaacuacauguaaaauuaaugcaguucccg\n", + "cgcgcgcgcuccguucuccgugacgcacacuucccccuccccuccgccgcgccupccucugcauugcccgacuccguaggagcgcpcggcuccugcucuuccuggacuccugagcagag\n", + "ggagagucccaccucuaacaucuccuguaggccuggcaauggcaggcaggaaagacagaggaaggaaggapagaapaaggagugaaggaaggagugaaaaag\n", + "gacuuucggcgccguggcggaauggcggcuuccaucucugaggcgagcgacgcuauggaucccacag\n", + "gacgacuuucggcgccguggcggaauggcggcuuccaucucugaggcgagcgacgcuauggaucccacag\n", + "gaugacgacuuucggcgccguggcggaauggcggcuuccaucucugaggcgagcgacgcuauggaucccacag\n", + "ugguuugcuaagaaggccauuuucaacucuccacuggaggcugcuauggcguucccucaccugcagcagcccagcuuucuacug\n", + "guuuuuguugaaauguggcuucaucacuauuccuuggagauguaucaaaaaaugcaguccccucaugccaag\n", + "cuggagguucugcacuaccgacucagugucuccagcgcccucuacagccccgcccaacccagccuccaggcccuccacgccuaccaa\n", + "auggagucucacuccguugcccaggcuggaaugcauugacauggucucggcucacugcaaucuccaccucccagauugaagugauucuucugccucagccucuugaguagcupauuacag\n", + "ggcugcugucccgagguucguccagcagaaacucuaccucuucuugcagcauugcuuuggccacuggccccuggacgcaucguucagagcu\n", + "gagcgucacgccagacagcggcccgcgcgccuucuccucggcgucggccgccgccgccucccagaaccuccucgugcccucgcgugccaggcccgcggcggccgaaauccgcg\n", + "agauccgccggccgcggaccpcugccucggaaacacagapucuucucucgcccugcauauaauuagccugcacacaaapagcagcugaauggagguugucacucucuggaaaapugg\n", + "ccgcucucugcagcugcccpcgcgaauggcaggcuguuuccgcggaguaaaagguggcgccg\n", + "caucuaacauggaccaaaucaccaucucuuugaucuuuccguggcugugaacuuucuaugcugcccagcuuucugcaugcuuagag\n", + "cccuccccgcugccgccuccuccupcupcccgcggugucucguccccucgcggagccgcuccugccgccgccgccgccgccuccucauucauccucgugcaccauaggcggcacaggcaccaag\n", + "gagauuccucggcpuaggcagcggugcupcaugcucagupcaggacccguuagaguggcga\n", + "auugccguuuuugcucagaaucgcgacuaaggcuuuuuuuuuuucucccucugaacgguuaggcu\n", + "ggccugcacccuagaauaauagcugaaggauuugaagcugcaaagauaaaagcacuugaaguuuuggaggaaguuaaagugacaaaggag\n", + "gcauugccguuuuugcucagaaucgcgacuaaggcuuuuuuuuuuucucccucugaacgguuaggcu\n", + "cucuugugcaaucgauggcucagguuggcugcgcpagcggccagaggcucgcuggcgcgcacgccgcggaguc\n", + "guauuccuggaguggagagccacucuuuuugaccugcccuacaucagaagucaccgagcucccagccugcagccaguguggaggccaaaggauauuugaguuucagcuu\n", + "guccccgcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggagaug\n", + "gugugauuuguccagagaaucuuuccuaagaggaaaucccagagaagcaggagaaagagaaagaa\n", + "gcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "uguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggagaug\n", + "agcuccacuuccuguccccgcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "acuuccuguccccgcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "cuuccuguccccgcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "gcauauucucacgaugcaggugugauuuguccagagaaucuuuccuaagaggaaaucccagagaagcaggagaaagagaaagaa\n", + "guaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "gcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "guccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggagaug\n", + "uccccgcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggagaug\n", + "acuuccuguccccgcggcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggagaug\n", + "gcucuguguccccugcuagccguaggucgugugacccgcaggcaccpagauccagaagugaaacgccaggcucucuggaggccaggag\n", + "ugcccacgcgugcguucccggccucuupacccgagcggcggaccuccggcuccuuccccugucgcgguugccuccagcgcpccggaggaaggagucucc\n", + "gcugaagcgcaggacgcgccgccgcccgcgcucaccgccguccgcgccagccgccccgagccgacugcccuucugcccccaag\n", + "cacccgagucucacgcgagugcgcugccgcgaggugucccugccgcagcccccgcccgcccgcagagcuuuugaaaggcggcpaggcggcgagcgcc\n", + "aguaacugagaccucaccgcguugacccagcaccapcucgcpucccgcgapucucgguagccgcgcgcccagagacccccgccgcggcccgauucucugagcgccagac\n", + "agucggaaccuccuccucgcccaggcgcgcucggcccgagcggcggcggcggcggcggccgaggaaaaaag\n", + "gcaacggccguuagaggagcugapapaaccaccgcucaccgcagacgugguggcugcagucagucuucccgagugapauuucgccgcccgcuuucaggcccgu\n", + "gugcaacggccguuagaggagcugapapaaccaccgcucaccgcagacgugguggcugcagucagucuucccgagugapauuucgccgcccgcuuucaggcccgu\n", + "agcucuucucugagccuguuppapappcguggaggaacupuucgcpagcacgagcugcagcaccacuuccgg\n", + "gagcucuucucugagccuguuppapappcguggaggaacupuucgcpagcacgagcugcagcaccacuuccgg\n", + "cucucgcupucgcucpucggcuucggucgcuaccgcucccgcucugccacccccgccaaccgccgcucpccuccgucgcugccgcgucgcuuucucgcuccuuggaucgcacauccucccag\n", + "cccpacupcugcggcgguuaguccucucccggccgccgucgccuccgacauauugcccgcaggagcugcggcggcgaagcggagagcaccppaggag\n", + "gauacccpacupcugcggcgguuaguccucucccggccgccgucgccuccgacauauugcccgcaggagcugcggcggcgaagcggagagcaccppaggag\n", + "ggcugauacccpacupcugcggcgguuaguccucucccggccgccgucgccuccgacauauugcccgcaggagcugcggcggcgaagcggagagcaccppaggag\n", + "agcccgcpccaacgcggauccaggcccgacuggcpaccgccccggauuccccgcpccuuccuagccgcc\n", + "guccggaacagugucucaacuggccaggcgguggcaguggagcugcuucugacccugcagcuggugcucugugucuucgcuuccaccgacagccgucagacaucaggcuccccggccacc\n", + "gupucuacauccccuuucagcagccccaucaccuccgacgaggaauaccugagccccccagaggaguucccagagccupagaccuggccgcgaacccccacc\n", + "auucaucccaguagaacgccugccucuuuagugacuacagaccucacuucccuucucuggaguuuuggagucuauuuucuucauggaauuuugcuaggaacaaaagaaaagucuaacucc\n", + "acucccccacccaccucguccgcucucuccuccuccuccuccucuuccucucuggucuccucccuccuccpcupuugcaa\n", + "gagupcgccagguggaggupccapuugucaapagcacgaaapucgcgguguguccggcaaggacugg\n", + "aguagccgccugcuaguggcgcugcuagccggccggcgcaggcugccgagcpugagcgcgcaggccaggccaaagcccugguacccgcgcggugcpccucagucugcggcc\n", + "acacacucuuuuacguuauuuauaaaagagucucacucaauggaagcuggauuuccucuccuguaaaaugag\n", + "cggaagucuggaggacgcugapcggaggcpagaggcgagcucgcgaugaguggucucggcaggcucuucpaagg\n", + "acgcgccuguagucccagcuacupaggcugagacaggugaaucgcuugaacccaggaggcggagguuguagugagccaagauugcacca\n", + "cuauauucauccaacaagccauaaagccauaaugugguauaacauccuuuuugagaggugaauauuauuga\n", + "cuccucuuagaagcuauucucuucucccugaapaggcaacacuguccguucgccugacuggcaguguuuuaaggacccaucgcgcuugacpaaagucag\n", + "auuaaaaaucaagaaauauaaaccagauguagcaguuucuugacauggagaaccaagcccauaauacgaup\n", + "uugaguuucguuccagcuucuccucuuagaagcuauucucuucucccugaapaggcaacacuguccguucgccugacuggcaguguuuuaaggacccaucgcgcuugacpaaagucag\n", + "ggaaaaupagugacuguuaaugaguaucagguuuccuuupaugaugaaaaugcucuggaauaaaguaguggugauguucaacuuugugacuaaauugaaaacugcuggauuguacacuuuaa\n", + "ggcccaggcggcpagcgcggcggcpuggcpccccuupcpccuggcpcpaggugacauacgcgguccugcgcccucgccucagaccucucpcgagcgcggcgcagcgcag\n", + "ggagcggaaagagucpcggagcaggcggcugcuugacagcugagagccgagcpcggcgcpcagguccacpaagccuacacgcccaag\n", + "guggaauucaagucaccaguggccaaaguacccuccaggugugaagaguugcagguccuccgaggagccpagcugcaag\n", + "gucpcggagcaggcggcugcuugacagcugagagccgagcpcggcgcpcagguccacpaagccuacacgcccaag\n", + "apccaaggccgaggcggcagcggcugcgagaggcggcggcacgacgacggucccucagcccagccacc\n", + "paupccpccapccaaggccgaggcggcagcggcugcgagaggcggcggcacgacgacggucccucagcccagccacc\n", + "cggcuacgcpaupccpccapccaaggccgaggcggcagcggcugcgagaggcggcggcacgacgacggucccucagcccagccacc\n", + "acuuccuguguccacggcugucgcgagagcccpcgagupccucugcucgupugguucucguggaggucagcucccgcgugucuccgcucgacapugcuupcag\n", + "acccacuccucapcagagcaaapugacacugcuugagaagugcuggugcuagaucapcapaaggaacauauaagccaagcaacauccacagcugcucccaaaga\n", + "ucaagagaaagaagcacugaagagucauaauuguguccugauuuauaaaucggagacagapagacgaaaaccacacuccagaaaguagcuuaaucggacucacuacuaag\n", + "gaguguucugapaagcaaggaggcggcggcggccgcagcgaguggcgaguaguggaaacguugcuucugapagcccaag\n", + "gaagcaaggaggcggcggcggccgcagcgaguggcgaguaguggaaacguugcuucugapagcccaag\n", + "agaugccaaaggaagccauucuucuggaagaagacuuucuccugaaagccuccuggaggcaaaguucuggcagaacgaggcaauuucccucccugcaggcggaaggaaggcaauuagagcgg\n", + "agugcugcaagaacupugugacucggaaucccucccaaccacuuccggcgcaaguggcuucugauaauc\n", + "cacuuugaguauaucaucccacugucuccuggapcaagauucagccuuaapuucccuuguaugug\n", + "uauguggcugagcugcuccaggaccagcggaagccuguggugugcaccugcuccaccguggagguccaggccgugcuguccgcccugcucacccggauccagcgcua\n", + "ugcaggucpuggcaccagcugcuguccugaggcugcacuggagccgcccgcapcuucugccpcucaggccuucucuccagcucgaggcucaguuuggcccaggcuuugccugcupcgu\n", + "uuccucugcucuggcagcagaucucccagapagcagccugaccacaucacuggcccagaagaggaggcgucugucccccagacuagcugaaggaaaggcuggcuuggaug\n", + "guggcuccauuuuccauuugagcucaaauauuuugcugcuuccucuguagcugccagaccugcucuugcugcugcucag\n", + "aaccauccaucccaucapaaauaugcaacaugcuucaaagaauaagaagagaacuuupccag\n", + "uagagacpuuucaccguguuagccaggauggucucgaucuccugaccucgugauccgccugccuuggccucccaaagugcupauuacag\n", + "agagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "ggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "acuccgguggaggcpacuuccuacagcacuuccggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "cuacagcacuuccggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "cagcacuuccggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "ccggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "uuccggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "uccggccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "agagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcaggugagcuucagagguucpagcuuucggaacgagcauuccuggccg\n", + "gccagagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcag\n", + "gagccucaagcuucgcugcupcaguuggcuggapcugcugcupaacaccuggagucuccgcpcaggugagcuucagagguucpagcuuucggaacgagcauuccuggccg\n", + "cuaguagcuguggucpcucpaccggcugccaucuuagucuapacugaggagucgccgccgccccgagucccg\n", + "guaccaugcauuucacgguggccuuguggagacaacgccuuaacccaaggaagugacucaaacugugagaacuucag\n", + "gcuggaguacaguggugugaucucggcuuacuguaaccuccgccucccpuuccagcaauucuucugccucagccuccguaguagcupacuacaggcgcgugccaccacucccg\n", + "ccgcugcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "apagcaccgcugcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "gaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "accgcugcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "cuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "pagcaccgcugcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "gaauguugaccapagcaccgcugcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "gaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "aaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaagauggaggagccggaggaaccggcggacagupcagucgcuggucccgguuuauaucuauagucccga\n", + "gcugcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "gcggccgaucagaggagcaggaacuggaacccuggccgaguccgaaaaaagccagaucuggaagguggcugcggaacgguuuuaagcggaag\n", + "cucagcuccuggacgugccacagacagaaagcauaacauacacucgccaggaagagccuuugccugacucapcagcucagagugup\n", + "agugcupagaggugguagagacaagagguuugucucugcagaaugaccugccucaggapcuucaapaacgupagccaggacaggcagcagguggaacag\n", + "aagagacapaacgucuagccgccapucccpaggcggcucuguaccagacggacuauacugagagccuaugacaauagccgaag\n", + "ggcgaccugaggucuggaguguauccucucaapagcaaguggaucccupcagagaggaagcuucuaguguacucuuacuuugaaaag\n", + "gagacguugacauuuapauguggccauagaauucucucuggaggagupaaugccugaacccugcucagcagaauuuauau\n", + "guccucugcucgcagaggcccagccucuguggcccugugaccugcagguauugagagauccacagcuaagacgccagguaccccggaagccuagaaaug\n", + "cggccgcggcpcggcgcpaaccpccccppagucggccpcugcugcugcugcugcuccag\n", + "gacgcucugccccgcagcpcugaaccugaaggaggagccgcugcugcccgccggccupcucagugcgcuccugg\n", + "gcucuggcggcugucgcgacpuucapaauauuuacupccucuccgcucccucugcucuuggaggugcc\n", + "ggcugucgcgacpuucapaauauuuacupccucuccgcucccucugcucuuggaggugcc\n", + "gccuuagguggccuuccgcucuggcggcugucgcgacpuucapaauauuuacupccucuccgcucccucugcucuuggaggugcc\n", + "cuucccggccagacggcpcaagacagcupuguacagcguccucgaaaccacgagcaagugagcagauccuccgaggcaccapacuccagcccaugcc\n", + "cupuguacagcguccucgaaaccacgagcaagugagcagauccuccgaggcaccapacuccagcccaugcc\n", + "agagcccccuggagaaggagcucucuucuugcuuggcagcuggaccaapagccagucuupcgcuggagg\n", + "agccuggccagagcccccuggagaaggagcucucuucuugcuuggcagcuggaccaapagccagucuupcgcuggagg\n", + "gccuggccagagcccccuggagaaggagcucucuucuugcuuggcagcuggaccaapagccagucuupcgcuggagg\n", + "gcucaagugcccugccuugccccacccagcccagccuggccagagcccccuggagaaggagcucucuucuugcuuggcagcuggaccaapagccagucuupcgcuggagg\n", + "gcucuccccaaggcccagccugcagagcugucuguggaaguuccagaaaacuaugguggaaauuucccuuuauaccugaccaag\n", + "uugccgcugccccgugapcugaaggccagaucgugcugucapacucaggcaaggcaacugapcccauuugcu\n", + "caaaaggagaaaauugucaucaaaggauauuccagauucuugacagcauucucgucaucucugaggacaucaccaucaucucag\n", + "cuccugcccaggacccgaggagccggccaccguucagaaggccccagcuugaaggccuggagagccgcccagcagcacaacacapaagcuupag\n", + "ggcagcuugaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "uugcaaaacagaaccacugauuccuuccugcuugacaagauugagucgcuaucaaggagcugcccgugcuuuggaaaugguccaaaucgacgaggaacugccaaggagcccccucagaca\n", + "gcagcuugaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "ucaaapuacuaugucccucugccgugcgacuguggaaugaagaaauagccccaggugaauagagcguuuguccuugacuacccaagugagaagucagcagagccupacgccau\n", + "gugccugcagaacuacauuccugcccacaguuuaacccucuccugcccagugugccgccagaccuccauccugcccgagaaapuggccgcgcuccagaacaauuucuucaucacaaaccug\n", + "agcuugaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "aagaaauagccccaggugaauagagcguuuguccuugacuacccaagugagaagucagcagagccupacgccau\n", + "pcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "aupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "auucauggacauucuucuuagaaggccuagugcuaagucgcaguugucaapaaccgcgugucuggapagaacaggcucuccggaguuucccpaaaccaccccccgcagaggcag\n", + "ggcagcuugaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucg\n", + "gaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "aagauccauugguaguaugcucuccagcucccucccucugugacuuacaccuucgcuagucauuugaaagcuucugupagugugug\n", + "ggcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "gacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "cagcuugaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "agacagcagcucuugcucacacagcugauaggauuaggagauggugcuuugucagcccugauugagcccaagaaaacccccugcauacacag\n", + "gcaucaacaaauauugacuggaucaucuggaccugacuuagcugcccuuuggaaaguucuguucaaucagcuggauagagcuguuuguuuuccucaccuaacccucacagcuauccuagag\n", + "uauuuaaacaagucaccaguccuugacuccagaacugaagcuuuauauguucuuucuauuuggcugagccaguaauuuuugauugcuucuucuucccaagag\n", + "auuugacucuugagcuuauuuaaacaagucaccaguccuugacuccagaacugaagcuuuauauguucuuucuauuuggcugagccaguaauuuuugauugcuucuucuucccaagag\n", + "cccgcgccggcucagcgcagucuccucgcuccgugcucgcaggugccuccuccuggacggcggcagcggcggcgcgaggagccggcpcagcggcgcg\n", + "augacacaggcuguccuagcagccagucagugucuccugugaagacacccucagaugcuggaaacagccccauuggcuuuugcccuggaagugaugaaggcuucaccagaaagaaaugcacgauugga\n", + "gugccuccuccuggacggcggcagcggcggcgcgaggagccggcpcagcggcgcgaupccccuccgcgagagcaag\n", + "uuucugaugcaaccccuuccaaguagaauccaucgcagccuuucagaucccggaacccagaggcugugucgguccugacgcacuggcuuggcupcuccg\n", + "augcagaaggcucagucuccauggauaccccacucugagacuguacucuacugagauaugagcugcacacacuguauuucugcaaaagacauaccccagccugugcupaggcuguuugcagaggca\n", + "gugccagaugucacugagagugagauccupaagguuccacuaaaggaguccaaggaaaugcagagcauaauuugugagcagagcaaaauccaauu\n", + "cugcuccaggaggcccagccuguguggcccugugaccugcagguauuggagagccacagcuaagaugccaggaaccccuggaagccuagaaaug\n", + "gucucucgcugccgccggaguuuccaggucucgacuucacugcucuguguccucugcuccaggaggcccagccuguguggcccugugaccugcagguauuggagagccacagcuaag\n", + "aggucucgacuucacugcucuguguccucugcuccaggaggcccagccuguguggcccugugaccugcagguauuggagagccacagcuaag\n", + "ccggaguuuccaggucucgacuucacugcucuguguccucugcuccaggaggcccagccuguguggcccugugaccugcagguauuggagagccacagcuaag\n", + "aacagccgccuguugagucuccuccagaucgcagcugaaggaucuguugagcgcuucaggaaaggcggugagauccg\n", + "gcgccgagccccauucccccaccucuccagcucgcccucugagccucccgagcccucucuccauuucccacaauugugcug\n", + "gaggcupaupuuugagagucugagaaapcaagagaggagauaagcagcuuaaagcagaguccap\n", + "ggcauuugcggccggcgccapuggagaguugugcgccggucccupccugagcuccggcuccggcupcgccugcgaugucucaag\n", + "aguucpugucgaggaagupcggupuggupuggupaauaagccccugaagapagcacugauggagugag\n", + "ggaaggauccuggaggaccaaaguucpugucgaggaagupcggupuggupuggupaauaagccccugaagapagcacugauggagugag\n", + "pccagccuccgcacucgagcuuugauuggcugacucuaauaagaagacgccacuapcpcgaagapcgcaagcucauugcguuuugagucucpaccccuguuggagagacu\n", + "gaccccuguuggagagacuauggcgcucaacaagaaucacucggapcggcggagugaucgucaauaacaccgagag\n", + "gucuuucaacuccucccagcupacacugcaccpaggcagcacggauuccugugucaucaag\n", + "aaagcucccagugaggaacuggucuucuggagacucuguguggcauagagugauucaaccaccuuaagaagaccucuggcuuuccuggaacacag\n", + "aaagagcuggcugugcgguggaacuuggaagagacgacgucupagcuuuugcugagcccapagaggcgucccucuggcugcugcuccagcucuggcagacacgccaagcuuugag\n", + "agcgcagagcgguuuggucguucguupcggugcugguuuuucgcucgucgacugcggcucuuccucpcagcggaagcggcgcggcggucggagaaguggccuaaaacuucggcguugg\n", + "uucguupcggugcugguuuuucgcucgucgacugcggcucuuccucpcagcggaagcggcgcggcggucggagaaguggccuaaaacuucggcguugg\n", + "aagcaaguguggcccucguggacaaccuacgagccuuapacacaaaaggcuuccugcgcaaacugcacggaaucuccugacaggacuucacguuaaucaucauucauag\n", + "cpaggcccggcggupccaggaucuguuccuccccccgcagcccuppcggcccpugagcgcggcggccuuaucuucpcgucuuucuuaggugaaagaaa\n", + "guucguupcggugcugguuuuucgcucgucgacugcggcucuuccucpcagcggaagcggcgcggcggucggagaaguggccuaaaacuucggcguugg\n", + "gagcgcagagcgguuuggucguucguupcggugcugguuuuucgcucgucgacugcggcucuuccucpcagcggaagcggcgcggcggucggagaaguggccuaaaacuucggcguugg\n", + "gcacupuccucggcgcggaccgcgcagacugaauaauaaaapagcggcgaagaggcaggaagacaagacc\n", + "aggugacugcgcggcpcuguggcugcggagguugapcguccgaggcgcggapcuggcupcaggapuuggcpcagcapccgcggcc\n", + "gacugcgcggcpcuguggcugcggagguugapcguccgaggcgcggapcuggcupcaggapuuggcpcagcapccgcggcc\n", + "aggagcgcaccggaagcgcccggcuggaggcgcggcggcapcupcggcggcggcggcggcgguc\n", + "gguaguguapacuucggcacgugugucauuccccpauuucuguaguaacccugcuucuggugaacuugucuggccggcauucauuuaaggccuaagg\n", + "uggcggagaggcugagaauuuuauacuugcuugcucgaaagcaccccaaauaagaugauccacgccaacaccuccccuuuacag\n", + "gaccgcagcagagccggapupcaggcgcpuccpagacgcgcpaaacgcgcggagccg\n", + "ugucugcucaaucaagucaaauacugaacaacuuccuggcggagaggcugagaauuuuauacuugcuugcucgaaagcaccccaaauaagaugauccacgccaacaccuccccuuuacag\n", + "gugucugcucaaucaagucaaauacugaacaacuuccuggcggagaggcugagaauuuuauacuugcuugcucgaaagcaccccaaauaagaugauccacgccaacaccuccccuuuacag\n", + "auucuaagcuucauggcacupacuugagacucguucagcguuuucucucuaguaucuuaaacagcggcaagucaugcgugacccgacauaggugcuag\n", + "ccguauaggugapacuugaucaggcucugcccugucugacagaacucauucucaccaauaauagucucguggaacug\n", + "uauccuaagaaauccgguaaccaauaagaagcauuacagauuguaugugauuuauaaaguuccgcaagucagaguacuggauuuccagaaagugaaacuaaaa\n", + "gcacgcupacgucucgcuggcpaggccacpcuuuccacagcgcpaacpaggcugcagg\n", + "cuuggcguucacugcaagcuauaagcucugcaaguggugaccccgacgugaucgccuugaaguuacgcuugaaggaggaaaacucaucaauuuucpaaucccg\n", + "uuuuuuuuuuuaaacuaaaauggaggcugguuucuugccuuaaggagcccauugccuuucccgcugaagucuag\n", + "uucccuccagcugcagagagcuucaguuugucuuuuuuuuuuuaaacuaaaauggaggcugguuucuugccuuaaggagcccauugccuuucccgcugaagucuag\n", + "caguucccuccagcugcagagagcuucaguuugucuuuuuuuuuuuaaacuaaaauggaggcugguuucuugccuuaaggagcccauugccuuucccgcugaagucuag\n", + "aguucccuccagcugcagagagcuucaguuugucuuuuuuuuuuuaaacuaaaauggaggcugguuucuugccuuaaggagcccauugccuuucccgcugaagucuag\n", + "gcggccgcpcgcgacggccpcpcgcugcugcugcpcaggcggcggcapcggcggcggcggcggcggcccgcuccagcc\n", + "cgcgcgcuaauugccuauuggccugugcugccggcucgcagcccpuggacccgagccacgcccccuggagugcgccggaaagccpcgcgcuagagcucgcpag\n", + "cgcuaauugccuauuggccugugcugccggcucgcagcccpuggacccgagccacgcccccuggagugcgccggaaagccpcgcgcuagagcucgcpag\n", + "cuuucucuccugcucucgcggcpaacgcpccuccguguucugcugucuucaucagcgupccgcgg\n", + "cuagaacuaugagcccgaggccuuccccucucccagagcgcagaggcuuugaaggcuaccucupaagccgcucaccgucggaagcugcpagcugaaacugcgccaucgucacugucggcggcc\n", + "cucuaaucugccauuuucugucccugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "aaucugccauuuucugucccugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "ugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "ucuaaucugccauuuucugucccugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "agucpcuapapaaacaaucccgcggagccauauggagapcaggaggugucuagauagug\n", + "ucccugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "cugucccugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "ccugagugagucucuggcgucccaaauugccuguuuuucucgcaggcucuauuccguucgcugguucgccaccucapaacg\n", + "gacuuccugcgcpcccgagccgcucagucucccugcucuccguggucccggcucgcguguagcggcggcggcggcgucuccgugaggaggcgcgcpcc\n", + "gcccgagccgcucagucucccugcucuccguggucccggcucgcguguagcggcggcggcggcgucuccgugaggaggcgcgcpcc\n", + "agucucccugcucuccguggucccggcucgcguguagcggcggcggcggcgucuccgugaggaggcgcgcpcc\n", + "cgugacgcugccccgcccccaggucggagagaucuucucggcggccggcgccgccuucacgaagcucpagcugacg\n", + "agcaaacgaggccccugagagcuccaccuaguucacaggauaaaaucccacagcagaacucggagucagca\n", + "cuaaaagauaccuacuuacagauaauguggugaaauuaaaagaauuucaacaaaagaaaguggcuguugcauguaaucuuucuggcacuaaag\n", + "aaacguauuuuagaaacuugaaaaagaaacugacccagaacaagcucaucuugaapaguugauaaccuuacuacauuugugugagucucpacc\n", + "ccgagacaguauggcugcugcauuucggcccucgaaucgaguucuccugcaggcgcugcagauuuugguguauccupupaggcuccggcucugucagcugccgcugcccucucggag\n", + "guaccaugcagagaacaaaaauuucacuuupaguauaaauuuggaccgcuuuuugugagguuguguuacgaguuggaucucgaggaaucugcaguggagcucaugaaagaccag\n", + "augcggcugcuuuaagauucuapuuguacaggcccacgccagacacgacgucuggcaggaaccucggccucagag\n", + "gcpccggapaccgauccuuucagagccgugccgaggugaaggaaaagcuggaguggacuuucug\n", + "uuccpagaacauccaagaugugcuaucugcgcugcccaauccugaugacuacuuccuccugcgcuggcuccaag\n", + "aaggcuggcaaaaaggagaccagacaggaggcgucuguagagauaucaugaacuucaacuuagcuuug\n", + "gapcgguggcucaggcuccuggaaaggaccguccaccccuccgcgcuggcgguguggacgcggaacucagcggagaaacgcgauugag\n", + "gacggccugcgugcacugcgcuugcgcpuugapcgguggcucaggcuccuggaaaggaccguccaccccuccgcgcuggcgguguggacgcggaacucagcggagaaacgcgauugag\n", + "agcaguguguggauuacacuaucacuggaaaaauacgaauugagaagaaggaaaagacuggaagaugcagaccuugguuccuguuaguggaaacacuguaaggucccag\n", + "ugcacugcgcuugcgcpuugapcgguggcucaggcuccuggaaaggaccguccaccccuccgcgcuggcgguguggacgcggaacucagcggagaaacgcgauugag\n", + "guggcucaggcuccuggaaaggaccguccaccccuccgcgcuggcgguguggacgcggaacucagcggagaaacgcgauugag\n", + "ggaagaacguugcuupcaaaaggagcauauucucaggagacpccccugccugccacaccaagcauuaggccaccaggaagacccccaucugcaagcaagccuagccuuccapagaaagag\n", + "uucauagcccugaugaagcaaguuacucugcucuccuaauaaaugcaagaaaaugaccuuggapccuuuuuaauuacacauagaagugacaauuu\n", + "gcucaaaguggcggagcgcggcggcpaggcaggugcacggcacccgccagupugccucaacuuccgcpcguuuaaauagcagccucucuccccucccaccg\n", + "acggcacccgccagupugccucaacuuccgcpcguuuaaauagcagccucucuccccucccaccgguaauag\n", + "gcuaaagauuccuggaguaguuauaguaauaaugucacaggaauauagaaagaaaccuggcaucuuupagaccuacugauaugugacuucuccaccccucccccuccuuuuuuaaccug\n", + "aaaguggcggagcgcggcggcpaggcaggugcacggcacccgccagupugccucaacuuccgcpcguuuaaauagcagccucucuccccucccaccg\n", + "gcugaggacgcggcugcugcucaaaguggcggagcgcggcggcpaggcaggugcacggcacccgccagupugccucaacuuccgcpcguuuaaauagcagccucucuccccucccaccg\n", + "caggcuuggcuuugaacagcauccagcuccacgauucuaucagcuaaauuuuuuuuuuguacuuuaagaaauapauagucauaguguuuacuguacgcaguuguucugaggagaaauuaggaaaag\n", + "agucucugaagccacagaucucuuaagaacuuucugucuccaaaccguggcugcucgauaaaucagacagaacaguuaauccucaauuuaagccugaucuaaccccuagaaacag\n", + "cuuuccuagagucucugaagccacagaucucuuaagaacuuucugucuccaaaccguggcugcucgauaaaucagacagaacaguuaauccucaauuuaagccugaucuaaccccuagaaacag\n", + "agaucucuuaagaacuuucugucuccaaaccguggcugcucgauaaaucagacagaacaguuaauccucaauuuaagccugaucuaaccccuagaaacag\n", + "uuuccuagagucucugaagccacagaucucuuaagaacuuucugucuccaaaccguggcugcucgauaaaucagacagaacaguuaauccucaauuuaagccugaucuaaccccuagaaacag\n", + "acuuucccaaccucugguaaccaccaugcuacucucugccuccaugaaaucaacuuuuauuuuaagcuuccacgugugagugagaacaucacag\n", + "gcuggagugcaauggcacgauaucagcucacugaagccuccaccuccupcucaagcacuccucccaccucagccccccagguagcugagacuacag\n", + "gaauggauaaagcacggagaggaaccaagaaugugcucagaaaaaaauccuuccucacugaaaccaggacuaaggaaaggagauucccuucuaccauccaug\n", + "gacucaggcugacggagcacgcugccugucugugucucuccguuucucucucuggaacguugucagaugucacggcggapaaaagagaccug\n", + "gaaugacuugccgaauuuuuagcccauaaccaggcacuguguaaaccgcuuuaccucauucagucuuugcaauuauaccacaag\n", + "ccucacucupaaggagguggucuucuggcaaaagaagauaucaaaguucuuccaucagaggagauccuuaucagcaagacauucacucugag\n", + "guagugcucauagcucucuuuguccagugcuucggccuuggucccagcgccuucccacggagcagcacucuucacccugcacagccuuguuag\n", + "pcggcuacuuaaggucggcgacccgaggccgcggcugccgacupuccccugccgcugucgccacc\n", + "ccucuaucagacccguuucagaaguuacacugaagacagugcaugaaagacaacauggccauaggcaauac\n", + "caagcuuuguacuuagaucuuuuacuuagaucugcuuuuugucuuauucuuuuuaguggauguuuccaaggauugucuucaguc\n", + "paaappacauapcgucgcpccccggcgaaugcgccccccgccgccucucpcugcgccgccucgcpaugaagcaccggccgugaag\n", + "agucuccccgcuuguuagcugcugcgauugucugcgcucccacpccgaccuaaaacaauucuugcgcacacgcugagauaaauaacggcgacagguggagcag\n", + "cuccagcccaggcgcagaucgugcaugcpccaggcauguguggugaaagaggacaauaucagcgagcgugucuacaccauccpapacacccuc\n", + "aauuuaagaaagcacagcuauuggaaagccaggaaacagacccagagaggcggaugcaugupagcaaagagcuuupcagccuuuaag\n", + "agaagcuguucauuugugcuugcpcucagaagcgucgcacugcuuuguuuuguacucuaccguguccuguugaaapucaacaagugccg\n", + "uauuuagcaagaucaaagacacucuggcuggaacggcucuuguuuuaccgcugacagauagccuuugauuuuuauuuuuugca\n", + "uuagauauggaagcugapaugcacagaggcagccagaaccuaggucapucucgcucggugcugaccgcccccpucgaguaggcg\n", + "paugcacagaggcagccagaaccuaggucapucucgcucggugcugaccgcccccpucgaguaggcg\n", + "uugaucucuucacaacuggaaaaauacuuuuaauucacucugacuuuaaaguaaaccuguccacguuucac\n", + "aggcggcgcuccgcgagaaccaaagugcagccgcugacccggcaaaacucagcpcuggauagcc\n", + "gcagugcpagcugaggcgccagcuguggauuuggaaguuccpaagucgcgcaugcgcgaguguacgcguugccggcgaagapagccugacgacucggaaauuugaauaccacaguagc\n", + "agucgcgcaugcgcgaguguacgcguugccggcgaagapagccugacgacucggaaauuugaauaccacaguagc\n", + "augcgcgaguguacgcguugccggcgaagapagccugacgacucggaaauuugaauaccacaguagc\n", + "gucuaacugcuguccccugccccccccapccuggagcaggauguccuccaggccauugaccpccaucgaggcuguacacaacacagcc\n", + "gaagcugauccaccaccggaaagagacccugucacgcagaggcccuucagccuccaguguugcaguu\n", + "gcggcucggcgcucccggccuggcguuguggcgccgcagcccuugccaccuucccugcaccugcccugcccggccuc\n", + "gcgcgcgccugcguagugugucacpcpacaaccgcggcgcggcucggcgcucccggccuggcguuguggcgccgcagcccuugccaccuucccugcaccugcccugcccggccuc\n", + "guagugugucacpcpacaaccgcggcgcggcucggcgcucccggccuggcguuguggcgccgcagcccuugccaccuucccugcaccugcccugcccggccuc\n", + "cuagcaccucguaccaaccucgccccaccccauccuccugccuucccgcgcuccggugucccccgcugcc\n", + "ggcuugccaggagcuggapagguaggcpcggcgcgugaccuaaggccucucugccgcgcgcgcag\n", + "agcccuccucpcupaaacaggaagcuguguuuuaaaugccgugaucacuggauuaaaggaaac\n", + "gccugccaggauuccagcgccgcagcugcggccgcagccauuggucucugacgucagcggcgugcggcgcacucggcacgucaucgccgcgcgccggcuugccaggagcuggapag\n", + "gugcupcugugcuguggagcucccugaugucagcugcaagcgguuucuggaucagcuaguuggauucuuuaauuuuuacaauggaccuguuucccuagcuuaugag\n", + "aacuguucucaggaagaacugagcacggagupacaccuucaucgagcaaauucugaaaaacaccagugaucugcauaagauuuucaauucccucuggaacuuggaccaaacuaaa\n", + "guggagccccuguuguugcugaaggcagcccgcauucugcagaccugccagcgcucgccucacauucucgcuggcugcauccucuauaaaggacu\n", + "gagcggcauugcccccgaauguccagauuaucccuguuuuugugaccaaagaggaagccauuagucuccacgaguucccgguggaacag\n", + "gcgcgccggcuugccaggagcuggapagguaggcpcggcgcgugaccuaaggccucucugccgcgcgcgcag\n", + "gauugucagcacccaacucccgcccucccucaccgccaagguccugcuucaccgaacagcaccucaggagcag\n", + "aaggccucucugccgcgcgcgcagguacpcagaagucgcagguacccagcugcugcccacauuucugguccagagucccgaaccccgagcacupaugccuggcuacuccg\n", + "agcguuauccagacuagcgagupaggcagauguaaaaucuggaacgcagauuuuaguuuguuggaaggagaaauguaacauagugaaccacgcaucucuggapuguaaagcagagacagccaag\n", + "cucucugccgcgcgcgcagguacpcagaagucgcagguacccagcugcugcccacauuucugguccagagucccgaaccccgagcacupaugccuggcuacuccg\n", + "gcgugaccuaaggccucucugccgcgcgcgcagguacpcagaagucgcagguacccagcugcugcccacauuucugguccagagucccgaaccccgagcacupaugccuggcuacuccg\n", + "gccgcgcgccggcuugccaggagcuggapagguaggcpcggcgcgugaccuaaggccucucugccgcgcgcgcag\n", + "cgcgcgccggcuugccaggagcuggapagguaggcpcggcgcgugaccuaaggccucucugccgcgcgcgcag\n", + "aucgccgcgcgccggcuugccaggagcuggapagguaggcpcggcgcgugaccuaaggccucucugccgcgcgcgcagguacpcagaagucgcag\n", + "gccgcgcgccggcuugccaggagcuggapagguaggcpcggcgcgugaccuaaggccucucugccgcgcgcgcagguacpcagaagucgcag\n", + "gagagcgccgcccacccauccpcaagagccgcgccgcaggagaggcaggcuggaccpcuccccpcccgcgacccccgccgugaccccgcagcccccagcucgcccccaag\n", + "cguucuccugcucucgguuupugagagcacccuuccuaacggucuucpaacugugcgcgccggcugca\n", + "ucgauuucacgcaaccaaccuuacccucguccccaacacaauccuugauuuuaccccupaaaauuagc\n", + "augaggccacacugcaaaapuccuggaguuugcugaaggaucugaaacgcaucacagacagugauguaaaag\n", + "aucucucucpuggagucuucugacagcuggugcgccugcccpaacauccuccuggacucaauc\n", + "ugcpcpcggacagacugcpacggacgguggacgcupacgcguuuguagcuccggccccgccguuccgacccccgccgccgucgccgcc\n", + "agacugcpacggacgguggacgcupacgcguuuguagcuccggccccgccguuccgacccccgccgccgucgccgcc\n", + "acgcgcuucccugccacupuuapaaggcuugccggaaggacgauuucggaggacagcagguguuagccaggcagcggagcgagcgccaacaggcgcacupcggagagacgccgugagcaag\n", + "cpcggacagacugcpacggacgguggacgcupacgcguuuguagcuccggccccgccguuccgacccccgccgccgucgccgcc\n", + "agaaccccugcgccggapapupaaugucugcacgupucupugugagcugucugagagucuggaugu\n", + "accguccgcagccgccggagccpagcccugcccaagucggagcggcguccccugcugagccccgagcgccgg\n", + "gaaccguccgcagccgccggagccpagcccugcccaagucggagcggcguccccugcugagccccgagcgccgg\n", + "guugcuuuccuguugcaucuuugauaucauuuccuagacucuacuccaugauuuaacuugaaauucugaa\n", + "aagagaaugaacccucucaggcagaaacggcgguagaaggagacccuucaggagugucuggugccacaguupcgcaagucuaggcggucccgaucugaaagugaaacuuccacu\n", + "ggccaucccuaguccugcucauaccucagcugauacucupcaagguguacaccucuagccugaacugagcucuugucccaacucucagcaucauc\n", + "accucagcugauacucupcaagguguacaccucuagccugaacugagcucuugucccaacucucagcaucauc\n", + "gucuuugucucucgcugcagccggaguuccuggucucgucuucgcccuucuguguccucugcucguagaggcccagccucuguggcccugugaccugcagguauupaauccacagcuaag\n", + "gauguggcpucuuugucucucgcugcagccggaguuccuggucucgucuucgcccuucuguguccucugcucguagaggcccagccucuguggcccugugaccugcag\n", + "ggaguguugacauuuapauguggccuuagaauucucucuggaggaguggcaaugccuggacaccgcacagcagaauuuauauaggaaugug\n", + "agucgcacaguugcgcgguggccgacaggaauuguuccccagugguaagccgcaaucuagcugacguggccccaaccccacauuccuuccugcccugca\n", + "agugcgcagcapcagguuccugcggagccgccggagacggucpuuugccapccpcpaccgcpacc\n", + "augauggacuuccaaaaccagaacuaauauccuggauugaacacpagagcccuucaggaaauggagagaaucacagaaaucaggaaacauaauuugcuccucuguugau\n", + "caugcaguccaguggaccuucuucugcugagagcaguauugcuggccaggcugucupuucaaagcuaggcugugccucauaaacaugaccuuug\n", + "uuucugaguccugagaaaggcaaaguuugcuuugcuupuaugucugcugucaguaaauggcugcaggagccgaagugguaaacuccucggucuccagaaaucagaagaaaauuuuagg\n", + "aguacucccugauuggcucugcacuggaggcagugauuuupcagagaauuuugcaacacgugguagugaacugugaggaguuugapucugaagacugaaagagucgaaugguuuguuggcag\n", + "gguguccugguggauugguuucuguaaguucagauucucauaaaucgugugagcgucgccgacaccucugagauaaaapccccuuucgacuagccucugcugaaag\n", + "gcacuggaggcagugauuuupcagagaauuuugcaacacgugguagugaacugugaggaguuugapucugaagacugaaagagucgaaugguuuguuggcag\n", + "agagaauuuugcaacacgugguagugaacugugaggaguuugapucugaagacugaaagagucga\n", + "gcaguacucccugauuggcucugcacuggaggcagugauuuupcagagaauuuugcaacacgugguagugaacugugaggaguuugapucugaagacugaaagagucga\n", + "ugapcgaaugccgagucgcugaccgagcgcaccccgcccccggcgccaucuucccgaccgcgagccguccag\n", + "accgcugcggcugccucagcuacugccgcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "gcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "gcggccggcgucaccgcugcggcugccucagcuacugccgcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "agcuacugccgcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "cugccgcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "gcagcaggcgcgcgcuguuuccggaagucgcggccggcgucaccgcugcggcugccucagcuacugccgcagucgccgcggaauucg\n", + "auuuuaagaguaaucuucacaaaguguaccaggccauagaggaggccgacuucuucgccaucgaupaguuuucag\n", + "gaaucagugauggaccuucagucucugcauuaacaaaugguuuugacacuccagaagagagguaucagaagcuuaaaaag\n", + "gucaccgcugcggcugccucagcuacugccgcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "gccgcagucgccgcggaauucggcgaguagaaccgcugaggcpcgcpcccpupccaagguuccggccacucugcaga\n", + "gaaggcugagcgcpcucucaaggaaaguagucgcggaaucucaguuagcgguggagaggcagu\n", + "ggaaggcugagcgcpcucucaaggaaaguagucgcggaaucucaguuagcgguggagaggcagu\n", + "acagaugcaaguggaguugupaauacaaccapccguguccuucugucuuugcuaupugg\n", + "cacccuggaggagaagagguucugcuggaacaagcugguguagaugcaagugaaagcuuugaagauguaggacacucuucugaugccagagaa\n", + "aggccuuaupcccugguuacggaagccgaggaaggcugagcgcpcucucaaggaaaguagucgcggaaucucaguuagcgguggagaggcagu\n", + "guggcaauuuguaaaaagacagcucuggaaguugaagagaccaguggcuucaagcaaaaaguaaauugaaa\n", + "auugcuuacaauaccugcuugccucaugugcuacuauuguuuccaaccaacuaugcuagacuucuuaaag\n", + "guuguuuauaagaauaaugacauccgucuggagcugucucgccuggcccggauugcggacaccaag\n", + "ggcaccugacguccuuccuuauuacugauggcagcagagacugaaccccupagaggaaagugaacuga\n", + "gacguccagccgacuggcggcgcggucgcccpagaccpaaagccguuucacacccguccuagucgaagucgag\n", + "agccgacuggcggcgcggucgcccpagaccpaaagccguuucacacccguccuagucgaagucgag\n", + "gacuggcggcgcggucgcccpagaccpaaagccguuucacacccguccuagucgaagucgag\n", + "gcugcacucagagaagcugcccuuggcugcucguagcgccpccuucucuccucgucaucauccagagcagccaguguccpaggcagaag\n", + "ccucccugcagcupacugcuguuaaacpucugcagccuggcugaggagcugcgccacauccacuccag\n", + "gcacucagagaagcugcccuuggcugcucguagcgccpccuucucuccucgucaucauccagagcagccaguguccpaggcagaag\n", + "ggcgccuucagccgcugcuacaagcugacagacauguccaccagcgccguguucgcccucaagguggugccguguggcpcupccpuggcuucgcccgcapaaag\n", + "guggagcgugagauugcccugcauagccgccugcgaccccgcaacaucguggcuuuccacggacacuuugcugaccgcgaccacguguacauggugcuggaguacugcagccgccag\n", + "guaacuucuuccuuaacaagaacauggaggugaagauuggagaccupacuggcggccaaggupccapccgcugccacag\n", + "aguacucugupaccccuaacuuccuggacccugagguugucuccagaaacggucacuccugccaguaggacaucupcucupcugcauc\n", + "gaaaaggcacgagucguuggcgccuccgcagcggccacagcgguccucgapcacccgagcccaacaacccaucacagccggcgcucuaaagg\n", + "uacucugupaccccuaacuuccuggacccugagguugucuccagaaacggucacuccugccaguaggacaucupcucupcugcauc\n", + "cugcgccugcgcgapcuacgcgcgcuccggccpcgcpcgcgcucucaggcpcuccggcggcagcgacgcgagcgcggcg\n", + "gcuggagugcaguggcuugaucuuggcucacggcaaccucugccuccuguauucaagcgauucuccugccucagccucccgaguagcupauuacag\n", + "cuugcucgcggagagaggagcuaggagccucggccaaupagccggcguuguuggaggccacggcggcgcagccccaaagcgagcgaagcuapucgccgccacugccgcaggaggcgugag\n", + "guuuacpugaaaauagacuuuuaaaaauucucuuaccuuagaaauauacaaauauguagauuagguuguuggaccuuaaag\n", + "gaaguagcugaucucugcaggaaacugcuguuaccuggccucagcugaauuuuugupaccuccugag\n", + "agacgagguuuccccauguugcccaggcuggucugaaacuccugagcuucaggugaucugugauap\n", + "guuguuggaggccacggcggcgcagccccaaagcgagcgaagcuapucgccgccacugccgcaggaggcgugag\n", + "agcugccucacgagcacuggagcuugcguuacuuggccucaccucaccugugcuguccacgccuggcuuugucucaccugacgcgau\n", + "agcucugagagcggagccccagccccagaauucccagguguuuucauuuggugaucagcacugaacacagaggacucacc\n", + "agaauccgguaaccgaugcggacgguaaagccguuupuuagagcggcgcpuguccaguccgcggaacpagaucguuggcaccuucgcuuuuuuapaacpauaguucg\n", + "ggcggcgaagccgcucggcagcaccuuccuucuuugccaggcagacgcccguuguagccguupaaccguugagaauccg\n", + "ugccucacauccaapagagagcuaacacgcaucucacugguugcugaaggaggcugcuguguu\n", + "agacpuuuugccauguugcccaggcuggucuugaacuccuggacuuaagcgaucuguccaccuuggccucugcaaguucupauuacag\n", + "aaagcccgcuuaucuaccauuuuauuuacugacaacugugaaguaacccaugaccagcugugugaauugcugaaguaugcaguucupcaaauccaauguuccaaaacccag\n", + "uugccaggcagacgcccguuguagccguupaaccguugagaauccgguaaccgaugcggacgguaaagccguuugg\n", + "gccuuccggagcguagcggccucuagcucgagcagcaggagcagcccgcaccggacaacuugcgagcc\n", + "ggccucacccggucccggcgccgccuuccggagcguagcggccucuagcucgagcagcaggagcagcccgcaccggacaacuugcgagcc\n", + "gagcgcagcuggccucacccggucccggcgccgccuuccggagcguagcggccucuagcucgagcagcaggagcagcccgcaccggacaacuugcgagcc\n", + "gagcgaaupccggcgacuguggaguuagcguccucaauguggacgcccugagcucccauuaggagccgcuggcugcggcagcapacuagcgugagag\n", + "acucgagagcuagcugagcgaaupccggcgacuguggaguuagcguccucaauguggacgcccugagcucccauuaggagccgcuggcugcggcagcapacuagcgugagag\n", + "aauggaaccuaguauauaaggcauucaagaaauacucguucagugaaugacuacauugacuugagacaupaacaucuugcaaugaccuggugcccuuugaaggcaaag\n", + "ugagcgaaupccggcgacuguggaguuagcguccucaauguggacgcccugagcucccauuaggagccgcuggcugcggcagcapacuagcgugagag\n", + "ggauucuggacaaauauggaacguupucgguugccpuccucaaaauuauaaccgccacuggaucugcgcugugcg\n", + "ccauuuaacuugcucupugcgagcagcgcuugugacupcaaccugugcgucagcguccccggugcuucggcgcuccggccagugacggcgaccaaacccagcuaggucagacgag\n", + "gccgaagcgccucggugcguugcaccgccggaggcupcagcucgcagcgcugcucggcgcuggaccccacccggcaggcgcag\n", + "ggaggcgccgcguaggcccpaggccpccggccpcugcgagcgccugccccaugcgccgccgccucuccgcacg\n", + "uuuugagguccuguaaccagagcagcugaggauucaaaccucguaguacgaaggucuguaugagacaagaaaggaaag\n", + "auaucucuapuuuaugacaggcuguuuucuuuucucagugupaugaauugcuccauuaucaucuaaauuggaagucaugaugaug\n", + "ucucacucugccacccaggcuagagugcagugcaugauuauaacucauuguaaccgugaauucuuggcgucaagcuguccucccgccucagccucccaaagcacupuuacag\n", + "gaaaccaacaugucugacaaaagugacuuaaaagcugagcuagagcgcaaaaagcagcgcuuagcacagauaagagaagagaagaaacggaaggaagaggagaggaaaaagaaagag\n", + "gcugauaugcagcagaagaaagaacccguucaggacgacucugaucuggaucgcaaacgacgagagacagaggcuuugcugcaaagcauugguaucucaccggagccgccucuag\n", + "gauggcauagucaauccaacaauaagaaaagauuugaaaacuggaccgaaauucuacugcuguccaauugaaggcugccccagaggcccugagagaccguuuucucaguuuucucucguaaaacag\n", + "ccggcagcgaccugaguagcucuugccaguaggccpacuagcugucucpccuuccauccgcuuggccccacag\n", + "gaaaagaccccaauauucucuuuuaguagcggagcguguugauccugccugaaguacaccaguguuccgaaggugcaucuggugaucug\n", + "gucguaacccaaggcaacggcccauccggcagcgaccugaguagcucuugccaguaggccpacuagcugucucpccuuccauccgcuuggccccacag\n", + "uaguccuggcupcucccgcuggagugugcguupcggaccaggagcgguggucuccapag\n", + "ccpagcgcuaggccuggucccucuuccuagaauagcguugcgcgcaugcgccuugacgagugagccgg\n", + "cgguggucuccapaggucgaggcupcucccacccggauuuggagcapucgccgcggcccagcugacccgccggcguuuguacguugugugcccacucapagcc\n", + "gcugcgccggcgccgccpagcgcuaggccuggucccucuuccuagaauagcguugcgcgcaugcgccuugacgagugagccgg\n", + "aauugguggcuuugaaggcgcggcgagcpaacagcucuugaggagugagacugcaggagaugupccg\n", + "auacugcgccugcgcaapcuguggcccuuuucccacccccuagcgccgcupccugcaggucucugucgagcagcggacgccggucucuguuccgcaggaug\n", + "apuaaaacugauuauuaugcucggaaacgcuuggugauacaagauaaaaauaaauacaacacacccaaauacagg\n", + "ccuuuucccacccccuagcgccgcupccugcaggucucugucgagcagcggacgccggucucuguuccgcagg\n", + "puuuguuaaaguuguuaagaauaaggccuacuuuaagagauaccaagugaaauuuagaagacgacgag\n", + "ggacacugucuucagccuuuucuucaaguuuuugaccguggauuguguugugucaaacuggaugaauuaucuuaguugaauuuucaccaguugaaaaauuggag\n", + "auuucuagacuacugaaaagaaguugcuuucagagcuggagaugugaauaaaauuucugugccapuugauaaaccaucuugag\n", + "gauuccauccaggaaaccccaucacaguugguuguuaugucuccuuagacuccucuuggcugugacaguuucucagacuuuuguucuugaggaguacugaucag\n", + "aaaaugacuguggugcuagaagaucauuacuuuuggaaagccgguuaacauccauuuccuaagagaaacuuggccaccauuugcucuggc\n", + "cacaugaccauuggcuggagcccaguugaccaagaaggaagccagagaaagccacacauucpcgagcaag\n", + "gaucacaaggagacacaucugagccugauauagaggauugcacaucagcacaucauucagagauccuggacuuugagauguauguaguaacag\n", + "gacacugucuucagccuuuucuucaaguuuuugaccguggauuguguugugucaaacuggaugaauuaucuuaguugaauuuucaccaguugaaaaauuggag\n", + "gagaaccgagcggagcugguugagccuucaaaguccuaaaacgcgcggccgupuucpuuuauugauugaauuccgccggcgcpagccucugcagagagagagcgcgagag\n", + "gcaggcgcugagaaggaggcgcaguccaucucucucapuuagugaaugaggcucuccgcccpccggcccpacagugcgcugcuggucccagc\n", + "gcgucgcuaaggagcgacpcugucggccagaccccgaguucucggugcgcucagcggccgccgacgcuaggaggccgcgcuccgcccccgcuacc\n", + "gguuuuuccggcucccccgcgucgcuaaggagcgacpcugucggccagaccccgaguucucggugcgcucagcggccgccgacgcuaggaggccgcgcuccgcccccgcuacc\n", + "agccggcgcccccugcccuucgccgccgcgcupcpcgcccccgccgcccucacuccgcugcucccggcuccucgcgcgcaggucgcggagcuccgccaccgcupugcggcgaggccggcgcg\n", + "uggacaggaaccacugaaguuugccugacaccaucaaccaggcccuagucaccuggcuuugccuuugcccugcugugugaucuuag\n", + "caucagcagagagcccaggauguuucacuagcaccaaaggcucaagacuagccguccaagauuagccuuuuaaupuucuugucucccaugcaucccugcaggccucccacccagaggaga\n", + "caucagcagagagcccaggauguuucacuagcaccaaaggcucaagacuagccguccaagauuagccuuuua\n", + "ucugaaccaacaacaagcaaaguuaaauuauggauauccaapagucuauagaagguccaugcaag\n", + "acauuuugacuacuugucugaacuagauaucccuugaaugugcacacaaaaagugaaupucauuugauaag\n", + "ggaaaacuagguuccaagauggcugaauaggaagagcuccaaucugcagaucccagugugagcaacguggaagacpugauuucugcauuuccaacugag\n", + "gaaaugagcaaccugaauuacucggaggagaaaggcaggagagauagaggcagcagaagccapcagcugaaagacagagaccuucag\n", + "ucugaaccaacaacaagcaaaguuaaauuauggauauccaapagucuauagaagguccaugcaagguauggagaguuccucaacagag\n", + "acuugaacuccauuucaucuuuuuucauaccaucucuaagauugcugccgcauuugcuuguuaaacugaaagc\n", + "gugccccagccgaagccggagucgcgcggccpagcacpcgccggcauaguacaaugaggcagccagcggaucuugg\n", + "cagaaacaaccuuauacaaagugguuccguggaggagagaauuaccauguuauaguccucaggaaggcuuuuguuccuggaaaggauaccauugaauagugacaucugaguuuuaag\n", + "guaauaacagaaaaaacuuggaaauaaacaucccauuauuugaccuccaaggcagaagacuggcaccaaggaaauggcagcuucgucccuuuccugucuupcauug\n", + "aggaccgcggccggugccccagccgaagccggagucgcgcggccpagcacpcgccggcauaguacaaugaggcagccagcggaucuugg\n", + "aaacugcccagacgguuggacaggacguagacacacagaagaaaagaagacaaagaacpuaggaaaauuaaaaag\n", + "cgguuggacaggacguagacacacagaagaaaagaagacaaagaacpuaggaaaauuaaaaag\n", + "acaacaaauagaauucuggcuuccuccugcuguagcaguaacauuuuaggaucggugaauguaugcgguuuugaacccgaucaagucaaaguucgagugaagg\n", + "auagagaggucpuagaggcucccpaccugcgugcugccgagagaggaagcgaapcaccaucuuug\n", + "gcuggaggagcucgaggcugaggcugccppcugupcuaccpccgccggcgccucagcg\n", + "gcgacgucacgcucggcuauaaaaggcgcggcucpcccuugcggcgcuggaggagcucgaggcugaggcugccppcugupcuaccpccgccggcgccucagcg\n", + "cuccccggaucgugcpccugagccucuccgccggcgcaggcucugcucgcgccagcucgcucccgcagcc\n", + "gcaugcgccgcagcgccagcgcucuccccggaucgugcpccugagccucuccgccggcgcaggcucugcucgcgccagcucgcucccgcagcc\n", + "gauggcuccugccuguucccaccccucacccccggcagcaaaaccuauguuccaggcaggcagcagugaggacaaag\n", + "gaaauucgaaaugagucccaugacuauccucauagaguggccaaguuuccagaaaacagaaaucgaaacagauacagagauguaagcccau\n", + "augaucacagucguguuaaacugcaaaaugcugagaaugauuauauuaaugccaguuuaguugacauagaagaggcacaaaggaguuacaucuuaacacag\n", + "gcupuguagugguguguucucggcucaccguaaccucugccuccggaguucaagcgauucuccugccucagccucccgaguagcupauuacag\n", + "ccagcgcucuccccggaucgugcpccugagccucuccgccggcgcaggcucugcucgcgccagcucgcucccgcagcc\n", + "agaucggugguuapuggaaupaagagugugccugccaapcacacagaaccuuugugcugauggaauag\n", + "augcgccgcagcgccagcgcucuccccggaucgugcpccugagccucuccgccggcgcaggcucugcucgcgccagcucgcucccgcagcc\n", + "gcgcacaccuccccgcgccgccgccgccaccgcccgcacuccgccgccucugcccgcaaccgcugagccaucc\n", + "gcacaccuccccgcgccgccgccgccaccgcccgcacuccgccgccucugcccgcaaccgcugagccaucc\n", + "guapcuagaguucuggccguggcpccgguuucugcgugcugcgugcgcggccgcgupcu\n", + "ggagccgccpagguaggcgcpacpcggcugcgguggcggcpuggaccgauugucgcucggcggcpagucg\n", + "guggagucucgcucuuucgcaaggcuggagugcaauggcaugaucucggcucacugcagccuccgccuccupuucaagugauucuucugccucagccucccgaguagcupacuacag\n", + "ggcacccucgacuugccuagaggcccccaaaaguugcaguccacaucagaggcagagucagaggccucc\n", + "cuccucucugcuauaugaaauaupagacgacagaccguuugugugcaaugccccpcuguggacag\n", + "aucaaacgccuacuccaacuagauuccugaagaacugugaggaggupacucuucaaugaacuagcuagcuccuuugaacaugaauucaagaaagcugcagaugaggaugagaaaaag\n", + "guuccgccaappaaaggaggagcuggagacagauuguaggaccgagcgcpcaggcpaggcaacggagcuaccagccg\n", + "aguauccguuccgccaappaaaggaggagcuggagacagauuguaggaccgagcgcpcaggcpaggcaacggagcuaccagccg\n", + "ggacpaggaaaguauccguuccgccaappaaaggaggagcuggagacagauuguaggaccgagcgcpcaggcpaggcaacggagcuaccagccg\n", + "agaagcgccuccuccccgcccggagcccaggcggcggugcapaggaaggcaccucaccuugcccccgaugapcggaucaugcc\n", + "gauucaguggccuuugaggauguggcugugaccuucacccaagaggagupcuuugcuggauccuucccagaaaaaucucuguagagaugug\n", + "aguccagcagccaccaucaccaccacugcgguugcugcugcagcugcagcugcugcucucccuccggcugcuucuucgcguggccagcagcgaauggagcg\n", + "apcugcgapcaacuucuuagaguggcccaucggucggucuapapapucagcguggcaag\n", + "gcaugcgugguggcgaaugccagcucccpuuccucuggucuccugagucccggagaccupagcaggupucauaguccugaaagccagagagcapcguuccuagcaccuccucca\n", + "apapcucggccuuggcuccacacugcgcugcccagaggccccgcugacuccugccagccuccagguccccgugguaccaaagcugaac\n", + "aagccaucccacuggccuggacucugcupauuauuuugaccccccapcagaguguagccaucugacuggcuuucucucucggcaggagacpcgcacgccugcag\n", + "gacuugugccuggcugcaguagcagcggcaucucccuugcacaguucuccuccucggccugcccaagaguccaccaggcc\n", + "gcaagcucgaucgaaccaagcuacuaaauugcugagcucguuuuaacugaagugugagaaggagguuuaag\n", + "acaucuggcugaacupagucaggugguugacuugugccuggcugcaguagcagcggcaucucccuugcacaguucuccuccucggccugcccaagaguccaccaggcc\n", + "guucuccucguccgcccguuguucagcgapaggcucugcgcgugccgcagcugacpaaacugaggcacggagcgg\n", + "acccgccucugcgcgcccccpcacgaccccggagucuccgcpcggccapcgcgcgugcgcggag\n", + "guucuccucguccgcccguuguucagcgapaggcucugcgcgugccgcagcugacpaaacugaggcacggagcpugagacaccugacgucugccccgcgcugccggcg\n", + "gaggaauuuuguugucagagaauaaaaggagguuguccauaauugacuuuaagcagcaaucaguaaaacauugagcucuucagcuccgccuuucuu\n", + "agucgccauuuugcuccuagagaggccgccaggagacccggcgcuuucuuccuucugcagcugaggcugcggcpccpcupucpccag\n", + "guuauaucucuugucuggaagguaaaggcugaggcccagcaaggacaagugauguccacauggccuaguagcuggaaggcaaacccaacucuucacacuccuacuucagccaucuuuaaguagaag\n", + "augaggaaacaagcucagapuugaaaugacuuguccaagguuacaggccaguggaggcuugaacccag\n", + "aaacaagaguacaaauucaagagucugugapaaaagauguuuucaucauccaaacuguuucgaa\n", + "accgcggacgccaaucuugugcauggagucgccauuuugcuccuagagaggccgccaggagacccggcgcuuucuuccuucugcagcugaggcugcggcpccpcupucpccag\n", + "ggccgccaggagacccggcgcuuucuuccuucugcagcugaggcugcggcpccpcupucpccag\n", + "agagaggupuugugaccggaguuagaugccagcgcagaapacgugagcccagccgagguaccgcugaagaggaaucaauuuug\n", + "auggagucuugcugugucgccaggcuggaagugcaguggcacgaucucagcucacugcaaccucugccucccag\n", + "puugugaccggaguuagaugccagcgcagaapacgugagcccagccgagguaccgcugaagaggaaucaauuuug\n", + "guugugaccggaguuagaugccagcgcagaapacgugagcccagccgagguaccgcugaagaggaaucaauuuug\n", + "aucuacaugaagaauuacagcaagacaugcaaaaguuuaagaaugaggucaacacauuagaagaagaguuccuggcuuugaagaaagaaaauguucaacuucauaaagag\n", + "cccucccuucuuccucucccgccapucggcpcpacpcguccggugccupcucucuccucucccugaggcgccgcupagucgaacccugaugaupaccugug\n", + "gccagccacagcagagaggupuugugaccggaguuagaugccagcgcagaapacgugagcccagccgag\n", + "gguguccccggcgccgcccpcccugapcuggcuapuccaggccppacpacagacgaaccagccccguguaggaagcgcgaca\n", + "cagucagccgacuacagagaapuaaucpuguccccggcgccgcccpcccugapcuggcuapuccaggccppacpacagacgaaccagccccguguaggaagcgcgaca\n", + "gugccggauacupcgaauacagcaagugugaccugccccugaggacccuggagagccuguugagupcupcccagccggcccuuuugau\n", + "gucagccgacuacagagaapuaaucpuguccccggcgccgcccpcccugapcuggcuapuccaggccppacpacagacgaaccagccccguguaggaagcgcgaca\n", + "agucagccgacuacagagaapuaaucpuguccccggcgccgcccpcccugapcuggcuapuccaggccppacpacagacgaaccagccccguguaggaagcgcgaca\n", + "guaaucauuaaggagcggaggcuuuuggagcugcuaaaaugccggauuaccucggugccgaucagcggaagaccaaagaggaugagaaggacgacaagcccauccgag\n", + "augagaaccuuucupugcuppuuccgucccgaaaugcucagcccaauccaugagucagcagcggcgagaggaggaagcaacg\n", + "cupugcuppuuccgucccgaaaugcucagcccaauccaugagucagcagcggcgagaggaggaagcaacg\n", + "guguacaaagauaaucaaugcugauucggaggacccaaaauacauuaucaacguaaagcaguuugccaaguuugugguggaccuuagugaucagguggcaccuacugacauugaagaap\n", + "gcagugagcugagauggcgccacugcauuccagccupugacagagugagacucugugucaaaaagaagaagaagaaaaaaacaauucagauguaauc\n", + "gauauaaucacagaagugaacuucaugaauggaaauggaacaaguuauuuuccaaaaggcaaacuauuucauacuccuacgugaacauccuuuuaccacagccucagccaca\n", + "aagacaccaccggaagcaaggaaggugcuguguaaucauuaaggagcggaggcuuuuggagcugcuaaa\n", + "agccgcggccccuuccucucgcagcuggugcugupccgcggagccgcgcgucgcugucucuauggccccggauccgagcgcaaag\n", + "gcuggugcugupccgcggagccgcgcgucgcugucucuauggccccggauccgagcgcaaag\n", + "gaaacagcccagcccagugaacupcucaaacucaagacuggcugauucaacaaggcaccccugcagacaaagcuggcagaguagaaguuucaacuccuuucc\n", + "pauagcgcggagcacgcagcagcgagcggagcgcpcggcggcgccguaccucpcugcpagcgcpcgcccupuccucgga\n", + "aggaaapuccccggacucupcucucagcaccugcggucgcaaaccaaccucaugcccugacuuuaccaggcgucpacucugacuuaaccpaaugapacuuggucuggcggcag\n", + "gauagcgcggagcacgcagcagcgagcggagcgcpcggcggcgccguaccucpcugcpagcgcpcgcccupuccucgga\n", + "cccggcaccgcggcgcucpuguuuuupcccpuggapcccpugccpcccaaggugcggccucgcuagcpagapagcpaucaccggcccggagagag\n", + "agagcpucccggcaccgcggcgcucpuguuuuupcccpuggapcccpugccpcccaaggugcggccucgcuagcpagapagcpaucaccggcccggagagag\n", + "acuccuggccucaggugauccgccccccgcucagccucccacagugcupauuacaggcgugagccaccgcacccggu\n", + "guuguuguucggcggcggcggcggcgguaagauggcugcccacpcuccgcggcguccucggcgcugaapuuaauucaacaguucaccaccauuaccg\n", + "aucucugugcccucccccuugcapaaacagcacacacuagugaaaucuugucuuaguguguccggaauuggupuucuuggucucacugaguucuagaaugaagcugcagacccucgca\n", + "gucuguaucagacaucaupagcagauccapcgacaucaaapaagcaugagucuccaggaccagapcuugg\n", + "acacacuagugaaaucuugucuuaguguguccggaauuggupuucuuggucucacugaguucuagaaugaagcugcagacccucgcagugaguguuacagcucuuaag\n", + "gugcccucccccuugcapaaacagcacacacuagugaaaucuugucuuaguguguccggaauuggupuucuuggucucacugaguucuaga\n", + "acagcaaggagguagcccagccccgcguucggcugcucucgaggaggccggagcccccggagacgaugcgccccgcgcagccgccugcgccugcpagcc\n", + "ggcugcccuugagauggaguugcugccucuuuggcucugccupuuuucacuuccugaccgupcuggaggaacagaagcggaacagccacagcagccucccaaggagucugcaaguug\n", + "agcacucggucccagccgauaaaucupcagcgcgcgguaggagcugcpcggccaggccccuuccugcguccgcaccuggccccgcgcgccccucucpcguccggcuuccggcguc\n", + "auguuuauaaauucuucugupaucagapcacgccuauuacaaccagaaaacuacaaguauaacagcgagg\n", + "agcaaagagcagugcccagcccagcucagapcaaaupacagaucccagaggcccugaggag\n", + "ggacaccpcupcggcggcggcggcggccgaggcggccgaggcpccgcaccpccpcgucpccacacgucgguucgcpucgccpcugcgcgcgcc\n", + "cccgacuaagugacuuaaacucccaccuacuccuggaauaaggagucaaagcccggauaggcgcag\n", + "augcggcuagagccugagapagagcgagaaagagcgcgagcgagcgaggccupccuugccugag\n", + "gcggcccpugucaguguggaggagacugagguaaaguupagcgcagcggcguuggcggcggcggcggcggcagcggcagcgcggcpccgg\n", + "aagupcpaaggcgcgagagcgagcgcgagapaaaaggapapupaagapaaucuuauaucacgugacapcggcgcggcccpugucaguguggaggagacugag\n", + "paaaaggapapupaagapaaucuuauaucacgugacapcggcgcggcccpugucaguguggaggagacugag\n", + "gagacugagguaaaguupagcgcagcggcguuggcggcggcggcggcggcagcggcagcgcggcpccgg\n", + "aguucccuggaggcuuuuugauacugauucgcguacaccuguuguuugaaagcucucagcpaca\n", + "agauacagaucacuuggauucagucgaguuugcuuugcuccgupaacugcaccagagcuggag\n", + "gucugaaaaagaacuguguuugauaugcagauaugcuagaagacugccugaaagcugcuuccuuugccacuuccuguggaggccugucuuugccauuugcgguuucuuuauucuuuug\n", + "guuagcaucuugcaaggagguaguaacauauccagucgugaaacupaaagaccagagcucuugcaucapaaac\n", + "paaaaugacaugugcuaacaauaaccuuuuuuauugcagguuagcaucuugcaaggagguaguaacauauccagucgugaaacupaaagaccagagcucuugcaucapaaac\n", + "guguugucuaapuuugucugagccgccucggaagaccuccggcucuugucaggcucuugucug\n", + "cuuupaaacaugaacaaaacauugaugaaauguuggaaaccaguugaaacacaguaaaaccaacupuaaaauaggaccacuucucuucaucuacacupauuugucaagaagugaacu\n", + "ccuuggcuauggagaggcggcccccgagccaggcccuccgccaccgcccccpccauggccccccgccgccacccuuccucgcgcggcccggcccgcpcucccggccgccgcagcug\n", + "gccuucccaacagaacgcuguccucuacugcagcugaugcaacccagccaccucccggcaauccgcuuacuugcaaucaapuucaggugcaagcagaugcugacucagccuguuccauuaag\n", + "cccgacauugucaccuccucuuugapuuagaagaagcugagaucucccgacagagcuggaaauggugaugaaucuuuuuuaaucaaaggacaauuucuuuu\n", + "gugacaaugagcuuucacccgaaapagcacuccaauauggcaauugaccucaccucaagcacacccaauggacagcaugccucaccaagucac\n", + "auuugucuucuuagugcuuggauggugugagugaaaacccagaggaauacauuugguggcugagcuaguaca\n", + "auuugucuucuuagugcuuggauggugugagugaaaacccagaggaauacauuugguggcugagcuaguacaaugccaucaccg\n", + "agaccaugcugcagaugcgaggaaagccguuuccuggaacaucggaauucuaaccccapugaaggacucacgacaggcgapcagac\n", + "ggaaaggaaguuccaaggcccgcgcupaaaaagguppaccapaagacucggagugcg\n", + "cagcagugagagaacuuugucuccupaugacugaaucaaaaaccupuaaucuuucauccagugguggcauacugacuugcagacaca\n", + "cagcagcagugagagaacuuugucuccupaugacugaaucaaaaaccupuaaucuuucauccagugguggcauacugacuugcagacaca\n", + "gcaggcggagugccugagugcccucucacucaacccucucuacccuuugucugcagaggcggccgcugacagcaccagc\n", + "caggcaaggcupucapcapcagagguguggaccpcaggcggagugccugagugcccucucacucaacccucucuacccuuugucugcagaggcggccgcugacagcaccagc\n", + "paguacagcucuuuccuuuccgucuggcggcagccaucagguaggcugcguugaggaucuuugcucuuccauccgccuuugaucgucuuccucuucagccauccag\n", + "uaccgccagcucucugcucuccacapcuccccgccccacccggccugauaaagcgcgccgacupcuacaaggccaagcaag\n", + "pcpacaauagcggccgcggcgccccacucggcagaacuccgccaccaggcgcgaugccggaacuacaugucccaugacgcucupaggccgcagcuuuccaccggaaagagg\n", + "aggcpcggcacugcgccuaagcupccacaaccgccagucapcucuccccuuccccucccucccccccuccuccuccuccucugccgcccagagcgagacaccaac\n", + "acaapucaucuuugagaapuuccuggacuccucaccuccaggaugagcacugcagugucgugacccuupuuuug\n", + "caapucaucuuugagaapuuccuggacuccucaccuccaggaugagcacugcagugucgugacccuupuuuug\n", + "aaaauggcgccguucacucgacuccupcuuuugagucagccggccuuggcgccagacgagguggcapagcggagacccugupucaucgucapacgguuuugagg\n", + "gcuaaagaaauccugacaaaagaauccaacgugcaagagguucgauguccaguuacugucuguggagaugugcaupcaauuucaugaucuc\n", + "agauuuagauuuguuucucccaagccugaacaaaacuacuacuaguggaugagguggcacaucaucuguuggag\n", + "aacucuccuuuccccgcccucuuuccccucggcgcuucgcuccucacggaccucaggacggcucuaacucggaaacaguccccaaacpcccagauccucuggcggagcagaagapccuug\n", + "ggaguuccuggucccuggagcuccgcacuuggcggcgcaaccugcgugaggcagcgcgacucuggcgacuggccggcc\n", + "agacucuupauuccuuagugagugaguucacugcucaaagaapcuuugccacuucugcapaagccagccacpccagcag\n", + "gupcauaccagugucagcugcacuuguapcccaagugccucaugacccacucggcagccuuccucuccaggauccccaaggcuaggaggccaaccuacuaacag\n", + "cagccugccugcagcuguccugguagaacaguguggacauugcagaagcugucacugccccagaaagaaagcaccccagagccaaggcaaagag\n", + "agagagccpcuacucugagaagaagacaccaaguggauucugcuuccccupacagcacugagcgaguguggagagagguacagcccucggccuacaagcucuuuag\n", + "ucugagaagaagacaccaaguggauucugcuuccccupacagcacugagcgaguguggagagagguacagcccucggccuacaagcucuuuag\n", + "gacaguguggugcccagccaaccagcuauaccucuuuugaagauuuuaagaacuuagccuccugaacagucuucuucgaaagug\n", + "gacagucaccugacaguguggugcccagccaaccagcuauaccucuuuugaagauuuuaagaacuuagccuccugaacagucuucuucgaaagug\n", + "uuacaaaccucucccuaucuccaguuguggcagccgaaaaugucuccagacauugccaaaucccuccugugaggcaaagucgucccaguggaaaaccaguagccuguagacaup\n", + "guagaaaaaucaggcccaguuuuagauaucagcagaagcagaaauauaguuuccucaguuuugauaaagcugugaacuuguauucugag\n", + "ugcaaapcagaguuaauuguauuuggaacccaugacagcaccuacupaaagacuucuaagugaggagaaacggcucuacaggucaugaaacu\n", + "aguguggugcccagccaaccagcuauaccucuuuugaagauuuuaagaacuuagccuccugaacagucuucuucgaaagug\n", + "aaaagugguaacagcugaugaguaucaagaaauuauuuucugcaaapcagaguuaauuguauuuggaacccaugacagcaccuacupaaagacuucuaagugaggagaaacggcucuacag\n", + "auucaggaugacuucagagguggaaaaauuaaccuagaaaaaacucagagguuacuugaaaaauuagauauucggugcaguuauauucaugugaaacagauuuuuaag\n", + "aguguggugcccagccaaccagcuauaccucuuuugaagauuuuaagaacuuagccuccugaacagucuucuucgaaa\n", + "aaaaupaaauuuuuggauaauggugguucuggauauauuuugaaaccacauuucuuaagagagaguaaaucauacuuuaacccaaguaacauaaaagagg\n", + "cucaucagugguauccaguugccucuuacucauucaucaucuaacaaaggugauucauuaguaauuauagaaguuuuugguguuccaaaugaucaa\n", + "aaaagugguaacagcugaugaguaucaagaaauuauuuucugcaaapcagaguuaauuguauuuggaaccc\n", + "augupcgccccagccagaagcagagapuacapaagcuacagagaagccccuucugaugccccapagcaagucgacuccuuccaggcuccaggaacaccacaaagcaau\n", + "aguccaagcucagucagcagaagagauaaaagcaaacaggucupaggcaguucuguugccacucucucuccuguca\n", + "agucagcagaagagauaaaagcaaacaggucupaggcaguucuguugccacucucucuccuguca\n", + "cgaaaccaacagcaguccaagcucagucagcagaagagauaaaagcaaacaggucupaggcaguucuguugccacucucucuccuguca\n", + "agcucagucagcagaagagauaaaagcaaacaggucupaggcaguucuguugccacucucucuccuguca\n", + "cccuuccuapuguggagagcpccccgcccugaapcaccgupcuppccuguuuuggagcaggcaccgguggccgagcuccgugacc\n", + "agucuguccuucpuccucagcacagccgugccggugaggcpcggcpaacgcggcugucccgg\n", + "acgcagcugcpcggcpcggcgcgcacacugcucgcupccgcggcucccpugucccaggcccggccggugcgcagagc\n", + "ugcugcucacggccgugaacugcuacagcgugaaggccgccacccpuccaggaugccuuugccgccgccaagcuccuggcccuggcccugaucauccugcupcuucguccagaucpaagg\n", + "gugauguguccaaucuagaucccaacuucucauuugaaggcaccaaacuggaugupaacauugugcuggcauuauacagcggccucuuugccuauggaggaug\n", + "uccuguucacggugaccuucgcuugguguccuccuggccucagcaaccugacaauucugucgugucccg\n", + "gucgccucgccaucucccauagcugucgccugcagcugagaaapuugcugucccagcaggccagguccag\n", + "gaaapaggugcccagugaaauggagccugucccgugcacuuucpcauuucgagcaucuugupcucucccaagucgcggccccuccucugagagccacagucag\n", + "gguggaaapaggugcccagugaaauggagccugucccgugcacuuucpcauuucgagcaucuugupcucucccaagucgcggccccuccucugagagccacagucag\n", + "aucaucuuucucaagauguuuucugucuucaugagucaaaauuugaagaggaaaggaugguggcupugguugacaaauuacucucag\n", + "uugcuuugauuagaaaguuuggcuuugcugagauacguaguuggaaaagagagaagcauuuucag\n", + "uuucuucaguguacuagauggcugacupaagauuccapucccaacaggcuucagaguugcgaaggcucuagag\n", + "gugaguagugccuccucccaucucucuugcuccuggucucaucgugacpccugguccugccucacuuucugcc\n", + "accccgcpcgcccuccaggcugccuucaggcgguauccccpcgcccccgcaccacacugcgag\n", + "ugguacugacuguccucacccacaccccugccccucgagugagacupacaagaugcucugcuggacuugagcuuugccuac\n", + "cacguucuuauguaaccgagcccpuaaagcapcugcagaaagcagaaacggcgagcccggcuccupagcag\n", + "gucucggcccccgcuupccccggccgugcggccggapagcggccggauggagcggaggaugaaagccggauacuuggaccagcaagugcccuacaccuucagcagc\n", + "agcccucccuggacggugugcgaacgcagcccccucccccaccaggucucggcccccgcuupccccggccgugcggccggapagcggccgg\n", + "acacagaccgacacaggcagcgagagacacgaggagcaaagcaagugaaggcacagacgcacpacaggagagccupcaagacuggagag\n", + "cagcgagagacacgaggagcaaagcaagugaaggcacagacgcacpacaggagagccupcaagacuggagag\n", + "aagcgccaccapcucucupuccacggccgcgcaccggagaggacgagguggaccaccugauccugcuggcccuc\n", + "cagcgagagacacgaggagcaaagcaagugaaggcacagacgcacpacaggagagccupcaagacuggagaggugcggugapcupaugcagcaacacagagcaggagcag\n", + "cgguucuuuccggaaauuaugacugcagcuguuuucacuccgcugugacucagagcgcuccpcugcaggagaggaag\n", + "cccagccuguucuaccagagaacuugcccaggucagaggucugcguagaagcccuuuucugagcauccucuccucuccucacaccugccacuguccucugcguugcugucgaauu\n", + "guuccaacuuccuaacuccaacauuaacccuuugaauguauucuuaugccagagaaaggcacauaaaguacugguguuugaacagauaacuuccaac\n", + "gaagacggapcggagccggcuucpacugcggagacuacacaccgagcgagcgccupcccgaapagcg\n", + "cucucgaggcuccucccgcugcpucggcgcucgcccucgcucuccucgcccuccgccccggccccggccccgcgcccgcc\n", + "gcggcccugagagcugacucugcagcugagguagagagacaacgaucaggaacccuaagaagaggcgccagaggagccgccuucugccucagaacggcgugacucggag\n", + "agccguucuccaauuaaagcuguuaacguguacuacgcuguuuccuuguuggauuuucuuguucucugcugcuacuguaaaaacgaa\n", + "augcgccgcccggcuuggaaggupcuucgcccpcpccuucgccpuaggacuccggccuugguggcpuggcuggcgguuccguuaggucugapagcg\n", + "aguaaagacacaggcgaaucaagaggaggcgaggccgguauuguccgucugaauaggcgcugauagcgccg\n", + "guucggcgccgguuuauauaacaggcgcpaggcgcupcucaggcugugcggagccaguucagcagccgccgccgccugcguucccucccccccucccccaggug\n", + "gcguucguggcauucapauguggcuguguacuucacccaggaggaguggagguuguugagcccugcucagaggacccugcacapaggug\n", + "gucgguggcccaggcgcguuaagcugguupacccpaaggccucccucuuaaggucuuucccacaccucugcaccuuguuaccugacuuucggcuucaggauccgcagcgugcacccgcguucc\n", + "aucugucuucugagacuuugcccuucuccaggaagagcacucaggagaccaggaaaauggccacapcuccugagagccaaaaaagag\n", + "gccugagcaggcacguggcagcauuugguagaggaaggagugagcccugcuguaggaacuauauauauug\n", + "gucuuucccacaccucugcaccuuguuaccugacuuucggcuucaggauccgcagcgugcacccgcguucc\n", + "cgguggcccaggcgcguuaagcugguupacccpaaggccucccucuuaaggucuuucccacaccucugcaccuuguuaccugacuuucggcuucaggauccgcagcgugcacccgcguucc\n", + "aaauuccaucuucuaaaccaaaacucauugcucagcuggagcgapaagcgcccuggagagaggagagaaaauguccacuggaccucuguccag\n", + "gcguuaagcugguupacccpaaggccucccucuuaaggucuuucccacaccucugcaccuuguuaccugacuuucggcuucaggauccgcagcgugcacccgcguucc\n", + "ucgguggcccaggcgcguuaagcugguupacccpaaggccucccucuuaaggucuuucccacaccucugcaccuuguuaccugacuuucggcuucaggauccgcagcgugcacccgcguucc\n", + "gcugguupacccpaaggccucccucuuaaggucuuucccacaccucugcaccuuguuaccugacuuucggcuucaggauccgcagcgugcacccgcguucc\n", + "cuggcaagcagaugaauuaacucccccaagcuucuagcuguguuucuacucagupagagauuuggagugaauc\n", + "cugaauaguucuguaugucagcucagcaccccuagugucagccaugcuacucuccugcugugcauagaupcccguccacacccgaaucuccupuucccgcugucagcacccgaag\n", + "gcguucguggcauucapauguggcuguguacuucacccaggaggaguggagguuguugagcccugcucagaggacccugcacapaggugaugcuggagacuuauaaccaucuggucucacugg\n", + "paaugguuucagcuuucgcccauucaguaugaaguuggcuguaggucugucacagauaacucuucuuauuuugag\n", + "augaagucucacucuguugccuaggcuggagugcaguggcgcgaucucggcucacugcaaccuccaccuccugguuucaagcaguucucugccucagccucccgauuagcupacuacag\n", + "ccaucugucugaucaccuuggacuccauaguacacupcaaagcacagccccaguuucuggaggcagaupuaaccaggaaaaggc\n", + "guaccauagaguugcucugaaaacagaagauagapagucucggagcucgccaucuccagcgaucucuacauupaaaaaac\n", + "cucuccagaaagacuucggaggagcuuacuccacuccccggacggucccaguggcuucguucuccacggcccagaagupccguaccuuccgauuagagcupcacucuaggaa\n", + "ucucggcpcpcagcugcggcagcugcugcuguggcucpcggcggcggcgcggcggcggcagapcuccpucggaccauccgcucucccugcgcucuccgcaccgcggcuuaa\n", + "ggacuccauaguacacupcaaagcacagccccaguuucuggaggcagaupuaaccaggaaaaggc\n", + "apaggcuucaugaccuacacaacugacuaaaucauuggccuuuggugaucaacucagccuucagcuucucucuccuccccaaagucapcugcugaaaguuccaaccaucuaaucacag\n", + "uagcaggaagguucapcccugcacuguupcugcucagacauuugugcaapagguguuuuguuuugguguuuccaucacacucacagugauuucuccuuuucccccuuuaguuugaagg\n", + "auuggcugcccgccccuucaggcccugcccccgccggucccgccgccggugccgucggugccgccgccgccgccgau\n", + "gccgucggugccgccgccgccgccgauauggcgcguacggccccuguggagcccccgcugcggcauuccgcgccccccucgccggccgcgg\n", + "gucccagcacaccuggaaaguucugcaaggccucagcuacagaaagcccagagacagaaaguaaacucuuuc\n", + "gaaaaagaggagaagupaguaaacagaaagauaaugcuuaugguacauacaaaacaaauggagagauugagucucacggauucuucgccugagccaccagcaaag\n", + "aucguuuacuuugguugucccuucuggcauggugcauauguuaupaagapauuauaauuuggugcuguuuguagagaugacaacacugauaaaauccacucauugcug\n", + "guaauucccupaguggaaaaggcupcggcugccugugcaccupccgugccpccugugugupucgugguuucugca\n", + "uguuccaguuuguuuucagccpuguacugcauuaacccugcaagaagaaaauggaaagaauuugaaaag\n", + "ccggcccuggcguggagcagapacacagguucccacgcuggcgcccggcgaccpupcugcg\n", + "gcauggccacgcucucacagguaccuguauggccacacccucaccccugagcagcccppccacagcaagagguacac\n", + "gcggaccuuccugguggcgcggcagccpcggcuccuccuuccucccggcccuggcguggagcagapacacagguucccacgcuggcgcccggcgaccpupcugcg\n", + "acpuauuguccggcuccggcggcggcggucggugcugcgagagcggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "gguauuguccggcuccggcggcggcggucggugcugcgagagcggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "guccggcuccggcggcggcggucggugcugcgagagcggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "guauuguccggcuccggcggcggcggucggugcugcgagagcggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "ggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "uccggcuccggcggcggcggucggugcugcgagagcggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "auuguccggcuccggcggcggcggucggugcugcgagagcggcggcggcggcgcpucggcagcpapcgcgcggccgagcggaggcggagucggcgccgagaac\n", + "aagugacaacucccucupaauggauaguguggcucuuugccacapagacaguggcuuuccugugucupuggucapagcaapuguguguuugaagc\n", + "guaaacagauucaaguguuaucpccaccugcagupuuuacugcuguuccaucuccccagacugcagc\n", + "augapcccgcggcccppcugaggcgcccgccgccugccgcpccgcucgcguccucc\n", + "apccpcgcacgucgapcugcggccgccgcagcpcacggccaacgagcugcpcccpaucgcggcggcuggacpcuggagcugucpapcggag\n", + "ggccgccgcagcpcacggccaacgagcugcpcccpaucgcggcggcuggacpcuggagcugucpapcggag\n", + "aaacccgagguccgagccccccagcaggccuccuucucuguggugguggccauugacuucggcaccacgucuaguggcuaugcuuucagcuuugccagugacccugaggccauccac\n", + "aaugagccugaccccuucaagcgccggcggacgcagcaguccggacccaggcgcgccccucccgccccagcccaccccggccugccgcccpapaac\n", + "agaagugguucucaucuuuuuuugcagcuuaagaucugccuugguauuugaagagauauaaacuagaucaauuucuuucacaggaucaacuaaacag\n", + "acuccagcugcagccacucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "aguguugcggagauaggaacaupagagaaacaaucupuaacaugaaagugaugcugguugcuaapaaggcaacuugauucugupaapcuguagcugauccauccguugucuag\n", + "cucacuccagcugcagccacucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "ccaugagaugcuauauucugagacuaguuauuccaucugucugaacaagaggaaaauaauauuuguguaaaauagcag\n", + "cacuccagcugcagccacucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "gcucgucgcgcucgcucacuccagcugcagccacucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "aagcggaugaaauagacucagaagauaguauugaaccuccacauaaaaggcuuuguuuguccucugaggaugaucagaguauugaugauucuacuccuugcauaucaguuguugcacuuccac\n", + "gucgcgcucgcucacuccagcugcagccacucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "agaacguuugucugccugaugagagccacuupuuaagaaacuaccugugaauagucaucauuucuguccuucauupaauacuuuuagag\n", + "acucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "cgcucacuccagcugcagccacucucgcccguggcugcuuccuccauccugguauuuuuuggagcuuccauccugguucuuccaaagugcccggacccaaaacaggaa\n", + "agucuuggagucucuucgcccagguggcuguggauccgguacpaguugccgccgcgguccaacuccccgcugccgcccagcgcauccgcucgcag\n", + "gucagaapaaaauaugcaaguuugauugaaaaauauaagaaacacccuaaaacagacaguucuguuacaaag\n", + "guaccugcacauguuguucuuugucagugcugucaagugugugccapugauccauggucacuuuccpauggcagcaaggugacuucggcugagg\n", + "guuagaupuagugcugacaucauaacaagguucaagaaugacucaucucacaugugugugaaacacccag\n", + "gcggacuaaagcuuuguuuaaauuccugagaacuggaaagaguuacagccucccuggccaggcgccucggcgcugucacccgcgcug\n", + "gcagacpaguuucuccucpucggagcaggaggcacgcggagugugaggccacgcaugagcggacgcuaacccccuccccagccacaaagagucuacaugucuapucuagac\n", + "aggcagcugcupcguccccaggaucuaaagauagcggccccugccuggaacucuaaaugccacccuggagcpagccgca\n", + "uggagauucccugcuccaagucuucupcgcuccagguucugugaggccccacpagccccggaccccuggucucuguaacugupugapaag\n", + "cugcuccaagucuucupcgcuccagguucugugaggccccacpagccccggaccccuggucucuguaacugupugapaag\n", + "ggcpccugaaguacccaaguccccgapcgcgccuuccccpaauuuaauucaggacaauaauguuuuauugagcgccuauugugaaucagacacugagcaguaagcgucggagaaacag\n", + "agcuauuuuucuccguggcggcggcgacgagcggaaguucuupagcgccaguuccgucuguguguucgaguggacaaa\n", + "ggcagcagacagagccuguguucuguuggcuacagcugugcuccagcccccgapccugcggaagagacaacgucucapaccagacagaaguccaacauaaaaagacaaugcuuca\n", + "uuugagaggaagagauguapcuuugcaccuuugccagacaggacuccugaucaaaggacagcggugaaacacag\n", + "cucgaaccccgcpcagcgcccapcacgacacccucaggcgagcccggcupcgcpcggapucguggucccpccguguggaccpcppucccacgcag\n", + "gugaugupccgcugguagaaauuugccggugaccuucccugcacccucucugcagccagccuugcggagaagacagguuuuggcgaccuuuugauuucuucugaauu\n", + "agcugaaupcgcgagagcggcgcupcpupcgcpuaccpcuggcggccggccggcgcccccucauuagu\n", + "cucaggcgagcccggcupcgcpcggapucguggucccpccguguggaccpcppucccacgcag\n", + "ggcggcccccagcugaaupcgcgagagcggcgcupcpupcgcpuaccpcuggcggccggccggcgcccccucauuagu\n", + "cugaaupcgcgagagcggcgcupcpupcgcpuaccpcuggcggccggccggcgcccccucauuagu\n", + "ggcccccagcugaaupcgcgagagcggcgcupcpupcgcpuaccpcuggcggccggccggcgcccccucauuagu\n", + "uuaguaugcggacgaaggcggcpcugcgcggagcggcguccccugcagccgcggaccgaggcagcggcggcaccugccggccgag\n", + "ugacaagaggaaccaagaaccucaguucapaaacacagcaaggaaaugugagccccaggcugcagaag\n", + "pupuuucagcgccupccccucuccccgccgcpcgcacggaaaaaccpaacccgcpuuuuguccuggcgagccacaucccg\n", + "upccccucuccccgccgcpcgcacggaaaaaccpaacccgcpuuuuguccuggcgagccacaucccg\n", + "agcgccupccccucuccccgccgcpcgcacggaaaaaccpaacccgcpuuuuguccuggcgagccacaucccg\n", + "acccuacugucgcauuaauuucuggcaaccacacugagaaagguguagauuaagcuggaaaaucacgaagagugccaapauuggucaguuuuuacupucugcaccaggccag\n", + "acuaucuagguuuauguaagaacgcucugauguuugcagaagaacaucgccuaacgauacauuucucagaag\n", + "aguapugagcucpacgcgcaggcpupuuucagcgccupccccucuccccgccgcpcgcacggaaaaaccpaacccgcpuuuuguccuggcgagccacaucccg\n", + "agauucuuagaagacccuucagagucugaaguaaagaaaguuuugaaccuguuuuuucauucuacuguapcuucugaaaacaag\n", + "gagagcuggagguguuucagaaagaupaacgaaaaauucagagucgacagcaacuuccagupaacaaccupccguuuccupaag\n", + "gugaugaugaaggaauccaggagacagcagaaucagaupacacacagucagagaaaccpcaaccuggaguugagacagacgacupauggaccag\n", + "cccgaccagaggapcggugcugcapcugguccpaggugacgaccggcuucggagagucuauc\n", + "auuccucgcgaguguauggcgupcucccuucccccucugupucccgcgaggagacucucpcuuugag\n", + "gaupagaggaaaaacaaauuauuuuuaaugauucacggcaaccacauuuauauccuauuguuacuagagaaaaaa\n", + "aguugugacagacuccuggaacagcagcucuucucaaggcuaguugugacauccaaagugacaagagcaggcccauauucagccaccucauccag\n", + "gccuuaucaaagaagagucuuauaugagaucaaauggcugccuuuccccacaagauuauauuuuuccugguaugcucuacuuugacacauguggcuuucucag\n", + "guccggaaucggcugucagccucccuggcuguuaguaccuucuuucccggaguccugguccacgaguuggauuuacugcugucgcgg\n", + "cuugacucugcugauuugcaucacaggcugcucucuucagcaapauaagagapcuggaaggaaccugcccagccupccucaggaagcagcaucpugccgcagcc\n", + "auucccaaccugcugagcauccgcacacccacucaggaguupcccagcucccaguuuacuugguuucccuugugcagccupcucugcccaggccaccacaggcapucgac\n", + "pccccupcucccapupagcuggcuccgaggcuggcuggcuccgcagguccgcugacgucgccgcccag\n", + "pcpupccccupcucccapupagcuggcuccgaggcuggcuggcuccgcagguccgcugacgucgccgcccag\n", + "gauagagccuccucaaauccaaaugcuaccagcuccagcucccaggauccagagaguuugcaagacagaggcgaapaaggucgcaacaacaguuaucuccaag\n", + "uguuucucaacauccuggcuuaguauugugugcaaaaucagagapugcaagauccugauuuuucag\n", + "agguaapaauapuguguguggupucpacgaaugugcgauuuuggugaggapaccuguaucuuaaaucgucug\n", + "ugupapuaccucucacagaagagucuuaugacuggcaucapaaggucaccaagucuuuccuguac\n", + "gcagguagguggacggagagauagcagcgacgaggacaggccaaacagugacagccacguagaggaucuggcagacaaagagacaaggugagaaggag\n", + "caagcaggucauccccuuggugaccuucaaagagaagcagagapcagagguppcacapaaapugaccucugagauuccccuuuucccccagacuuuggaagugacccacc\n", + "guaauggauuaggaauuagaauugupugguaaagaaaucccpacauaguggagaaauuggagccuauauugccaagauucuuccupaagugcggaacagacpaagcuuauggaag\n", + "ggcuaagccauaauagaaagaauggagaauuauugauugaccgucuuuauucugupcucugauucuccaaupaauaccaap\n", + "auuugcuuucucuuuuuccuuucuuccggaugagaggcuaagccauaauagaaagaauggagaauuauugauugaccgucuuuauucugupcucugauucuccaaupaauaccaap\n", + "aauauuugcuuucucuuuuuccuuucuuccggaugagaggcuaagccauaauagaaagaauggagaauuauugauugaccgucuuuauucugupcucugauucuccaaupaauaccaap\n", + "cucugcaaaauggcgacaaugucauucaccucacgaguuguggugaggacuaaauaacauaacggaggcugagaagagcugagugcagugcuuagcaggapugugccacuggagagaag\n", + "gaggauguugauuguuggaacacacaccuguccaggugcapagcuggaggcucugugagaggapccagcucagccacagcaggaggacugacag\n", + "acaguugcggcpagagcggcpccgagagcgugacucgcccgcuccgcgcugcuucccccgcgccgccuccccgcgccgcucgcgcagcc\n", + "pagagcggcpccgagagcgugacucgcccgcuccgcgcugcuucccccgcgccgccuccccgcgccgcucgcgcagcc\n", + "cacuuucgagagugccgucuauuugccacacacuucccugaugaaaugucuggauuuggacuaaagaaaaaaggaaaggcuagcagucauccaa\n", + "acuuucgagagugccgucuauuugccacacacuucccugaugaaaugucuggauuuggacuaaagaaaaaaggaaaggcuagcagucauccaa\n", + "acacacuucccugaugaaaugucuggauuuggacuaaagaaaaaaggaaaggcuagcagucauccaa\n", + "accccccagcuccaupacaaaagcuacuaugcucuggacccuuccagaccucacuagauuuaccuccucaucuggcucuucauuugugguacuuuuaaugcaccagua\n", + "puuuuggccaaauupcgapcacaaaauaaccacuuaccccuucucaccgaggaagagcpagaaagg\n", + "gguuuuggccaaauupcgapcacaaaauaaccacuuaccccuucucaccgaggaagagcpagaaagg\n", + "uggccugauucuuuugagaagccuuccuacuccuuacucccaacccugaucaaaggaaaagccauguu\n", + "agaacagcuugaagaccguucauuuuuaagugacaagagacucaccuccaagaagcaauuguguuuucag\n", + "apaguuuucucuguguccccacaaggcaugauucupucuauggugacuuaagapccacacaacaaugaguauuuaauuuuccucagauguauggcuacaauaaacaucuauag\n", + "agugccacauuagaacagcuugaagaccguucauuuuuaagugacaagagacucaccuccaagaagcaauuguguuuucag\n", + "agcccgcccagcggucpuccpcgcccgcgcagaaucagcugucugagcugcccaggcggcpagcagcgagcpcuucagcgagccgcaggaggcacaggccuguccupuccccgcag\n", + "gucugcgcgucuguuguucccagcgcucugagaggccugaaaaggaagagcaaccuguccagaauccccgcag\n", + "gcgcccgcgcagaaucagcugucugagcugcccaggcggcpagcagcgagcpcuucagcgagccgcaggaggcacaggccuguccupuccccgcag\n", + "acucuuuccugucccggccugcguggugupcuugupucuuugagacccgaaaauugagagcguuuucgcacuccagcggcugcuccuggcggcucugcggccgucacc\n", + "acauugccuuuugccuaggcuggcgucgagacuugaggccguugcagacuuuggcgcggcucgcgccuccugcuucaagagcccagcggugagagcuggccugcggcacgcggccuaaugccag\n", + "ucacaacuguggagagacuaugaggcccugaacuuuggcguuaccaaugaaaapaauggauucaaggccaggcaugguggcucacgccuguaaucccagcacuuupaggccgag\n", + "aauauaugcugcuauaaaauaagagcaaguuuaaaaagauuaaagccacaugugccgcuuggaagaaauugcaguucucuaccag\n", + "agagucacuuccugcaaaagcuguauucccucagccugcucucccucacacccucacgagucauggauggcaagaggaucuccuccuaugaugacag\n", + "acagguucauggugaagcuggcugaagagacagaupauaauugucuccaaugaccaguuccpaccuggcggaggagucugagaagugg\n", + "pagagaaaggapaugaagccgccugcccacuggacpapcugcagccagagcuucapcagcccugcuggaupacagcacugapcuggaccuppauggagaacaug\n", + "gapugagaapccggcugccggagcupuugcgaucuucccggagccggagacccucccuugaaaccggcacupacuucucgaucucuggaggcaccuguugcaagugacag\n", + "gcaacucugguagcucuccuugucugguuguuuugaagaaagaagaguagaagaaaaaguugaguaaauc\n", + "agucaccuuuucgupuuccucucacagcgcucggccgucgagcpucgcuaacccgcacucucuucggaccuacgacaucgcggcuucucuggcguuggccagucagccacag\n", + "cgcucggccgucgagcpucgcuaacccgcacucucuucggaccuacgacaucgcggcuucucuggcguuggccagucagccacag\n", + "ggaacuaguaaaaaaagaaaaagaaaaaauaaagugaaagaggcguguugucuaguuucaaaggagaggagagaag\n", + "agacugagucgcccuguguugcccaggcuggucuugaacuccuaggcucaagagauccuccugccucagccucccaaagugcupauuacag\n", + "papugagaapccggcugccggagcupuugcgaucuucccggagccggagacccucccuugaaaccggcacupacuucucgaucucuggaggcaccuguugcaagugacag\n", + "apugagaapccggcugccggagcupuugcgaucuucccggagccggagacccucccuugaaaccggcacupacuucucgaucucuggaggcaccuguugcaagugacag\n", + "ggcuagugacuaugagagaacacggcugaugugaggagaaaugguggacaauaaagacuucagcaguggcaucgucugugcuugag\n", + "ggucucacucuguugcccagguuggagugcagcagugugaucauagcucaccguagccuugaacuccupuuugagcaguccuccuggcucagccuaccaaguaggacuacag\n", + "cucaaggacauggugccaaaggagacaaugucuaugaauuucaccuggaguucuuagaccuugugaaaccagag\n", + "gugccpuugcaggcgcucaggagcgcuapuuugaggccugcuuucugcucgcgccagcagagcacuaccugaggcagcgaggcgcagcgagccuagccuccccgcgcccupcaguguggcc\n", + "ucuggagccucuaaguuagagacacaggcacagcguguuucauuuucauucaccaccugcaauccucugcccuucccucuaccuguuggaauuaauuuaucauucag\n", + "acacupaaggagcugccucuugcuuguuaaccuugagcuggaaguaggaguupuuguuucucauccacuggaaaaaguguuaaguaguuucacuuuacauuaugaugcuaaauugaag\n", + "aucgcggcuccpuacccgccaggaccccugcccccuuuguccgcgugcgcgccggagagccugcagugcgccaacaag\n", + "aaaaacugccugcucuucuaaauugugugucccaaaauauuucauuaacaaguaucaagugauaauccauggaaaagugauggaaagucacaauacaag\n", + "ggugagguggcuuugaccccpuugcccggccagcacgaccgaggagguggcuggacagcuggagg\n", + "cuuggcucggcuccccggaggccpcpcgccggcpcupccgcaggcucpaggaggcggcgguucccgccgcggucgcgccucugugccpcuccucc\n", + "caagacupcucccuggcagcacccacggaccccgacccucugcaccuggacapcggcuccgagaagcccaagcggcccgugucggcc\n", + "pcuuugucuggcgacucgcugccccggcgucggcugcagcggagcugcggcucgacuguucggcccgccgugcucccaggugcccccggccugcgcucccauccacacgcucg\n", + "auauuucugcaugguccuaccaucuggaaagaggcuucuaggaaaccaggcacaauuguaaap\n", + "accuucacugccugguguaacucccaccuaaggaaagccggcacccagauugagaacaucgaggaagacuucaggaauggccuuaagcuc\n", + "cgcggagccagccagcpugcccgcgcaagccccgagcgcggccggccggcgcggccucapcpaag\n", + "auuaaguacacpcuucapaccggccccacgaggaacgccaggcacgcuuccagaacgccugccgcgacggccgcucggaaauc\n", + "gcuuuuguggccacaggaaccaaucugucucuccaguuuuuuccggccagcuggcapagaacagcgacaaacaccuagccgagaguaugucgacuuagaaagagaagcaggcaag\n", + "gagaggcgcggaggcggcgapcgcpcucugaggaccgcucggcgccgccuccugccacacc\n", + "gccaucccugagagccucucagcccuucaucgucggucuuccggugucucccgcuguagaaggaggau\n", + "ggagccpcucaccaggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "gcgcuugaagaggcucagaaagcuauccaacaacucuuuggcaaaaucaaagauaucaaagacaaagcugaaaaaucagagcaa\n", + "aguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "aggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "gugugaugucagcagccucugaugcucaaagcccagauccauuauuccauuaggagguauaaagaaugauacucuggccgagugcapcucacgccuguaaucccagcacuuupaggccgag\n", + "cuagaagaaaaacucaaagaaaaaguggauguaagucugauugaacgaaucaaucugacuggagag\n", + "gcauuagaaaaauugcggaauuacugccaacagagcaaagccuucuggauuucagguccuugauacaagaagucacugagauauguuuguaca\n", + "guguugaguacaucugucuuuuuguuuucucugucucucauugcaucucuaaagcaaggcaguuuuuacgccaagaucaucaggacuuuuacag\n", + "gugaaagaaaucacccgugauauuaagcaauuagaucacgccaaacgccaccugaccaccucaaucaccacacugaaccaccugcac\n", + "caggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "ucaccaggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "ggagguauaaagaaugauacucuggccgagugcapcucacgccuguaaucccagcacuuupaggccgag\n", + "gcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "ugacggagccpcucaccaggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "gaaacaguccauaaagaagcaccaagagaacauuuugagcugauuucaapaaauuauacccuauuccuccacuacaaguuggccupaccuugugccacccagagugacgauaggaucuaaag\n", + "guguuuccaagccaggacccucuagaucgagcagauuucaaugcuguugaguauaucaauacccuguucccaaccgagcaa\n", + "gagacuggaugacaauauucgaacuguuguaagaggucagacgaacgupcaggauggacggcaa\n", + "aggagguauaaagaaugauacucuggccgagugcapcucacgccuguaaucccagcacuuupaggccgag\n", + "agcggcugacggagccpcucaccaggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "agagcggcugacggagccpcucaccaggucgcugccgcgapaguugcugugcupccupuggcggcuggaggccugaguupcucgcggcpucggcapccpuggcgga\n", + "ccucaccuuccucgcugcgcpcggcgguugguaaccggucagaccagcccgagapaccuggugccuguacccaggcuucugucgcucugucgccugcgcu\n", + "gcgcuggcugugcuggucacuaccuuccacaaguacuccugccaagapcgacaaguucaagcugaguaapaa\n", + "aauuagcggcccaacgccccuuccgcgccucauccpuucccpacpaaaguggcgugguaaccaggcaacuacugaucaauccccuccccggcugauuugcgcaucag\n", + "pacpaaaguggcgugguaaccaggcaacuacugaucaauccccuccccggcugauuugcgcaucag\n", + "aaaaagauuuacaaauauaagaaagugcugaguaacccaagccgcupaaguugucuugaaagagauccggacccugguggac\n", + "ggcuucuuggaupcupcgugcauggcauaaccguuugagaacaacaaaccaagccggccpcugccgcucuguuuccugcgaggapaaguuacagaucuccgcccuggcguccpaagg\n", + "gucauccccgccggccucgccccgcagccauggccgccggccccgcgccgccccccggccgcccccpcgcagaugccgcaucugaggaaggugcgaggcgg\n", + "gccauggccgccggccccgcgccgccccccggccgcccccpcgcagaugccgcaucugaggaaggugcgaggcgg\n", + "aggcaagugugaaccggacagcagacaggagaaccuggcaccaaggagacggagaagcugccuuuggugccuccugccuccucccugcuuuguuccaauaauuuugugcucg\n", + "agagcugaauuupaagcagcugccugcuaugcugaaaaccccuggaaacuugcuaaagagcugug\n", + "aauccucucgguuaauacaupaggaucagaaucagapcauuaaggaucaagccupcuuggagagcacagaagaaaaaaaugaaapacagcaagcuggauucugaguuacugap\n", + "auacugaccgagcuuuaucauuacuggaagaauacugcaaaaaauuaaggaaaccagaggagcagcuguugaaaaaugcgguuaaaaaggug\n", + "aacggcuucagcuapagcpagcccaauagagucagaggccaaauagaacaggaacuuggaacaagcagaauuuagcaua\n", + "agaagaaagugucucucuuccugcuuaaaccucugucucugacggucccugccaaucgcucuggucgaccccaacacacuaggaggacagacacaggcuccaaacuccacuaaguga\n", + "ccagagcugugauugugcccgcugaguggacugcguugucapagugagugcuccaucaucpagaauccaagcaggaccgcc\n", + "aguggcucuacuuucagaagaaagugucucucuuccugcuuaaaccucugucucugacggucccugccaaucgcucuggucgaccccaacacacuaggaggacagacacaggcuccaaacuccacuaa\n", + "auagauaccugaacacccguguucauagcagcaugagucacgguggccagaagguggaagcaacccuaaugcccaucaguggaugaaugaauagug\n", + "gagaacuugcgcpagccggacugagcggugcgagcgcgcaggcgcggccgacpcpcugcuacuccggaaucugcuaaucccagucggugccgcauccccagcccgccgcc\n", + "cccucuucupucacgcuagaaucagaucugcucuccagcaucuucuguuuccuggcaaguguuuccugcuacuuuggauuggccacg\n", + "cccucuccapucacccuagaaucagaucugcuccccagcaucuucuguuuccuggugagugauuccugcuacuuuggauggcc\n", + "gupcaggcgaggagcpaagaccaucucugcaagugcagcauagccucggccuaggacagupaguguguggccaaagcugugagcagaggcacaggugguggcagacaguagaggcgcccc\n", + "guuuaucucguupacuaaggcgucgguuggcgcgcaacpuucuaggcugcaggcagcucgaggacccgcggccccgccccggcucggccuggcag\n", + "gcgccagcucguagcapagcgcccgcggcgucpuuupcuggaggucgccaupcgaggcagcggcaccuucgagcgucuccuag\n", + "agcaaaauaugcugugaauuccaucaagaagaaagucaacgacaagaacccacacgucgccuuguaugcccuggag\n", + "gcgcgugcgcgcacuggapaaaaggcggaagcggaagucppcgcgccagcucguagcapagcgcccgcggcgucpuuupcuggaggucgcc\n", + "acaaggcgaccagccagcuccuguuggagacagauupaguccauuuugcagaucugcgaccugauccgccaapacacaca\n", + "cggcgcggugacgugcgcgugcgcgcacuggapaaaaggcggaagcggaagucppcgcgccagcucguagcapagcgcccgcggcgucpuuupcuggaggucgcc\n", + "agucppcgcgccagcucguagcapagcgcccgcggcgucpuuupcuggaggucgccaupcgaggcagcggcaccuucgagcgucuccuag\n", + "gguuuucaaggagacuucaagugagacaccuuccuugccaapaaccagcaagcagacugaguaucucagccacacag\n", + "cucuucccpaggagcccggcgucuuuuucacccgcgcucuccccccuuacucccucagccucccacccp\n", + "agucgcpaaaacuaaagupcppccuuupcccgccccgccgccpccugcuggcggaapaaaupupuppupcaggcgacggupaag\n", + "accaguucgcgccggcgauagacgaggacgccaacagcagcggagaaacguuucucuuuccucucaguuugcgcacacc\n", + "aguucgcgccggcgauagacgaggacgccaacagcagcggagaaacguuucucuuuccucucaguuugcgcacacc\n", + "caacuacgaacauggacaucuguucuaguccuugcuuucaauuauuuuguguagaugcacagcaguggaauugcuggaucagaug\n", + "cuugaagagugguuccaaucacaaguguuaccuuccaaggacaaugucauccugguaauaaccagcuugcuccccugcccugagucuucugccaagucuguccag\n", + "uucgcgaaggcaccccacgcuccuagaaaagagcacgacgcacccgaugcucggauuggaugaaguggcaaag\n", + "gcccacapcagaaucupccuguggcpacagcaauaaaaggaggaauuguagugcuacgcuaaaauaauagaaaaaag\n", + "uuuucaaaccucagccaaccccggaagaaccuuupuauuaagaguacugcaguccgaaacauag\n", + "gcggcgaggaggagccggagcpagugacaccgagccggacccagcgcgaccugcggcggcuccp\n", + "acuuuguaccuuucucuccucgacugugaagcpccpaccugccaggccagaccaaaccggaccucpcg\n", + "agupcggaagagguggccccggaugcugcggcgcccgcuggccpcuggcugcggccgcccupccpccccaccggacg\n", + "agucucgcgcgcpcggaggupccggugcggcgcugucacguagguucagupcggaagagguggccccgg\n", + "agagguggccccggaugcugcggcgcccgcuggccpcuggcugcggccgcccupccpccccaccggacg\n", + "cuaucapupucpcauccgagcpuuugacggaaggagcggcggcgacggaggaggagg\n", + "uuuuccauggacacagccuagcagaaagacgcagccuucgugcuucgcugacugcugaccacugacccaccgccuug\n", + "aacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "cugaacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "acgccugucgugguuuagcugaacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "gaacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "aguuugugcuuggucgccagaggaggcgguggcugaggagaguugaguccacugcugacccuguuuuacgguaggaggcacggcuagcucuaa\n", + "cuuupccguagguuagugupccgugucucaguccacccaaggucuccucggaucgccuggagaggcacucggaccug\n", + "cuggaguugccgugugacgcgupcpacgaggcccpcucpaccuuucgcacucpucapuaaagcagccugucgcuugccpcagcuggugagucggugaccuggccugugag\n", + "gucgcgagaacucugccuuupccguagguuagugupccgugucucaguccacccaaggucuccucggaucgccuggagaggcacucggaccug\n", + "aacucugccuuupccguagguuagugupccgugucucaguccacccaaggucuccucggaucgccuggagaggcacucggaccug\n", + "gucaaagcucagauucacaguugcauaagccgucaccuggaaugucuuagaagccgugagguauggcugu\n", + "uagugupccgugucucaguccacccaaggucuccucggaucgccuggagaggcacucggaccug\n", + "acupcaguuugacccuuaagccugaagauucaacuguccugcucuuugaagcugacacaauuacucugcgccagaccaucaccacauuupucucucaaaaccauu\n", + "upuggcagccupucggccagagaguucaggccaccccggccggacgccugccacuugcugucacugugccgcuguc\n", + "gaacaggagccgccgcugaagccaccgccpugcccagcgccgccgccgcccccgagcucccccgcgccccugcccgcpcggccggupcagcpcgcc\n", + "agauaagupuggcagccupucggccagagaguucaggccaccccggccggacgccugccacuugcugucacugugccgcuguc\n", + "gccpugcccagcgccgccgccgcccccgagcucccccgcgccccugcccgcpcggccggupcagcpcgcc\n", + "agagagauggaagcggccggccpcpagccugaagcagccuuacccaggaauugcapuupuggcgagcagucgcggcgccucagccuaaguggcuuuuapcagcugccpau\n", + "uacccagaapauucggaaguaugacuacaaccccagcuuugccauccguggccuccacuaugacauucagaag\n", + "auuggccggccgccgugaggagcacgaggccaccguggcpcgcgcagucggapcggcpcggcpcggcpcuggccgapcagcgcpcggcpcggcgcgcggupc\n", + "ggcaaccgapccgugaccaccgccuccccgcgacgccccaguccaguggccucgcguccgcccauucagcggagaccugcggagaggcggcggccgcggccuccgcaagccg\n", + "augacugcaagagcaaacgacagcuuuaggaaagaagcacugguuccuggccacaagauguuuacagucaauaggaaacacaaaaagugaauuugcag\n", + "ggacauuuuuuuuuuucuugcucccgccucuguucuucccccaccugccacguacagagcccaaguucucgcuaggcuuguupucagcgcgauuggccpcccgcgcgagccugcgagcgag\n", + "pcagcucacgcuuccuaaaucccgucauccagugagaaagcapacucuucggccuaggcagccpacccagccagcccugcgccucgcgccgucgcgcaugcguccugg\n", + "gagaaagcapacucuucggccuaggcagccpacccagccagcccugcgccucgcgccgucgcgcaugcguccugg\n", + "gcccaccaggcccaggccccpccgccccgapcugcgcccaccuccuuccugccucggcaaccccpcccugapcaggccccaaccgcggaggagcaggagapcggaggccggcpcc\n", + "gapcugcgcccaccuccuuccugccucggcaaccccpcccugapcaggccccaaccgcggaggagcaggagapcggaggccggcpcc\n", + "gugcgugcaggagcugcggcapcugcugguguggcagcaggaggagcccucugaguuugacuuggccuacgccgacuuccucgcccuggacaucagc\n", + "gcaacaauacaggugugapaucgcagcccugguccaggcucuagucuccccgcccucucgcuuucuupccuccpcgccucaaag\n", + "aggcccaggccccpccgccccgapcugcgcccaccuccuuccugccucggcaaccccpcccugapcaggccccaaccgcggaggagcaggagapcggaggccggcpcc\n", + "acuuuuccagaucuaggagcaucauggacaccucgucagagaugcugguacgguuuggacggcgcuguggacpcgaaggaaaguacag\n", + "gugguacgaguaacaacuccaccggcuggcguccgcggcgcuuggcgccacagucacuuuuccagaucuaggagcauc\n", + "aguuggcucggcggcagcggagcggccggagcugcggugcggaccpccgcgcggcguggcgcpagcggcggcggcggcagagccagagcaac\n", + "gcuuauugcuggucucucaaggcuuccuauuuuuguuugcuuuagucucucuaaaauuucapaaaaacuaugagucucaaa\n", + "augccagugaggcugugcugcggcugagcpccucccaucccucuuaaaagaguuaggcauuuagcc\n", + "cguuggcgcgagauccgaacgucggcggccgcgguucuggcguucccugaggcgccpagccugcgccggcguccugccggcuucgucuccucagcggcc\n", + "guuggcgcgagauccgaacgucggcggccgcgguucuggcguucccugaggcgccpagccugcgccggcguccugccggcuucgucuccucagcggcc\n", + "gagccpagcpauccaggagcgaggagccpagcpaacapagucpagccpaaccapcuggcagcggccgcc\n", + "gcuupcuggaucuaugagccpagcpauccaggagcgaggagccpagcpaacapagucpagccpaaccapcuggcagcggccgcc\n", + "pcuupcuggaucuaugagccpagcpauccaggagcgaggagccpagcpaacapagucpagccpaaccapcuggcagcggccgcc\n", + "augagccpagcpauccaggagcgaggagccpagcpaacapagucpagccpaaccapcuggcagcggccgcc\n", + "ccgcagcaauggcgcugaguuccucugcuggaguucauccugcuagcupuucccgagcugccggucugagccugaggc\n", + "cgcgccgccgcgucagcucagcgcupucucucggucccgcagccgugaggaggacggucugcauacucgcugcccgccggcucccucccccgcgucccugcgaccgccgcggcgaag\n", + "caaaaccaccugucgcucccaagccaaagacuaccaguccacugacgccagugaccgcgcccaaauucccuuccucagccaggcccgagagucuucacaguccaaacucc\n", + "gcgacggagguaggcuuacgaggccugugucpuagaaapuccuuccuggaccpacccucugccacgacc\n", + "gacggagguaggcuuacgaggccugugucpuagaaapuccuuccuggaccpacccucugccacgacc\n", + "gugcccucgcgcgacgcgaagguugucpauccgcggcagcagcggcugcuugagaucuguuucupccucuggcgguggcggccupcggcgcgacggcuggugcgcag\n", + "gcgcgacgcgaagguugucpauccgcggcagcagcggcugcuugagaucuguuucupccucuggcgguggcggccupcggcgcgacggcuggugcgcag\n", + "gcuggagugcaauggcgcgaucucgacucacuguaauguaaccucugccuccuggauucaagcgauucuccuguuucagccucccag\n", + "gcccauuuucgucapaauauguacccaucggcuuuagauaaauaaggaaacagcaggcugaaccagaacuaagagaaaauupcagagagaaggca\n", + "agaccagaugaagaagcugugguggaucapupaccaguacaauucucaacauucacuaugaaaaagaagagcuggaag\n", + "acucuggcccgguucucgguggugcpagcpcpagcagcggccgcucuggucggcggacgugcugccgaguagucccggaagcgaagcagcg\n", + "aagcaccacuuucucaaacccuggccucauugaggugauaacaacuguccugcucaapauucccccuuucccccucuuccucacuccuucccccaccuccucuugguguuauacapauauc\n", + "cggaggupuagauagacccggagagacggcgaaggagcuggaaaccgagccapcugagccggcugacaacag\n", + "gcaucgaucgaagguuuccgguaaccagcauacaccaucucauccgaaacagcpuucggcuucuccu\n", + "guugaaaggcuggcuuagaggcaggcugagaggauggcuggauuagaggcuugcugagaugcugacug\n", + "gugucagagccagaggagaagaguggacaacccaacugcccaccacaggucccuagaaguacaggucaagccuaugcupagaggcaaacag\n", + "cuucuuuagacugccacgaggaaaaagcagaugugagaacucaagguucapcugcucuucuaagaaacaagucugccauaaucuccaucuguguuggaaucuguuaacua\n", + "gcagaugugagaacucaagguucapcugcucuucuaagaaacaagucugccauaaucuccaucuguguuggaaucuguuaacua\n", + "ugguacgaugcucucaaggcaguugccaggcuauccacaggaauaccaaaggaauggaggagaaag\n", + "gcgguccucgucgcgaccggcccpccgcaggacgccgcgcucpagcugagccaccucuccgccaggcccgugcgagcgg\n", + "agagacaauuguaccccauugccuggugccaccugcccugccccguccugucccuccuaucccuccugucccuccuguccuuccugccaccuccugccaggcuggcucupaagupugaaaggag\n", + "agucccgcgguccucgucgcgaccggcccpccgcaggacgccgcgcucpagcugagccaccucuccgccaggcccgugcgagcgg\n", + "pucauugcagagccapaggagauggugaagcagacuauccagauauucgcgapugaagcccccuguccggaagcaccaacaap\n", + "auuuauuccauagaugaagaugaaaaauuaauaccuagcuuggaaaucaucuuaccacgugauuuggcagaupuuugugaauaauaagcgagaaagcuacaaauuuaa\n", + "auuucaaagaauuuuugaucaggaugcaaaccaagagaccguuuuugaaaacauugccaaaccaguugcupag\n", + "gacagcagcaaaauauauacaacacacauuuccuauuuggaaaucuacaaugaaugugguuaugaucuuuuggauccaagacaugaagccuccaguuuggaagauuugcc\n", + "gagucuauaucaaccugcagauuugcacagcgaguggcacucauaaagaaugaagcuguucuuaaugaagaaauuaaccccagauua\n", + "gugauuaaacgccuacaaaaggaaauccaggaacugaaggaugaacuggccauggucacupagcagaggacagaggcacucacagaagcagagcuccuuca\n", + "gcuggaaaaacuaauaacauccuuuuuggaagaccaggauucagacaguagauuagagguuggcgcggauaugcguaaaguucaucacuguuuucaucauuuaaag\n", + "acuguugcuaagacugupucgccggagguggupaguuaguuuuggcagcccpccugagagaggucaapucauugcagagccapaggag\n", + "acuggaaauagcaaaggcuaugcauuuguggaguuugagucugaggauguugccaaaauaguugcugaaaca\n", + "auaguggcaccaaaggauucuuuguagaaaacuuugacagcagccuuuaaagucauuauuccuacaa\n", + "aacccuuaggagaaaucuugagaguggacagcaauugugaagaucgccagagaguucuguguuucaucaccgccgaaag\n", + "apcupcgucggucuguccgucgcgcucagapaggupuaacuagccgcuuuccapcgcpaccgcggcucuaccccacccuuccacpagacggag\n", + "gcacaugcgcauugcgcccgcagcccuggaccauuugucaggacuacucgugagacggagaaaaaaaaaagagaaaauuup\n", + "cgcgcgccgccccugcggcccccuccgcccguguggccuuugugccpcgcgcaccggagagcgagcgagcpcpcgagcgcgagaaguacaa\n", + "acaugcgcauugcgcccgcagcccuggaccauuugucaggacuacucgugagacggagaaaaaaaaaagagaaaauuup\n", + "gcauugcgcccgcagcccuggaccauuugucaggacuacucgugagacggagaaaaaaaaaagagaaaauuup\n", + "acacuagcaauggcaaagcuuugugcggaggcauugcuggcugcucugaacuaaaagcauccgupaccgaaagagguuuuugcacaccuuauuaag\n", + "gaaacugaaauagcaguucaagcuaaacaaccggauguggaagagauuuugucuaaapcagcauuuguacaaggaaaaaccagccacucagccagugaag\n", + "aggaaguuagaagaucugagcucugaguggaaggcgguaaaccguuuacuucaagagcugapcaaagcagccugaccuagcuccuggacugaccacuauuggagccu\n", + "cuccuacucagacuguuacucuggugacacaaccugugguuacuaaggaaacugccaucuccaaacuagaa\n", + "agugcuuucagcugugagcuupcggcggcggcggcggcgcuccacuuucpagcccggcggcucupaagcucacuccuccacucguacccacacucgaccgcggagcccuugcagcc\n", + "acuuucpagcccggcggcucupaagcucacuccuccacucguacccacacucgaccgcggagcccuugcagcc\n", + "gccugccucguccccucagcuuucacacgaugauacucauucacgcauugaacauuaugcuagcag\n", + "gcuuucagcugugagcuupcggcggcggcggcggcgcuccacuuucpagcccggcggcucupaagcucacuccuccacucguacccacacucgaccgcggagcccuugcagcc\n", + "cuuucagcugugagcuupcggcggcggcggcggcgcuccacuuucpagcccggcggcucupaagcucacuccuccacucguacccacacucgaccgcggagcccuugcagcc\n", + "uuupaagcagcauauugagaaccucuucagugaccuacaggaupaggcgccuccuagaccuccucgaaggccugacapcaaaaacug\n", + "ccaaaagaaaaaggauccacaagaguucaugcccugaacaaugucaacaaggcacugcpuuuugcagaacaauaau\n", + "guugauuuagugaauauuggaaguacugacaucguagauggaaaucauaaacugacucuugguuugauuuggaauauaauccuccacuggcag\n", + "uuagcaggucuuucugcapcugagcuaucgcuapaacccacggugacugaaucaaapaagaaagacccaagaccuggaucucccuuuuacauggacccuaaagcaaag\n", + "gcagagugcggcgcagcggccgcugucpcuggccauggcgapugcacggcggccaccugaguggcgcggcggugucag\n", + "aucgcuapaacccacggugacugaaucaaapaagaaagacccaagaccuggaucucccuuuuacauggacccuaaagcaaag\n", + "guaggcgcuaccpcguccggcgcagagugcggcgcagcggccgcugucpcuggccauggcgapugcacggcggccaccugaguggcgcggcggugucag\n", + "gaguuggugaccuucagagauguggcuguagacuucucccaagaggaaupauugucuggauucuucucaaagacaucuguacaguaaugug\n", + "gagagacccuguccagugacaucugaggucgugcgaauaugcgaccuuuugugugaccauggucgcguuuuauauucucguggcuguuugauucugaccuugcaguuuugucagagaca\n", + "agugcgaggcugucaccccgugugccuguccacguccugugugacupugcgaggaagucaauggcaccguggaaugugaggcu\n", + "gucgguaaggagacguagcuuuccgupuguaccacugcaguugguucccggcpagacgcagg\n", + "auucugguagcucuupcugaagcupcuuuggugcucaagagaggcuuggaggagaccacaguucuuucuccaug\n", + "ugugaggaauuaaaggcaacugugcagaaacacacgcagagccugaagcccagcaaggaggaucugaacaggcuuaaucaggccauccaguggcugacgguggaggupcagugcugagagucag\n", + "auagccggaagucauccuugcugaggcupcaaccaccgcaggucgagacagcaggcggcucaaguggacagccp\n", + "gaggcucucuaggcgugcgacccagcgacucgauagccggaagucauccuugcugaggcupcaaccaccgcaggucgagacagcaggcggcucaaguggacagccp\n", + "auccuugcugaggcupcaaccaccgcaggucgagacagcaggcggcucaaguggacagccp\n", + "gacucgauagccggaagucauccuugcugaggcupcaaccaccgcaggucgagacagcaggcggcucaaguggacagccp\n", + "ggaagucauccuugcugaggcupcaaccaccgcaggucgagacagcaggcggcucaaguggacagccp\n", + "ucaggcgccacgupauucggcccpugcucuugugagcugcugcuccugcgguuggugagauuaccupucuagagugcggagcugcuccguggccacgaggacgucacc\n", + "ggcccpugcucuugugagcugcugcuccugcgguuggugagauuaccupucuagagugcggagcugcuccguggccacgaggacgucacc\n", + "aggcgccacgupauucggcccpugcucuugugagcugcugcuccugcgguuggugagauuaccupucuagagugcggagcugcuccguggccacgaggacgucacc\n", + "acpcucaucugccgccgccgccgcgcugaggagaguucgccgccgucgccgcccgugaggaucugagagcc\n", + "uacaaaauggaucuguacaucaaaaggauggauuaaacgaugaugauuuugaaccuuacuugaguccacaggcaaggccc\n", + "aguagagugugucupucagcugagugacuacaucaaagcucccagccuugaaaaacacaugcuguucccaggccucaagauauugaaacauuaauuagauaauuuaaaguagcguuuucuucuaca\n", + "gaauuggaauugagacaccaaagccuagacgcguuuccuggacgacggcuucccggcapcauccagccagcggccaag\n", + "aucucugupupccgcgcuuaggucuggauccccuccucuacccuccggugugaccacguccucccacuccpcucggauucuuggucuccuag\n", + "ucaguggucuacagcaguuacacacaggcagugguaucugugagcagcucuguggacucaaagguuuucucccugagaggcaugacccaggccagcugauucaucagaaucag\n", + "gacucaguggucuuugaggauguggcuguggacuucacccuggaggagupcuuugcuggauucugcucagapaccucuacagagaugug\n", + "cucccugccgcgcgugcccugccuaccacgagcggcccpaguaccuguaccuuucagcugcgccggccgcgaggccacggagagcucgccuuggagagcccaggagcapagac\n", + "ucuauucuugagccugugccccgcgacacugaacuucacaagugcuucucaguucuuccuucuccucucacuuggcpacaagaugaauagaggaagaugaupauacaucucuuuccacag\n", + "cuuucauggucauucuaagacaugcacguacacggagcagcaaaacaucuuagucgccacaagcacaccuucccagcugagacugcuccag\n", + "gauagaacccaaagaaaggcaaagaguccugcccggcaccggcgccgcgupccaaaccugcgcccguggapcgcgcagapcaccpcgccpagcaggcggcgcagcaccag\n", + "uucucccuccuccuccuccccccgcuacuauccgcggcccagagaacugccgcuugccgccauugacacgcacagauagaacccaaagaaag\n", + "gauuuuuaaagcgccucuggucugccauuucccagupupacacccugcuagcuauugucugagacaaccacaucuguuuucacugccuccugccagcagaacaggag\n", + "gacuuccucaagcgcapacuaugucuuaaggcgcuuugcagagccaagcucauuucuggcacauaagag\n", + "gcgcgcggagucupcggaggcgagcggcpugugcgcgacucpugauucacgccpaccccaaggag\n", + "guguuggcuacguuugugguuuuaagaaagccugapccugaaggcagccccuggagaagcccuuuccgapcauucggaaccuucugguccuagaggugaagcugaacugucaccaggacuu\n", + "accagagacuccugccuuccauuggcgaaccggucaccggcuccguccugaaaacagaacuugcuccgagugau\n", + "acauuuauugugcccaagacuuuugupcucucugccaggaaapcaggucauugaaupcccupaaaaaugaugucugagcuucucuccaguucucagagaaag\n", + "agagaggcaapcaggagugaaggagagagcugaagccupcuccgagauggucagaggaupagacpcagugaaacaaggcuucuuguaucuucagcagcagcagacguuuggaaag\n", + "agagaapaaacacacggcuaagaagagagaggcaapcaggagugaaggagagagcugaagccupcuccgagauggucagagg\n", + "cacggcuaagaagagagaggcaapcaggagugaaggagagagcugaagccupcuccgagauggucagagg\n", + "cugcagugagaagaggaguuuguuacuuuaaacagaggcugaagaaacuauagaauuagcagagaaaguggagaagguagagg\n", + "ccuccuccuccugcuucuccugcucagaguuccugccuccagcugccappacagccagccagcagcaggagg\n", + "uucuucccucccuccccaugaagaagaguucccuccuccuccuccuccugcuucuccugcucagaguuccugccuccagcugccappacagccagccagcagcaggagg\n", + "guuucuuuacugcaggacuucucagaaccuuuaauaugcuaaugugcauugugaaucuccaagapauaugauaugcagcauucuugaauacuucuaaugacapagcccacuaccucauaag\n", + "gugcacgcaguucccaacacuucucgucauccucucuuuggucucuuuauucugcugagcggugcuguuaggauuucuuuuuuuuuuuuuuccccugaccacguucgcgaug\n", + "agccccgucgugcacgcaguucccaacacuucucgucauccucucuuuggucucuuuauucugcugagcggugcuguuaggauuucuuuuuuuuuuuuuuccccugaccacguucgcgaug\n", + "cuugucgcugguguuugucucupaggaucapcugccugcuuggaguuuguuguppag\n", + "gacuucucagaaccuuuaauaugcuaaugugcauugugaaucuccaagapauaugauaugcagcauucuugaauacuucuaaugacapagcccacuaccucauaag\n", + "agugcccgccggccgcuuccgcucccggcgcaggcgcggcagcuuggccagagcggapcucpagaggaguggacgccgcuggccagg\n", + "gcccaggccgaggccgccagugcccgccggccgcuuccgcucccggcgcaggcgcggcagcuuggccagagcggapcucpagaggaguggacgccgcuggccagg\n", + "gagugugaaagcgcggacgcucpapucgcacugaacaaucagguucaggcuuugacgagucgugcacccggaauugcggucccaguggcccgagaucuacccuggaagcaacag\n", + "auugcacagccgagcaucccacauucaacaggaggaacccgcpagaggagccccacucccccagcgccgcagccaccgcagccaccgcagcccgugcgccccgcgcccucgagcgcc\n", + "gacagaauaauaagcugaauagaaucugaccauuggcuuucaccuggccaggaccuucuauguagcucuccuuuuguggcccaugugcugcauccucugcccucagugugcaacuggcccccaacgca\n", + "agcugagagcccaaucgcaucapagcacggcccagcagcaggagcuccaggcuggcuggacaccupuccccacgcagacugugaguagag\n", + "auacuaucaaaucagccupaagcaucuuuucgcucagcaaguucaagagaacaaauauguuacaauccuugccuauucuugccuccacuucauaau\n", + "gucauaaaagccaccupugucauuuaucaaccucucuccagcccacucuuccaaaauaacacuacaguuuccuacauguguauuuuugccaggacuccaaagagccuugcuaaaguggaacaag\n", + "caaaauccuccccuggccuccupacugcagucaccaggcugucaaagccucaauaccccacugaguuccagagaapucucaaagcupagaggaucaaacuaacaug\n", + "ggcgucccgcccccgccccpaacgcugccucugccgcaaagaugcccccuuccgcuggaaagcg\n", + "auucuuuuuuuaacuuuuacuuauucauuaggaugauuucauaauauauuuccugguuuagaggaaacaggaaca\n", + "pccpccgcccgcccccgcgucgcpcucuuuaaggccggcgguuuucgcagccagcccpcpaaagcggagcgcgcgcuccacgcpaccgccucccpcc\n", + "cpccpccgcccgcccccgcgucgcpcucuuuaaggccggcgguuuucgcagccagcccpcpaaagcggagcgcgcgcuccacgcpaccgccucccpcc\n", + "gaacaagaaaaccaaacacugcauuuccugcaauaaguguguguccggcuucgaccaccacugcaaauggaucaacaacugcgupaagccggaauuauug\n", + "guucuucuucagcacuguggccucggccacagcuggcaugcucugccugaucgccauccugcuguauguccucguccaguaccucgugaaccccpugcuccgcacggaccccaggu\n", + "cggccacagcuggcaugcucugccugaucgccauccugcuguauguccucguccaguaccucgugaaccccpugcuccgcacggaccccag\n", + "acuuuggucuggaguuagcgagagcgacgcugcuuuucucuugcucuucagccuggaccugugaugugauaggcgugagaaggaacugupuucuggcg\n", + "cuggauucugauggcaccauuacuauagaggagcagauuguccuugugcugaaagcgaaaguacaaugugaacucaacaucacagcucaacuccaggapag\n", + "aagguaauuguuucccugaaupauggacucauuuguuggcccagaggaacagupaaaauaucggcuguuccaugcccuccuuauauuuaugacuucaaccauaaag\n", + "agcagcpaggaggcggcggcggcggcuagcgaggagacagagcupuccugcaguaggacucccpagccaccauu\n", + "ugagcaagcagcacuugcgaagcgcaguuucaagugaaggaugcaucugugaugcaaaaucaucgaccauuuauuuguaaug\n", + "guuuguaaauauuaucucugugguuuuuguccugcggaauuguucacaaauacacguucugaucuug\n", + "ggauuucggccugagagcpccgaggagauuggcgacggugucgcccguguuuucguuggcpugccupcuggupaacagccgcccgaaggaagcacc\n", + "gcagccagguacccgcgcgaggcacuugcuggcaauggcpaggcggacguppucaugcaauag\n", + "agagcgagcuuaacggauuaauaagcgcagccagguacccgcgcgaggcacuugcuggcaauggcpaggcggacguppucaugcaauag\n", + "gaaggaacauaggaugaaaccauggaagucuuccucagaucupapagccuggcccaagagcccguggagcuaaugaaaacag\n", + "guuaauuaccaugcucagcauuaccaucucacuccauuuacagucaucaauauuauguacaguuucaacaaaacucag\n", + "agaauuuaccccugacgcggcggcggccgacpaagcugugugugcuuaggucgugguggccccggugguggupcuccpcpcucgcgucauccugcccccgcugcg\n", + "auugugaauuggaaaucccccagcuugcuggcucccucagupacauuccagcacauuauuacuuagugauguuccauucaccuugaaaaccacuacuugccaggaccuggcccauaapuuag\n", + "aagcugugugugcuuaggucgugguggccccggugguggupcuccpcpcucgcgucauccugcccccgcugcg\n", + "agaaaaugaccagagccugcupacuugaaccagcaguaagauuuucacgacacagugcugucugcuucuccguaagaaguuagaag\n", + "cggccggacgccuccgcguuacpaugaauuaacggcpuuccgcacggagguugugaccccuacggagccccagcuugcccacgcaccccacucggcgucgcgcggcgugcccugcuugucacag\n", + "guuacpaugaauuaacggcpuuccgcacggagguugugaccccuacggagccccagcuugcccacgcaccccacucggcgucgcgcggcgugcccugcuugucacag\n", + "acpaugaauuaacggcpuuccgcacggagguugugaccccuacggagccccagcuugcccacgcaccccacucggcgucgcgcggcgugcccugcuugucacag\n", + "auguaguucugauagcagcauuccccucuccaccauuguaccauacaagugagupcuuggagaauacaguucucaagau\n", + "aggupuuacggcgcgaggaaaauggcggcggccpaucucagaggugcaggaapagcugcagcccpcuuuuccuccugagccauggaccuuccccpccgcgaccucgg\n", + "agucgccuguguaccuuuguacuuucuacagugaaaguugcuacaggaucucccuuucucaauaaauucaucugcgguggagaaaaucagc\n", + "accagucgccuguguaccuuuguacuuucuacagugaaaguugcuacaggaucucccuuucucaauaaauucaucugcgguggagaaaaucagc\n", + "guguaccuuuguacuuucuacagugaaaguugcuacaggaucucccuuucucaauaaauucaucugcgguggagaaaaucagc\n", + "papcacaacagcugcuaccugaacaguuucugacccaacaguuacccagcgccggacucgcugcgccccggcggcucuapacccccggcgccuacacuuagcuccgcgcccgag\n", + "agaauguuggaccgacgacacaagaccucagacuuguguuauucuagcagcugaacacaccccaggcucuucugcccggcaguggcucuggaagcagucugguguauag\n", + "caapapcacaacagcugcuaccugaacaguuucugacccaacaguuacccagcgccggacucgcugcgccccggcggcucuapacccccggcgccuacacuuagcuccgcgcccgag\n", + "acaacagcugcuaccugaacaguuucugacccaacaguuacccagcgccggacucgcugcgccccggcggcucuapacccccggcgccuacacuuagcuccgcgcccgag\n", + "uccuccucgccugccaccggugcacccaguccgcucacccagcccaguccguccgguccucaccgccugccggccggcccaccccccaccgcagcc\n", + "agucccgcuccguccuccucgccugccaccggugcacccaguccgcucacccagcccaguccguccgguccucaccgccugccggccggcccaccccccaccgcagcc\n", + "uuuuaguuuugauugcuguuaacuacuacugauaacugagccaaaguggugaugcuacuugapaauuucugcaacccauagucaacgauuacaug\n", + "gucgcucgcgccgcugcgugcgguguggugcgaggcpugcgccpcggccgcggcgcggcpaccauggagcucagagcgcagccccggcgccggcggcpaccgcggaccg\n", + "gcucgcgccgcugcgugcgguguggugcgaggcpugcgccpcggccgcggcgcggcpaccauggagcucagagcgcagccccggcgccggcggcpaccgcggaccg\n", + "gauugacuucuaaagagucaugcugugugaugaaaaagcccagaagagaaggaagaggaaagcaaaggagucapauggcucuuccucag\n", + "uuccacugcuccaaacccacccaccaaggacucugaaccuguccaccccpcgcaucaagaucuuccagcupuacccccgauuupccgacuuugcaccuccaaacaaccuuagc\n", + "agcuccaacacagccuccacugugauuaaaaauaaaaauugcuagagcagcccucacucgccacaucuacuuu\n", + "agcaaaucucccugagagcpaccggccucagcuccaacacagccuccacugugauuaaaaauaaaaauugcuagagcagcccucacucgccacaucuacuuu\n", + "cgccugaccacagccggcccuggcgcuugcacauuaagaaacucaaauuaagaagupugaauupaaaggapagccpcguuugcaccguguaucucag\n", + "aauguaagcuccaugapaaaguacuuuguugcucuucuucuccucaguauccucagcguuaggacaaugcagugauauugaauga\n", + "uuuccuguuuagaaaguucugcuccuucauaaggaccuugaaguacuaggaggaaaggugcuuuguguguggaguuuuccaugaagugcagucccaacuaaaaggcugcguuaaag\n", + "gcuagaguagugcaguggcgugaucucagcucacuccagccucugccucccpcucaagugacccaccugccucagccucccaaguagcupacaacagaugugagccaccacacccag\n", + "aggacagauuuugcaaagcggaggcugcgacpuccugcapacagugaggaaapccgccucgucuccgcuccupaccgcag\n", + "agaugugauuugugauucucggaaucaaccapuccuaagauguccuggaggccgucuccauuucucucg\n", + "cagaaggccucgcccugccgccgccgaagcuggaauucgucggcuaguaguucucgccggcaacuagaggaaccuguuggcguggcccagaaggcuuagcpauugcacgag\n", + "cgccaacauuccuucguuccccuaaaucagccucuugccccauugcucuuugcapuagaagaaggaaguguagcp\n", + "uguuggcguggcccagaaggcuuagcpauugcacgagguuaguugcuaagcaagguggucuuuggucaacugccgccuggaccaaggcaacaggaa\n", + "guggaucucacaagauccuuuucauuucggaacucaaagcagacauacucupuucccaucauugcugccaau\n", + "cgcccugccgccgccgaagcuggaauucgucggcuaguaguucucgccggcaacuagaggaaccuguuggcguggcccagaaggcuuagcpauugcacgag\n", + "uucucucucuucacugcuguccauaagcacuauagccucguucaguggcaagaguuugcuggccagaauccugacugucuugag\n", + "cucuguuauccagaaggccucgcccugccgccgccgaagcuggaauucgucggcuaguaguucucgccggcaacuagaggaaccuguuggcguggcccagaaggcuuagcpauugcacgag\n", + "cagaagaaggaggaggagucggcpcggcaccaapcagcagcaagaaggcgucggcggcgcagcugcggauccagaagg\n", + "acauaaacgagcugaaccugcccaagacgugugauaucagcuucucagauccagacgaccuccucaacuucaagcuggucaucuguccugaugag\n", + "cuggaccguggaucccpcpcgugcpcggcagcguacgaggccuucuacucgcccpuguccggugccucgcuucucccupacccugucgucaacaucgag\n", + "aauccggaaacggcggcggcggcgacaggaccgapccuuaguuggupcaagucpaucccagaaagagaagcgugacccggaagcggaaacpuguccgucccagcuccg\n", + "acggcggcggcggcgacaggaccgapccuuaguuggupcaagucpaucccagaaagagaagcgugacccggaagcggaaacpuguccgucccagcuccg\n", + "uucccuaggucuuuucggaggcggaguuuaguauccaaguccgcpugugagcgcgcgcgugugu\n", + "guggcgacagacaaaguugcagaaaagcugagcucuacucucucaupugaagaacacaguaucgcauacagucagucag\n", + "acugccgcugcggcuguugcugcggagccaggapaagcgauggcupcccgcguggaucucuaag\n", + "apcpcuccgagcgupupcgcuugcgcacugccgcugcggcuguugcugcggagccaggapaagcg\n", + "aagcuugagugcccaapuuugauaaauguggaaaauaaccgcuguucgaauauccuguuggccugcug\n", + "ugaugugagguguggaagaaacacpagcagccuuccucaggacaccucuuguuuaucucucuagcucugaaaucac\n", + "acuauauugaauagaagcgaagagacagaguauacuugucuuguuccuaauccagaagaaaaguuugaaucuuuuaccauugagu\n", + "uaauccaagaugccuuuuuucccccuucagaagcuugagugcccaapuuugauaaauguggaaaauaaccgcuguucgaauauccuguuggccugcug\n", + "cagauguggcaucaggagugaacaaagccgcucaucucgcaguaucccuaccuaugcuccupaggagucuaccccagauacg\n", + "gagaauauauaaaaaacuggaggccaagauacuuccuuuugaagacagauggcucauucauaggauauaaagagaaaccucaagauguggauuuaccuuauccccucaacaacuuuucaguggcaa\n", + "gcugagucaucacuagagagupaapcagcagcagcagagaauccaaacccuaaagcugauaucacaaaguaccauuucuccaaguupcucagapagucauc\n", + "ccaaacccuaaagcugauaucacaaaguaccauuucuccaaguupcucagapagucauc\n", + "cuggcaguugacggcuccupacuagaucccgcgagguagcccccgaacuauuucucuacguuuucucuugauccucccgaaaucuuccagauccgcguagugaggaaucgucuccaccguc\n", + "auaggcagaggccacccuccccgccuccccgcccgcugcgcgcccgccccgccccggcucacuuuaaaaguuuacucpccpacgcapcaaagcgagcc\n", + "gugcgcuauuaccgaapcgccgccaucgcggcugccggacccgcuaaggccgcccuccpuagccgcc\n", + "gaacugacucggagcgaggagacccgagcgagcagacgcggcccuggcgcccgcccugcgcacucacc\n", + "ggacuuupacuggacagaccuggucacagucuagguucuacaucuuacuggucgagcaacuuuag\n", + "cuaaauguggucaacagugucagcaguucagaggacaucaagcccuuaccapcuucccpauuggaaac\n", + "agaggcggapapacacpcucauugcggugugcgcccugcacucugucccucacucgccgccgacgaccugucucgccgagcgcacgccuugccgccgccccgcag\n", + "auugcggugugcgcccugcacucugucccucacucgccgccgacgaccugucucgccgagcgcacgccuugccgccgccccgcag\n", + "augcpuuccaucacgugcgacgcggauccuggaccucggcupcgcpapacaacucgup\n", + "gaggcggapapacacpcucauugcggugugcgcccugcacucugucccucacucgccgccgacgaccugucucgccgagcgcacgccuugccgccgccccgcag\n", + "gacgcgauuugacccuugagccguapagcgcggcauuuucuggaaaguucuggaaccgagcgaggcccpaacuagacuaagccggccggagapcugagcgcgcuagcacacccugcgcgg\n", + "gcgguccagcuggapugcpcggcgacaaccuggaguuccgcaccgcgccgcaccgcaggcccaggccugcpuccaggccucgcpuccaugcpuuccaucac\n", + "agugaugaaaacuugcuggaccagagaacagcuccapaaagcggcapagagguggucaaapaaacaaggaggagaauaucggcacccggauccggcuagacaagcuggauggcaggaaacgg\n", + "pauuguaaccacuuaggcccgcuggugcaaccugcgccuggccgacuucapaaccpapuggu\n", + "gccccgacgcgcaccgcgauucgccccaapcccugcgcaggacgcugacgcgaagacucggaggcggaagaaaaaaggagcuguuucuaggcuuuucuaggcgcccagccgag\n", + "acuuuguugguuupuagagccagaccagacagacgucpauucuguacuuccucacaaaugcuuucuc\n", + "gaaggaggagacaguuacugucuaucccgcagacguggugcucuuugaapauccuggccuucuacucccaggagguacgagaccuguuccag\n", + "aggcagcpaggapcggcgcgaaccauggccpacagcgagcagacccugcagaaccaccagcagcccaacggcggcgagcccuuccuuauaggcgucagcpaacagcuagcggcaag\n", + "guucccgcupauuccccaucuccaaccccgcaggcaaggacgccgugaccuugcaaggcaucccugagg\n", + "gagccuuugaugaagugaccucaugccuggugaaggugccagagaagacagaagguggcaacaac\n", + "gcgcucgagugupcpacugapaagaagugaaaaucggacugccaggcgacaguuccuccguuugaaaucucgccggcuccugagcpccaccpcccpcupucuggcgg\n", + "gagaaauaacuuuauuuggacugagagcuggagaaugagaauaggaccugagaguauauupcuaaggaggagag\n", + "ggacugapaagaagugaaaaucggacugccaggcgacaguuccuccguuugaaaucucgccggcuccugagcpccaccpcccpcupucuggcgg\n", + "gaaaagugcgcccuacgaaaggacggucgacuucggcpcccaggugagaaaggcccaccuguguccugguugapucuccapuucuuupcccgag\n", + "aaccaaucggaaggcguauugcugaaaagugcgcccuacgaaaggacggucgacuucggcpcccaggugagaaaggcccaccuguguccugguugapucuccapuucuuupcccgag\n", + "gacuucggcpcccaggugagaaaggcccaccuguguccugguugapucuccapuucuuupcccgag\n", + "gcguauugcugaaaagugcgcccuacgaaaggacggucgacuucggcpcccaggugagaaaggcccaccuguguccugguugapucuccapuucuuupcccgag\n", + "cuucggcpcccaggugagaaaggcccaccuguguccugguugapucuccapuucuuupcccgag\n", + "aggacggucgacuucggcpcccaggugagaaaggcccaccuguguccugguugapucuccapuucuuupcccgag\n", + "ggccuguccucccaaagccaacucuaaggagaggagaggaagagcaguucuupcagaguugacgca\n", + "agaucaugagccaucagcuccucupccagcuauaggacaacagaacucucaccaaaggaccagacacagupcacc\n", + "aucaugagccaucagcuccucupccagcuauaggacaacagaacucucaccaaaggaccagacacagupcacc\n", + "auccgcucaccaggcccuggcgaccugagcaucuacgacaacuggauccgguacuucaaccgcagcagcccgguguacggccugguccccag\n", + "ggccucuggugacugcaguggagaaguuugaggcagaagcugcagccuupccaacgcauaucaacacugcagaapcagcccuga\n", + "ccaacgcuacccuuapugcapacgcccccuguccagagcgucgucuucucugcaaccaaagag\n", + "agcaagacuucagccaggaucuaccccaccuaccacacagccuuugacaccuuugacuauguggacaaguuuuuggacccgg\n", + "aauaagagagauuuucugaugacccgacaggagugacuaucuccagucaaagaaagaggapugaauuuaaucuuuc\n", + "acucuugagauacugacuggaagauagacuguuuuguuccaccugauuguaupagaaauuuuugaccuuagaaaguggaa\n", + "auacggcuugguucugccuggacgcacagcaugccuggcugagagcuugaaacagaguucugcagaaaaacuguaaagaucccgagacauuucccug\n", + "acucuugagauacugacuggaagauagacuguuuuguuccaccugauuguaupagaaauuuuugaccuuagaaaguggaaaugagguugcu\n", + "cagagccacpcgcccgccccgccccgcgccgccccgcgccggcuccgcagcucgcgcccgcccgccugccggcccgcccggcgccpcc\n", + "gcgccgccccgcgccggcuccgcagcucgcgcccgcccgccugccggcccgcccggcgccpcc\n", + "cccgccccgccccgcgccgccccgcgccggcuccgcagcucgcgcccgcccgccugccggcccgcccggcgccpcc\n", + "ccuccccccpaggcuugcgaaggagaagccgccgcagaggaaaagcaggugccggugccuguccccpcgcc\n", + "ggacpcuccgcgcgcuccggcagcgcauucpuccccuccccccpaggcuugcgaaggagaagccgccgcagaggaaaagcaggugccggugccuguccccpcgcc\n", + "acuuccpucggacggcgcuagcugcagcaucggaguguggcagugcupcuggccggcpcupcugcggcccgcgcgcggccggcg\n", + "ggacggcgcuagcugcagcaucggaguguggcagugcupcuggccggcpcupcugcggcccgcgcgcggccggcg\n", + "apagacgauggacugagcugauccgcaccauggagucucpucuuacugagaacauucuguuugaucuucggucucggagcag\n", + "accgcgaggcggaucacgccccuaguccapucggapcugapaacuuugcagagagaapuuuaaaggagguc\n", + "ucuucaguucccaauauugucgcgaaaacgcgguucuuugcugcccuggaggaagagacuugcauuuug\n", + "agaaggauccaucuaacauuuacugaaauaaggaagaugcuuuauucaaucuaaaagugaaaaaagaaccuuuuagacauuauuauuauaaa\n", + "gugcuugccuuggagaccgcgaggcggaucacgccccuaguccapucggapcugapaacuuugcagagagaapuuuaaaggagguc\n", + "cgagcgcagcagcapcccgguccugcgccucpagucggcguccaggcucggagcgcgacacggagacuagguggcag\n", + "gaguucugcguccpuuugaaauuuacaucuuaagacaguguaggaagucgguguuuugaagguagcucaagugcaccggcapuuugaagcagcgugaagcuauugcccaag\n", + "agucugugcaauuuagaaacucgauaggaggcagcagcuggucucccaccacccuaaaaauaauccguuccggcgcacugcgugcuucgccuapaggaaaacugucaucgga\n", + "gaagcccccggaagccuccccagaagcuguugccggugcuaugcgaccuguacagccugcagaacc\n", + "gcacaauuccaccuuccuuugugcuccauuacucaagacacugaagacuccaaaaaguaguaggaaaa\n", + "uaaagaaaaggauagauuaaaaccuaaaaagaaagaaaagaaggaucccagcgcauuaaaggaaagagaagu\n", + "uccccaacacccuuccugcuuauuuuuccaauauaauacacagcupcccaccuuaccacauccucguugauaccaacuuuaucaacuuuuccauaaaagccaaacuggacuuagugcaguca\n", + "acggaagaaccaggaguuuggcgugaccauggugagagaagacgguccaagaapacguuaucaggccacuuuuupuggagaaggag\n", + "agcauuagacaccggapcaccupaccaacuucgcgaagcpaagcccggcppuppagcuaaagaccugcggccucagccccuccaaagaacapag\n", + "agcagagguaccaacuauagcuccacggccagaagauaccagcagcucugccuuuacugaaauuucaucuggagaaagguccacag\n", + "agucuuaaccpugugcpagcgcaguccpugcguapccgcucggcpccgcgcpcaag\n", + "caggcaucagcaagapaagauacuaucuuccupaguugacaguaccugauaauugaucuccuucccaucagauuuccaapaucaaggugccccgguucuaaacaaccacag\n", + "guacggucacauggcucagaaagcacaagaaguagagccccgaggucagaucugagaggcuucugapccgaugcagugacuucucugcugcag\n", + "aggcugacagaccagcccagauccaguggcccggapccugagcuaaauccgcaggaccupuaacacgaggaag\n", + "guuuacucccuccugucuagucggcuuggucccuuuapcuccggauaucuuuggugacuuguccacuccaguguggcauc\n", + "ggcuguuuacucccuccugucuagucggcuuggucccuuuapcuccggauaucuuuggugacuuguccacuccaguguggcauc\n", + "gacuucagacuccaguuuaucugugccccagcuuccucacuuagucucagaagacuuaggcugaggccucagaaggag\n", + "ggucagagugcagaccugagaccacugcucaccgacuucagacuccaguuuaucugugccccagcuuccucacuuagucucagaagacuuaggcugaggccucagaaggag\n", + "cuggcupcggugcugacugucgcpcugcgapcgguguuugcgucgcucaugcgcpcpaccucgcpcgcpaaagaggcagagcgcgcgcag\n", + "cgcgcggcauccgaugccauccgcgacuuacpuggcggcpcgcpcugcggagaggacuggugaccgaccgugugucugucpagcaaaagcugcp\n", + "guuccgcauuggcgugcugcapcgcggugcacugcgccgccaccgucaauagguggacccccucccggagauaaaaccgccggcgccggcgccgccagucccucuggcugagaccucggcuccgg\n", + "auuggcgugcugcapcgcggugcacugcgccgccaccgucaauagguggacccccucccggagauaaaaccgccggcgccggcgccgccagucccucuggcugagaccucggcuccgg\n", + "aaucacugcagccccccucgcccugagccagagcaccccpucccgccagccccucacacucccagcaaa\n", + "gcggccgccuuccugcupauccuguuugcccucgucugccggagcccgcgcgcccagccgcccgacuucgccgccgccuggagccggcuggccgcgaccucagccgcccgccgcccgccp\n", + "aguccuguguauggaaacucacaugagucagcucagucuagaapuaguaauuucucauaauauggauaaagcucugaaagaag\n", + "guaucaaauuguaguggaaauaauccaggcgacuacaauuagcagcuuuccccaacugaagaggcacaaag\n", + "agcacucugcgcgcccgcucuucugcugcuguuugucuacuuccuccugcuuccccgccgccgccgccgccauc\n", + "gaauagucaguaccuagaagccacucuucuuugaaaaggauuaucaccugaucagguucucucugcauuugccccuuuagauugugaa\n", + "agucgcggcccggagcugcggagcucggaucuucucccccgucuggcccgcucucgacccgcgcgcucugcupcc\n", + "gacagcgcguagucgcagagucapapaccucaccaccugucuccucccugaggucuuagaacagauacaagaaauuccaggcgaaggucccacag\n", + "gucucucgcugcagucagagcuccaggucugguucuucuccuaaaggcccaggcuguguggccccguguccugcagguauupagauccacagcuaagacaccpaccuccuggaagccaaaa\n", + "cuucuccuaaaggcccaggcuguguggccccguguccugcagguauupagauccacagcuaagacaccpaccuccuggaagccaaaaaug\n", + "cuuuugugcuucucugcgucccgagcuccaguucuuuucuucapcucugcauucucugcuccuagaggccaagccucuguggccuuguguccugcagguauucgcagauuu\n", + "agaaccgcugccucgcucccggaaguggapucuacacgaagcgccgcupucupugcccggaggcagcagcguucgcggaguucgcccgcuggcccccgaucacc\n", + "pcgcgacuagcagcagguggaacugcagaggaggcpcgcugaaguguuggagacagupucuucuagcacccggaggcupcugugcuapaapacuggagcag\n", + "gaucccucugugacccagcugaccaacgccccgcapcggccuggcggaauucaaccccuucucagag\n", + "acaaaugcagcgacaacaguuccugucacccaacucccupuccucacagccagcgguucuccagccaucaguggaaccaacccagccgaccccccag\n", + "gccguggugucugcagcccaggcaggccugcuccggcagcaggaagaacuggacaggaaagcugccgagcuggaacgcaaggagcpagcugcagaacacuguagccaacuugcaug\n", + "ugagacagaacaacuggcccccucugcccucguggugcccugugaagcccugcuucuaucaggauuucuccacagagaucccugccgacuaccagcggauaugcaag\n", + "cugccucgcucccggaaguggapucuacacgaagcgccgcupucupugcccggaggcagcagcguucgcggaguucgcccgcuggcccccgaucacc\n", + "ccucgcucccggaaguggapucuacacgaagcgccgcupucupugcccggaggcagcagcguucgcggaguucgcccgcuggcccccgaucacc\n", + "agugcugaaguaggcgcggacgugcccggugccuggcgcgugguagcaggcgcccggugccccggccggcgaagacc\n", + "gguugcugcaguuuuuccgcgauaguuupcaguuccgcgcguugcaggcccuucugaauuuccuggaccuacgcauuggauccucaaagaacug\n", + "cugaauaccacuagaaacauaccuguaaccagagacagcugauuauagcuuucugcagcaaggaagcccacguaccapcugucuug\n", + "gcacaauucugcuuucccaggaacugcaucacucaggacucugcaaguuuccagaaguaagapaaa\n", + "cccgccccguugaggcuuugagaaaggaguaggagccgagcauuccggcagaggaagaaaaacggcccaucuuuuagaguccgaccucuggaaau\n", + "guccacaccucugcaucccugcaccaggacucaccaagacgcccauccuggaaaaggucccccguaag\n", + "ucaacgccgcucupacgcgucaggcccagcgcacagccupcagcucagccugucagcugagcacpcgccucaapugcggcccucucagaaggaag\n", + "aaagugcuuggcagucccccccuuguucucugucucuccugcugccaupaagaagguccuugcuuccccuucgcguucugccaugauuguaaauuuccugaugccuccccagccacgugaaacu\n", + "ggcccggucgcggucgcggcucuuuccagcuccuggcagccpcacccgaaggaacpucgugcaacgacgcagcuggaccuggcccagcc\n", + "cuggcccggucgcggucgcggcucuuuccagcuccuggcagccpcacccgaaggaacpucgugcaacgacgcagcuggaccuggcccagcc\n", + "agcuaaggucaggacaagacagagugaagguccccuggcacugauguuacagaagaauucggugguaapcuucuggagaguggc\n", + "agcuccgapcggcuggcccggucgcggucgcggcucuuuccagcuccuggcagccpcacccgaaggaacpucgugcaacgacgcagcuggaccuggcccagcc\n", + "guuuaagucacaaucacuaagaagucacuuugaaaaaaauacuacuuuacacuaucauccaccuauuuugccuaaagaa\n", + "uuauaauaaggaauugccugugcauaucuguaauguaauaucuccugagaagauuuauguucagugguuguuaacugaaaacuuacuuaauag\n", + "acggccgcagcugcpugcggcpcgcpagcggupagcugugguggcggcggauggcccagagcugaucu\n", + "gaggaaaggcuuuguuuccguauuacacagaaugucacuuuguuccugaagugugaucucugguacuuaauaugcaagacaacacacuuuuuaagagguuauuucaagu\n", + "cucucccpauuuugcugccpcucccucucucugcggcccuagaguuaaucccaucagccgag\n", + "gcuuuucgcccuuccuuggccgccagaggcucccucucucucccucucccpauuuugcugccpcucccucucucugcggcccuagaguuaaucccaucagccgag\n", + "acugagccuuuagaaaapcpuucppagugagcugaaaaacucucccuagacaggaaagguagaagaccuccucaucccuuucucuuuggcagugagaucuuaaggucaag\n", + "agagcagcccucgcaguucagcaaguaacacaggacuaaupagcuguaaccuuucuccuaccagcuccccagacagapcaauucaugacauaguugaaag\n", + "gaaguaccuguagaccaggaauacupccagaagaaaaaaauacugucuaguuuagcaaauugcagaauggacagcacugaauguuggaacauaaaauuuuuaaaag\n", + "agcccagcccagcccagccccgccuccuacggccuucccuagaucapccapccaaagaccucccagcagaagaggagaagagguugugupacaagcugcucccgacagaag\n", + "pacaagcugcucccgacagaagguaccaggcupuggcapcuggaagguccuggccupaugaagapacugccuaaggcupuggcuccaagaugcuggc\n", + "auuuccucacugacuauaaaagaauagagaaggaapcuucagugaccggcugccuggcugacuuacagcagucagacucugacaggauc\n", + "agaacgccaccgacuugaggaagcccaguacauuucaaguuggucgcggcuupcuccgcuuupapcagcag\n", + "cuugaggaagcccaguacauuucaaguuggucgcggcuupcuccgcuuupapcagcag\n", + "acuguucucgcguucgcggacggcugugguguuuuggcgcaupcggagccguaguuacggucgacupcgucgucccuagcccpagccpucucuggagucgcggcccpuucacg\n", + "aguuacggucgacupcgucgucccuagcccpagccpucucuggagucgcggcccpuucacg\n", + "acggucgacupcgucgucccuagcccpagccpucucuggagucgcggcccpuucacg\n", + "caupcggagccguaguuacggucgacupcgucgucccuagcccpagccpucucuggagucgcggcccpuucacg\n", + "guaguuacggucgacupcgucgucccuagcccpagccpucucuggagucgcggcccpuucacg\n", + "guuuuggcgcaupcggagccguaguuacggucgacupcgucgucccuagcccpagccpucucuggagucgcggcccpuucacg\n", + "gaggcugaagupaggaucgcuugagucuggaagcuugagacugcagcaagcugugaucgugacacugcacuccagccupcaacaaaguaagauccugucucaaaagaaaaaaaaaaaaag\n", + "guggaagcaaauacugcacaugcguguugguccugugapaaaccagcuaguggagapagagguugaaggaacagaaaaaugagaagacaacucacug\n", + "cccuaccgagguccgugaggugugugcuaaccaapcggcucacaaccgugacagacugccauuccugagucucuucuggcc\n", + "uuuuuuucccccuaccgagguccgugaggugugugcuaaccaapcggcucacaaccgugacagacugccauuccugagucucuucuggcc\n", + "cccpugacugccgcaggcuccaucgcccuguggccugcagguauugcgagauuuauapaggacgcupacccccaaaagcupaa\n", + "gcupcuuuccagccucuaggugcugugcuguccugaggccupccauggugcccaaggaaagccccugaagcucaccaggaggaagaagc\n", + "ccucuaggugcugugcuguccugaggccupccauggugcccaaggaaagccccugaagcucaccaggaggaagaagc\n", + "gugcugugcuguccugaggccupccauggugcccaaggaaagccccugaagcucaccaggaggaagaagc\n", + "gcuuuaccaagccaauucacucaaguugucucaucuauaccccuucaaacccugugagguapapag\n", + "acupuucacgupcacguggcuccacuccggucacugcuuccupcagapaugacguggaagguagaccuappacapuugcuuccugccc\n", + "gguuccucucggagcggagacggcaaauggcggacuucgacaccuacgacgaucpccuacagcagcuucggcggcggcagagg\n", + "aguucaucauuuggcupcgcgguggcucacuccuguaaccccaggacuuupaggccaaggcpcggauuaccugag\n", + "gauucugcuauguagaauucgaugaaguggauucccuuaaggaagccuugacauacgauggugca\n", + "cuguupcgaucggucacuucguguggacauugcagaaggcagaaaacaagauaaagguggcuuuggauucagaaaagguggaccagaugacagag\n", + "gcuucapaugacuucuuapcapagguagucgcccaggcgaccggcgaacaggccccccc\n", + "cugguuccucucggagcggagacggcaaauggcggacuucgacaccuacgacgaucpccuacagcagcuucggcggcggcagagg\n", + "cagagcaagcugagccgagccgagccgagcupcgcagagcgcpaggcggcggcggcgcggagcccag\n", + "gccauuaggaucucacacucupuuuucccuaucuuccaucuuaacupaaacacgcugccaa\n", + "agagcaagcugagccgagccgagccgagcupcgcagagcgcpaggcggcggcggcgcggagcccag\n", + "cgaaaggaucucauucugccacccaggcuggagugcaguggugcaaucauaguucacugcagccuccaacuccupcucaagccauccucccgccucagccuccugaguagcupacuacag\n", + "auuuuucuuccuggccugguucccuugccuucuccauuugcuucauucgcuuggauuuucaagaagcuuugaagcuggauaggagucuccagucuuccucuugauccauauguuucag\n", + "guaaaagaaugucacaugucagcauuuguaccugaagucagcaugcaaaguucapuaccuggaugaaugccaacuuuugcauuucccauguguauccugugaccauucuaucup\n", + "aacauccuucaaagaguucaugcaucuuacugaggacaccugaccuuuugaagcuucauaauucacaucuag\n", + "cgugaucgucgacucagcugacccugcpaccggaaaaagaaauucccpcccuggcuucuuggcgcg\n", + "acucgagcagccgccgccggccggacggacgccgcucccgccgccuccgcuccgcccgccgcgccgcgcgcccuugcucggc\n", + "upuuugucacaacugagaacuauugcugapuguauaauccuaugugaaaacuuaauuucuuaauugcuuguauccaaaauauagacacagugcuagaugcugguuuacuu\n", + "ucacuggaaaagguccacauuuagugaacgcgucgucggccuacuuuguugugagcccgccucugcaguguuauag\n", + "gupupagaagccpaggacupugcgccugcapaucggaagccgguupugugagagguuuucucgcucuag\n", + "agcuucccacccccgccgcccgccgcggcccgguaccaacpuggucucgccgapagcugucgugccucguggucccpacugcaguggugugcgcucucggcgcguggcgcuaggc\n", + "gcgacgguagcucgagacccpacuccgcccgccuccccgcgaguauuugagguccpcggcuccggcgccucugcccgccguucugcucgcucgcuccccgcucugga\n", + "aacaccaccgauagccacaccgaagaguucucccauuugcugguucccggacaaaaaagcugcugaucccuugagcacacugcagugaagcucccagcugacauguccuguccau\n", + "auacuuucuuucaauaaaaguggcggugguggagacauccaccapcuuccagucucuucucaccgaagugaacaagacuggcacgcaguacuugcuuagg\n", + "gacccgaggaccccpcgcccaggcccagcgcccacggaagaggcggccggcgcpaupcggcgcagagccucccpccacag\n", + "cuucgcgcuccggacpcgacgguagcucgagacccpacuccgcccgccuccccgcgaguauuugag\n", + "aacaccaccgauagccacaccgaagaguucucccauuugcugguucccggacaaaaaagcugcugaucccuugagcacacugcagugaagcucccagcugac\n", + "aguucugagguuggagguuggaaaupuuccgcapccaggcuccuccagaggauccuccuugccuuuccagcuacugcagcugugguccuugcguuucuuggcuugaggcccuucaucuucaag\n", + "auucuucuucuugagcagcagcucagaaagcgcauccgcccugcguuucaagcccagcuacuucuuagcuucacuuccgucaacuucaccuucccuguagugcagupcauugaug\n", + "gcpcugugaccccagcagucccagcpcpcccpcgagcguccggcuupuucccuuccggagccucgcagcggcagagaacggcgacgcggccgg\n", + "ccagcpcpcccpcgagcguccggcuupuucccuuccggagccucgcagcggcagagaacggcgacgcggccgg\n", + "ggcggcuccggcgccucugcccgccguucugcucgcucgcuccccgcucuggaguacgugucuggcuupagccgcucggacacgcuggcuugg\n", + "guaggcguggccuucgupuggucucaucuuggcacugcugcugguacccgucaacaaagugauugccacccgcauc\n", + "gauguuucugcauugaauagcccuggaagacagaauucuugucucuccaaagaucuggcagacuuauucccaauuauaagagau\n", + "ccuugcaaaggaggugucuugcuucaccuucaccuuccacugugauuguaaguuuucugaggccucgccagccaugcggaacu\n", + "gaauaggacuagcaacuucauagacgguugugaagacaagcuagacggcagaugaaaguucuuggcacagagugaacacuugauaaacuauauggcag\n", + "ccacagccuccggagccguugcacaccuaccugcccggccgacuuaccuguacuugccgccgucccggcucaccuggcggugcccgaggaguagucgcuggaguccgcgccucccugg\n", + "auuugcggccpaauggcagagaucgccccccaggucugcccggcgcucapaauugguggcagcgucuauuucagaguuuaug\n", + "paaccucaggcccgcggaupagaaaccagagaugccaacuuccugcuuccgaaguaguggcupucuuaaagcacc\n", + "gugaaguggagguucuggauccgaacgacccuuuaggaccccuugaupcaggacggcccgauuccaacucugaaag\n", + "cucugcucaccucauccacpagacggaagucuuggcccugcuccgcucccccgagaaucpccucgcccugcupcggcuggaccupcaaagccupcgcgcucccgcgcagcggcgcc\n", + "gaguccagcccapcuccpaccguuuguaguuaggauccgcuguggcguccugaguggaguuupaccccapapapugupcguucpuccagaggagcuguuuag\n", + "cuguggcguccugaguggaguuupaccccapapapugupcguucpuccagaggagcuguuuag\n", + "paccguuuguaguuaggauccgcuguggcguccugaguggaguuupaccccapapapugupcguucpuccagaggagcuguuuag\n", + "ggucucaauccauugcgcccaggcugguaugcagucauguuguaucuggaauuggupuucuuggucucacugacuucaagaaugaagccgcagacccucgug\n", + "ccugcuccgcagcpaccgcguagaccucagcuccccgagcagcgcaggupccapaaggagaggaccgaggcaagccaccacgcpauuap\n", + "gcuccucaccccgccugcuccgcagcpaccgcguagaccucagcuccccgagcagcgcaggupccapaaggagaggaccgag\n", + "ccaggcuccuucucuauaaagupaucuaucaugaccagccuaccuuaucaauauaggagagaaaaucuuc\n", + "gccgcagccgccgcuacaguccpccpcuccaccgcgcauccugcuccacucuggcgaccgcccccpcccccgccgcpcgcggcgcccgcc\n", + "agagccgcagccgcagccgccgcuacaguccpccpcuccaccgcgcauccugcuccacucuggcgaccgcccccpcccccgccgcpcgcggcgcccgcc\n", + "agccgcagccgccgcuacaguccpccpcuccaccgcgcauccugcuccacucuggcgaccgcccccpcccccgccgcpcgcggcgcccgcc\n", + "cuacaguccpccpcuccaccgcgcauccugcuccacucuggcgaccgcccccpcccccgccgcpcgcggcgcccgcc\n", + "agccgcagccgcagccgccgcuacaguccpccpcuccaccgcgcauccugcuccacucuggcgaccgcccccpcccccgccgcpcgcggcgcccgcc\n", + "cgcuacaguccpccpcuccaccgcgcauccugcuccacucuggcgaccgcccccpcccccgccgcpcgcggcgcccgcc\n", + "ggcgcugcguuggcugcggccuggcaccaaapcggccccggcggagagcggacccaguggccucggcgauu\n", + "acugaaaagcggaggaagcucucuggagaaacgccgugaggccgcuggcpccuuccuggugucapuuaccg\n", + "guucgccugcgucgcuccpagcugccgacggacggagcgcccccgcccccgcccggccgcccg\n", + "gcuguucgccugcgucgcuccpagcugccgacggacggagcgcccccgcccccgcccggccgcccg\n", + "ccacaacgcacugaagcugcgcuucccggccgaggacgaguuccccgaccugagcgcccacaacaaccac\n", + "gagacagaagguuguguupaacugaaggaguuucugupcggacapaacccugcguuucuacugugugauucugccaccuuccuggcccgacgcc\n", + "cuggugcgagaauccugagaacugugcuccaguucuuagapcucucapacugugguccucuauuccuugucuuuacaaupacugguccaagu\n", + "guauuuccggagucccuucugagacagaagguuguguupaacugaaggaguuucugupcggacapaacccugcguuucuacugugugauucugccaccuuccuggcccgacgcc\n", + "uguupaacugaaggaguuucugupcggacapaacccugcguuucuacugugugauucugccaccuuccuggcccgacgccaupagugacuug\n", + "gaaggaguuucugupcggacapaacccugcguuucuacugugugauucugccaccuuccuggcccgacgcc\n", + "acagcggcggccggagcagacgcpauggucgcgcguccccugcacagcacagapcagccggagagccupaaag\n", + "guaucauugcccagugccuaagaucuuuuauguucagcucacuguaggaaauaaugaauuuuuupaaggaaagacucgacaagcugcuagacacaaugcugca\n", + "agcpucaguucucuguaguguuugccaauguuggagccgucugcaaaguguccccggcaagaag\n", + "aggcugccuaccacaaggacuuuagcuuacuuuuuaaagauugaagaaaaaaaagaagacagaaaaagaagaacucaaagauacacaaaguaauuugaaccaaggcucagaag\n", + "agcccgapuggaagccggcggcggccgagcpucaguucucuguaguguuugccaauguuggagccgucugcaaaguguccccggcaagaag\n", + "pcpagcccgapuggaagccggcggcggccgagcpucaguucucuguaguguuugccaauguuggagccgucugcaaaguguccccggcaagaag\n", + "uuuuuggagccgugapauacagcaguuuggucaauauugucuuaacaugcuucaaauaaaucag\n", + "cpagcccgapuggaagccggcggcggccgagcpucaguucucuguaguguuugccaauguuggagccgucugcaaaguguccccggcaagaag\n", + "uguuauccuauuuuuugugauuuagaauggugaaucaggaaaggauguggaugaugacaaagaugcaaauaagucugagaucagcuuaguguuugaaauugcucugaagcgaaau\n", + "ggcpcggaggcppcpagcccgapuggaagccggcggcggccgagcpucaguucucuguaguguuugccaauguuggagccgucugcaaaguguccccggcaagaag\n", + "gcgccucccucuguuccucccaaggcuaaacuuucuaauucccuucuuupcucpcucccggagcapcgagagcucgcgucgccgg\n", + "aaaggaagacpaagaaapcaggcggcucggcpcgucuucuccacuccucugccgcguccccguggcugcapagccggc\n", + "augagcagaggcgccucccucuguuccucccaaggcuaaacuuucuaauucccuucuuupcucpcucccggagcapcgagagcucgcgucgccgg\n", + "aaacuuucuaauucccuucuuupcucpcucccggagcapcgagagcucgcgucgccgg\n", + "cucccaaggcuaaacuuucuaauucccuucuuupcucpcucccggagcapcgagagcucgcgucgccgg\n", + "cucgacacccaaaccucaacauaaaucaaacacuuucccpcagagaaugucugugucaggcaagaauuagagacaagcggucagcagagccucagugcugaucgucggagcuupagcaggaag\n", + "gaaacacaagacugaaacugugaagguuucuggcaccacuuuuugauccucugaapccuuggaaaucagacgaccccaaucccaucgaggcuuucuaucuucuugccaaaaggaacuucuuuaag\n", + "uuucaggucugugcggcugcuaaagaacgacccagucaacuugcagaaauucucuuacacuagugaggaugaggccuggaagacguaccuagaaaacccguugacagcugccacaaaggcc\n", + "aggagaugugccaaacuguuaagagugguuauuucugagcagaagaauguggaugaauuccauucuuccuauuuuucu\n", + "gacgacacggcccapaggaaagaacucguccaaguuccaugccapagaugcggagcupauuugaucaag\n", + "aguauupaugcugagcugcpuacpccugaggapaupaguaagaagugcuguggaaaccgucaggcc\n", + "ggagucgaccgcucpcagcgccaccgccacgagagcccpacgcpaaagaccgaaaggaagaggaagaggcaccgguggcc\n", + "guucccaggacggaaguggccgagagagugucgaapapcgaggccggagcccgapcgacccgagaagcggcpcggcpccggcpcpcgcagagccaggcagcgcag\n", + "acagacccccaacuugcagcugcccaccucacccucagcucuggccucuuacucacccucuaccacagac\n", + "cuucccccucpuggaaacaaapuucggcgcgcggugcggagccupaaaapaggagcgcuccgguggucuggcgcgcupcucgcuag\n", + "agugaagauaguccaaguccuaagagacagcgccucucucauucagucuuugauuauacaucagcaucaccagcucccucaccacca\n", + "ccucaucacugucaccuuagagcauuagagccucuauaggugcuccccaaucucugcccuccccaccc\n", + "pcuguagcuggugagaggaaguccuagaggcuauggacacucugcugcupaucaccgag\n", + "gaagccucaguuuuggagaggaagagccaggcuuuagccucccaucucapucpauuuuugacucuaccucuccccacag\n", + "cpapaguagaggccpcagapcgapcgapcagapcgcuggcggcagcggccgcggaag\n", + "pucccagaacugaguggaguaggagacpcuguagcuggugagaggaaguccuagaggcuauggacacucugcugcupaucaccgag\n", + "gagaccgcccagcgcugcggagcpapaggcuucgcggaacgcucucggcgccaggacucgcgugcaaagcccaggcccpcggccag\n", + "gcagcguagcaaauccaggcagcgccacgcgcggccpccpcggaaccgagaagccpaccgcgcugcgacgcgccggccgc\n", + "ggcagccgcgcccgcupccacagaggccgcugaggccgcggcgcccgccagccugucccgcgcc\n", + "pcaaagugcuacuggugaaaaaugaagaacaaaccuccugacugagaaaggucagcucugccaaacaaguacgaaagcaagaaucaaacaggaagaaagguuaggaacacaaaagcgcagag\n", + "gcagcuccgcggccapuggaaggaagccgcagccgcagccccaagucaacccccgcugccccgucccaccgucucaucucuccccccucg\n", + "cagagacpuuucaccauguuagccaggauggucucgaucuccugaccucgugauccaccugccucggccucccaaacugcupauuacaggcgugagccacugcgcccugccugg\n", + "gccuucuuugcagcuccgcggccapuggaaggaagccgcagccgcagccccaagucaacccccgcugccccgucccaccgucucaucucuccccccucg\n", + "gaacaucugcuacuacagccuugcagcccggagucccggauuuuacugguucccgugccugcggacaggcccccapcuagcggcuuuguggapaacacupuauccucuccacaguccag\n", + "gugcupaggcccuccuuggcuuaggaggacacuuccaaagcupcgccccaaggaggcaccaguggccaga\n", + "auacapugaggcacagugaaucugcuggaccagcuucaagaacaauaugucagccuauccacugccaccucccacagcuccagacucgupugcuuccuggaugugaccagccauag\n", + "gcgcapapcpcgccgcgcacgcgcacpccggcggcgcgcgccgagcppcaccgcgcpugcagccacg\n", + "agauaauugguucuacaaaucuuauaauucugcuagaggaugaagucuuugccgauuuuuucaacacauuucuuucccucccg\n", + "guuuuuggucagacaccauuuuauacuguugaaaauucacaguggagcuuguggccagaaauaccuuguaacuug\n", + "aagccagagugagccucuuaaaaaguaauuggugguggugcuggapacucccaggaagaugaugaaauaggaagcacuaggaaucuguuuccucaucuagacaacaauu\n", + "agucccuccugaaccucuccaucuggcaucccaaccaaucaaccacuaggapagauccugagccac\n", + "gacaapugucccccaccugaagacggcaagcupuccugagugaugccccucagcugaguguccaaggcuggcccgaggagcccccacggccccaccuuucccc\n", + "auauagagcaggcgccgcpucgcagcacagugcggagaccgcagccccggagcccpccapuccaccuguccccgcagcgccggcucgcgcccuccugccgcagccaccg\n", + "agcaaucagcaugacagccuccagccaaguaaucuggagucaugagagcugcuapagcaacaugaaucaugacggucccupaauuuccugauaacuaaccupaguuucp\n", + "acagugcggagaccgcagccccggagcccpccapuccaccuguccccgcagcgccggcucgcgcccuccugccgcagccaccg\n", + "gaggcugauuaaacaaacgacaagauuggagupaaaugagaggcucuuaaaaguggaagcuuuuuguuuguccauuuacaagaaauuggaca\n", + "pupcuguggccgugucuagcuguucpugugcuguggucauccucccugcgcaccuacagccgcagaccgccgguppcp\n", + "acauucacggcaugguguaacucccaccuccggaaggcpacacagaucgagaacaucgaagaggacuuccpauggccugaagcuc\n", + "aacucagupuuggaagcuguaaccccgacaupcuugcgcuacguccugccccuccgacccccpaaaggupcagcucgguucgaguugapcugcagaacgagg\n", + "gcccuacucccuccccacgccapcagcagccguugcucagagagaagguggaggaagaaauccagacccuagcacgcgcgcaccauc\n", + "aaaggcauccuguauuagcucacucaggaauccuaggcccugaaacggagcccuuuuacucacuucaucagacaggcagag\n", + "uggcuccgaagucgcupuacacggcgccuccuccgagcgacacgcgcpagcupcupcuguucggcgcugcucgaagcuucgucaccgucgcccugupugca\n", + "cgccuccuccgagcgacacgcgcpagcupcupcuguucggcgcugcucgaagcuucgucaccgucgcccugupugca\n", + "gcupuacacggcgccuccuccgagcgacacgcgcpagcupcupcuguucggcgcugcucgaagcuucgucaccgucgcccugupugca\n", + "pcucpaugcpcupacccucccgauuccpcggauuccggacgccpaccggccauuacuggugccpuupcuucuccagaugccpcupuccuucccaagguugag\n", + "caacguguggcggcucgcgacccccggcaacccggagaaggucuacagagcggccugcgccagcga\n", + "aacguguggcggcucgcgacccccggcaacccggagaaggucuacagagcggccugcgccagcga\n", + "guugaagaaaaaaaacaacaaccuaggaucaguuupagaauugauauguuuacuauguugaagcuuccaaccugupcaug\n", + "ucuuacuguugcucaggcuggaaugcaguggugcgcucucggcucacugcaaccucucccuucupuucaagcgauucucgugccucagccucccaaguagcupauuacag\n", + "ggccugcccuggauccuggaggcuacacagcugcccacuccuccupaggcugccguggaggcc\n", + "ccugcugcucuuuguggcagucgcaguccuuuugupaguccggucuguccacuugccggucccucagaccgucggcggucucuguccgcuucpaccuguccgcuggucgcuccgcguccg\n", + "ccccggccugcggupcagcagcucagguucuccaaaucauugcguaguuccgaauacccucggccacaccuggccuucucc\n", + "ggauccagcaccggcuccuccuccggcaaccacggupagcggcggaggaaauggacauaaacccp\n", + "ccggccugcggupcagcagcucagguucuccaaaucauugcguaguuccgaauacccucggccacaccuggccuucucc\n", + "guuacuuuauggaauupcucuuagagaacaagaaaagacugaaguuuuacpaaaacaaaucauguggucuucagauucugaaauaaggagaa\n", + "auuacagccacggccuucaggagugaccauagacgaauccuuucucacagaagacaagagcacccagaaucgcaagcuucuucagaaacgaaggacgcug\n", + "gagcugccagcagcaccccuuucgcacugccaagccccaguacuuggaggaacuggaaaacuaccuacgcaaggagcuccuccugcuggaccupcacagauuccacccaggaacuaaggcugcag\n", + "cccaccaaapagaagauucpcucuggagccccugaaggccaagcuugucacugugaaugaggacugcaaugagaggauccuggcc\n", + "aaagcaagugauugcuuuccuuuccucauuuuuggaagcccugccuaacacacagcugcacuguacaucccaguuccugg\n", + "ggagucpccccpccgccaccgucaccucggccgcugccgcugucgccaucgccuuguuuccccaucccccgcc\n", + "agucpccccpccgccaccgucaccucggccgcugccgcugucgccaucgccuuguuuccccaucccccgcc\n", + "guucauguapagucpccccpccgccaccgucaccucggccgcugccgcugucgccaucgccuuguuuccccaucccccgcc\n", + "guuccuuuccucacagcaacagauaccacacuacagupacaauuuagacacuccuguuaaccuaacgu\n", + "aaagccacggcaaccgccaacacagaacccagccccccaccccgcucccauuuccucauucuuapuggcugcagcuggccccuccagcupaucuggacuapaacggagcaag\n", + "gagagcgcggagagcgcgacacgugcggcccagagcaccpccacccgguccccgcaggcccpaccgcgcccgcuggcaggcgacacgug\n", + "gucacggugauccauuuguaaagucpaauaaaugaccucugaaguguugucuguauauugaucugcuaccaguaaaacauaucucu\n", + "agagagcgcggagagcgcgacacgugcggcccagagcaccpccacccgguccccgcaggcccpaccgcgcccgcuggcaggcgacacgug\n", + "paacgcccgagcgccggcagagagcgcggagagcgcgacacgugcggcccagagcaccpccacccgguccccgcaggcccpaccgcgcccgcuggcaggcgacacgug\n", + "gagcgcgacacgugcggcccagagcaccpccacccgguccccgcaggcccpaccgcgcccgcuggcaggcgacacgug\n", + "gcucuguaauugaccccapcapaccacggccgucgccgapcagcpcapcggagccpccgaccgcgcacucagga\n", + "aucuuaauauuugccagugaugccugcaaaaaugugacauuacauguucccuccaaacuagaugccgagaaacuuguugguagag\n", + "guccuaaagaaaagacauacuaaagaaaaaguucuaaggcgcgccaagagaagaupcuccaauuccuuguucg\n", + "ggcapaccacggccgucgccgapcagcpcapcggagccpccgaccgcgcacucagga\n", + "aggaacgguggcgcpcggaggcgacagcgaggacccaaggcupuuuccugcuuggaucaggagugccupa\n", + "cuccgagacgcuccupcugcgcgcgcuuuupcugcgccaccgacagagacaucuggaagccggagcuaguggaaga\n", + "cucugccucaccugccuccuugaaggaaacacpaagccaggacuggccgucacguuggugacaaau\n", + "gcgcpcggaggcgacagcgaggacccaaggcupuuuccugcuuggaucaggagugccupa\n", + "uuugauccccauccuggugcagcuccgagacgcuccupcugcgcgcgcuuuupcugcgccaccgacagagacaucuggaagccggagcuaguggaaga\n", + "gacccgaggapaagaggacuccaagcgccauggccgcugccgcccgagcccpucgcguacuugcugaggcaacugcaacgcgcagc\n", + "guagcuguggacccaguccuuaauuaguuugguggauacugccuaggaaaagaaaugauagccacugugugaggccaacagguugaucuuugcaccugccugguucccagagaaccugag\n", + "acugagcguaucauguuaaagaugagcpuggcagcgacagagccaaaaucagagcuggaaccugaggagagag\n", + "gaggucagagacuuaagucuaaggcacugagcguaucauguuaaagaugagcpuggcagcgacagagccaaaaucagagcuggaaccugaggagagag\n", + "caccaaagcagccauaaacaauauguaaauaaacagauguggcuguauuccaguacaacuuuaccuacaaaaacaggcaucagaccagcuugccaacuuguggcauagacuguuugcuac\n", + "agagacuuaagucuaaggcacugagcguaucauguuaaagaugagcpuggcagcgacagagccaaaaucagagcuggaaccugaggagagag\n", + "uacaacuuuaccuacaaaaacaggcaucagaccagcuugccaacuuguggcauagacuguuugcuac\n", + "gucagagacuuaagucuaaggcacugagcguaucauguuaaagaugagcpuggcagcgacagagccaaaaucagagcuggaaccugaggagagag\n", + "agacugucccgagcuucccccpcpcagapaagccggcupaugaggaguggaggaggcaggaaugccupacacucgcpcaugugagcag\n", + "cccguggccacccaggagcccgaugugcaaggcaggugugagugccaggacggcauuccuggagaugaaggccuggagcugcggucugcggacucggcagugcccguggcc\n", + "cpcgugcggagcpcgacaguggcgupaucugccucucugcgagcagcupagcggcggcggcggcgcc\n", + "auguupucugaagcggcugcuguaggcgccgacggagcgagcpcgugcggagcpcgacaguggcgupaucugccucucugcgagcagcupagcggcggcggcggcgcc\n", + "agaacgcggagagucgccgccuggccpcguagacgcgguggcagagcccgcgcggcgcuggaagcgaguggcggagcggcpaccucggcggacucgcc\n", + "aaaagcgagugaagagagcgcgacggcggcggcggcggcggcgcagcuauugcuggacggccagupagagcgaggccugagccucugcgucuag\n", + "uagagacggugcuagccaggaugaucuccaucuccugaccucgugauccacccgccucggccucccaaagugcupauuacaggc\n", + "agugcggagcgccucggacgapuccaaccgccggcaggcaccagapcacggcuggcucggcacupapcccggcgcucgcagccccccacgcccagagaggaugc\n", + "ggugcgcccugagagccpuagccucggauagcggcgcugcguacgcgaugauggaugagccguggupaapcgcgucgccucggacguccacugcacccugcgcgagaag\n", + "cggccggagccgugcgaguucucuacccugcuucgcgagcpcgagagaacgcgagucccaggauccccggcacccaguucucuuccacugcauucccccggcgcgugupaccgagguggac\n", + "auagucauuuuuacuugaaggaagcugcuucuacuupaguggcaggagaagugagaaaaccac\n", + "cacagcgcgaapaaacuucgacacuggaaggaacgagaauaaauacuuaauuacggacgcacugaaccgcggcupacagacacuucpaacccgaggcggaccpcgacgag\n", + "acagcgcgaapaaacuucgacacuggaaggaacgagaauaaauacuuaauuacggacgcacugaaccgcggcupacagacacuucpaacccgaggcggaccpcgacgag\n", + "auagucauuuuuacuugaaggaagcugcuucuacuupaguggcaggagaagugagaaaaccacauggaagacucccaggauuuaaaugaacaauca\n", + "gucuauggaaaugcaggaccuagcaaguccucauacucuuguuggagguggugauacuccagguagcuccaaacuggaaaaaucuaaucucagcagcacaucaguuacuacaaaupacaggag\n", + "ugucucuucuugcagucaaaacagagcccuugaacagcagugaaaccacagccacgacuggagauggagcgcuugacacuuuuacupucag\n", + "uaauuacaaguaguggcuacagccccagaucagcacaucaguauuccccacagcuguauccuuccaa\n", + "gauuccuacaggaagcaaguaguaauugauggagaaaccugucucuuggauauucucgacacagcaggucaagaggaguacagugca\n", + "uuagaaugcuagguuccccaaauccucaccaacucuguacaacuuaaugaaguuuugauguaaaau\n", + "cugucpuuggcaggacuguuuugacaccgauuggccgaguuuugcggagcgcupcagugcuguupagagugcucupaagaauaggcaguuuuc\n", + "paacuacaauucccggcpcugugagaugccuuggcuguaguuaguaaggagccggaugauugccucagcag\n", + "gaaagaaaaggaacagccaaaguggacuuuuugaagaagauugagaaagaaauccaacagaaaupauacugagagaguguuugaggucaaugcaucuaauuuagagaaacagaccag\n", + "caapcaaguauuuuguaaccuucccauauccauauaugaauggacgccuucauuupacacacguuuucuuuauccaaaugugag\n", + "uuugcuguapuaccagcgauugaaaggaaaauguugucuguuucccuuuggccugcacuguacuggaaugccuauuaag\n", + "gcaugugcugauaaguugaaaagagaaauagagcuguaugguugccccccugauuuuccagaugaagaagaggaagaggaagaaaccaguguuaaaacagaagauauaauaauuaagg\n", + "uuaaagcaggaguuugaauucugguauccuguugaucuucgcgucucuggcaaggaucuuguuccaaaucaucuuucauauuaccuuuauaaucauguggcu\n", + "ggagccggaugauugccucagcaggugugaagcgugugcuuuaguuucgupaggccuggcauccccgagapapaaag\n", + "agagaaccuggagccuaagguuuaggcucacccauuucaaccagucuagcagcaucugcaacaucuaca\n", + "ggcccaaaccaccaapuaccacgcuuuggaaaguucaagauuuacacccauagcaacauucuucucagacaccuucagaagcaccuuuuccugccaccguaag\n", + "uuggaagagcagugapuccauguuaagguaauucauacuuucuauuuucacagaaaugccuaaagaaga\n", + "gcapcaaugugagcagccaggccauccugcccaccugguugcccuucaggaccacgguguucucagaggagaagcugacuuucucucugcgucug\n", + "gguggagccagccauccugagacguccguacagcccguacugguggagugucaggaggccacucug\n", + "aapugaaapagcgagcaccgauagcaagguggcagccugcacguccgcuccgapcccuucccaggagcggcuggaucugaccgauccccaaguccag\n", + "ggcagupcagccaugccgagucaugaagguggcaugcapaupaaaugcugccuuaggag\n", + "cpagccagcccuggagacggcgcuccuagccgcaccugcgccuggcaggcggccggcucugcccagccccuacccacggccccggccccgcaccg\n", + "augcagaggaggcccagcugcugagaggaguugccugagagugaccuuugcaucugccuguccagccagc\n", + "agucacccaggaaaagcgaaccgcgccaggcccugucaucgaccgcupuccguccucccagcgcucgcggccgcucac\n", + "aucgucaucguggucacuggugccacpccucagcgcagcuucugucuuaagcuccupccuccuuauuuuccccuuugcgaucgauuccagccacaccugugg\n", + "cggagucaugugaccgccgucuugacaguguuccacpcgcugcuuccugccupuuuggaguugucaccacuuuccccucuccgucuccugcpcgca\n", + "agucaugugaccgccgucuugacaguguuccacpcgcugcuuccugccupuuuggaguugucaccacuuuccccucuccgucuccugcpcgca\n", + "caugugaccgccgucuugacaguguuccacpcgcugcuuccugccupuuuggaguugucaccacuuuccccucuccgucuccugcpcgca\n", + "guuugcuggugaggcccaugacccgcuaguugaagcacuaguuacagaagcauggagaaggcuagaaag\n", + "guuugauauuaaacugcucucagaauuuuccucuugccuagcagaucagcauuuguauuuuaguccauua\n", + "agagccaucaugugagucauaugaaagcuccacgcugcugaccucuggcaaaaapagagaacaaggauaggagaggcagupaaagguucaagugcpuuuucuccuugaaccuacaagauu\n", + "cugccucguuuucaguugugcacaucugaaugcaagcaaucccugucugauguggaguuucuugcacugauaaggaaaaacugcugaaguugugaggcugcuccaggcagagccaucau\n", + "cucuggcaaaaapagagaacaaggauaggagaggcagupaaagguucaagugcpuuuucuccuugaaccuacaagauu\n", + "gaucuugcucugucacccagucugaagugcuguggcacaaccauggcucuaugcagccuugaccuccugaacucaagcaauuguccuaccucagccuucccaguugcuaggaccacag\n", + "agagcgapcaggaggupugcggcacggccpucgcpcucpacuaccggcgagg\n", + "gcuggaguucuguggcguaaucacggcucacugcagccucaaccucccagacucaagcgauccucccaccucagccucccaaguaguupacuacag\n", + "acagaagaaccugccagccugugaugauccuaccaaagagaaaccucaaugaguuacggaauuuccuuuuuggugaauugagugcuguuuuugcuuuucucagauuccaa\n", + "gcccccgccccgcccgguccagccagcucggcccpcuucpcugucpccggcgcucccuucucugccagguggcgaguacaccugcucacguaggcguc\n", + "agucucugcuuucuuuuuccuuucuuccagaaggagauuuaaccauaguagaaagaauggagaacuauuaacugccuuucuucugupcugugauuuucagapaaugcuaagag\n", + "aucuuguucucagaggccauucccagacccacagcaagapauuauggcugcaggccucaugcuccuuuguuuuggaagaaacuguugagga\n", + "caccacuccucaagccccagccagcaccaugagcggccgaguuggagaccugagccccaaacaggcagagacccuggccaag\n", + "uuccgagaaaacguccaggaugugcuuccugcccugcccaacccugaugauuauuuccuucuacgcuggcuccgag\n", + "aaacuaggcuuggccucuugccuauaguggccaccacuccucaagccccagccagcaccaugagcggccgaguuggagaccugagccccaaacaggcagagacccuggccaag\n", + "caguuccgagaaaacguccaggaugugcuuccugcccugcccaacccugaugauuauuuccuucuacgcuggcuccgag\n", + "ggagccaccagcagaaccucuucaauaucuugcauguuacagauuucacugcucccaccagcuuggagacaac\n", + "uuuccugaggccggacucaacpucucggcugagccaccpugagcucaccgcccagcccaaaccaggagauugcgapagcgaugcggugcagcgcg\n", + "guucgacgccaggauuggcugcaaguapagcuuucgccgccgccccpccccucggacugugccggcgccgcacccgaggcucucgccagcccggcgccccggugcugag\n", + "auuaaagguuauacaaaacuuaaaagaagcagcaauucuauucgcuuguuauuggacuugaaacucccuuugaccucggaaacugaag\n", + "upugaaaaagaacagugugucaugaagacaggcaccuggaggugauuupuggcauucaugagaaaauucacguuaccc\n", + "aaguapagcuuucgccgccgccccpccccucggacugugccggcgccgcacccgaggcucucgccagcccggcgccccggugcugag\n", + "acuucgcuaacugaugaaacacugccagagcccacuuggacuguuucgcaacuuuacuuaapaauaaaagcucucaugcugag\n", + "acugagguauuccuuccccucucaggacuagccacaugcugucucucugcccuggccucuuccaccccaugcccagucagagaccguuuugagg\n", + "agccacaugcugucucucugcccuggccucuuccaccccaugcccagucagagaccguuuugagg\n", + "cauugcgacugcccuugguucaguuccpaaguguggcugcccuucugagacccucaacugcuccuccugccaccacacagccgacgaauggaacuggcuugaugcgugcuccaggaagacu\n", + "ccuaccccucuuguauucccauggaaggagcugaguauauuuaauauuaggagcacauccagaagucuuugaagap\n", + "acagccaggcagccccgcgupagugcaggugguuucgguugcggcagucgcgucccpagcgucgcugccuggugaacg\n", + "gaccagcccagcauccacauagucuacacagagcuccccuugcugcccagacaagcugaaggaccacag\n", + "cuguccucuccuuccccugaccagcccagcauccacauagucuacacagagcuccccuugcugcccagacaagcugaaggaccacag\n", + "aggauupcuggucaccacaaagacccaagugauuagaaaguugaaacuuuuggccccaccaaucugcaggaapagag\n", + "gucacuggaguucuggaugauugcuugugugauauugacagcaucgauaacuucaauaccuacaaaaucuuccccaaaauaaaaaaauugcaagagagagacuauuuucguuauuacaag\n", + "guuaaucugaagcgaccuuguccuuucupcagaagauggccacuguucaauaaaagacugucauguggagcccuguccagag\n", + "gauucagugguccugagccuucugaaguuaggcuucugccugguggupauccugacaucaaggaupacacccuggaug\n", + "gugauuguagagaaggcuccaaaagccapugccugaucuggacaagaggaaguaccuagugcccucugaccuuacug\n", + "uuggccaguucuacuucuuaauccggaagagaauccaccugagaccugaggacgccuuauucuucuuugucaacaacaccaucccucccaccagugcuacc\n", + "acagcccgacgcgccacccagcuguuuuugugcucccagcucuagcgaaaagccgccgguauuucuccaucuggcucuccucuaccuccag\n", + "uacaaggaggaccaucccuuugaguaucggaaaaaggaaggagaaaagauccggaagaaauauccggacapucccc\n", + "gcugcgcagccgaauuggapcagaauauggcuuaagugguapaccagcagcuguuggauuuuggaaauggaggagcggagauuuuaaaauugugcucuuuaucuucag\n", + "gugcucccagcucuagcgaaaagccgccgguauuucuccaucuggcucuccucuaccuccaggcaggcucacccgagauccccgccccgaacccccccugcacacucg\n", + "agugcauuccaaguucuaaacagcugaguuuuggaucucagcuccuuugagaguuguggaccagucagacacaaaauuaucuuuaaauauacagauap\n", + "aaaccuggcaaagaaaacggucucgacaaugaguaggccacccaucacuacuaacuacagaugacuugccauuucauuuacaaag\n", + "pcacupcaguaaauugguugcaggauuggaagaaguccaaggacagugupaugccacccuguagcugucuagagaccuagugaag\n", + "agacguaggcccpuucccggccuggccpuagcagcgcpcggcccupcpagacapcggcuccacuccggcgcucugcggaggacagcagcgaucgccaaggcuca\n", + "cucuaugaucagaagauggcauaagupcupcacaguggcucagugcccagcupauuacgccuguaauaccagcacuuupaggccaag\n", + "ggucucacucugucacucaggcugaagugcaguggcgugauuguggcucacugcaaccuccaccuccupcucaagcgauccucccacgucagccucccaaguagcupaccacag\n", + "gcggacggcuuccpuuupccuggcucugugacugaggcggcggcgguggcggccaagcpauacpcggcpagcupaacaggc\n", + "gacugaggcggcggcgguggcggccaagcpauacpcggcpagcupaacaggcauggacguuuccpcaagagaccgacuggcggagcaccgccuuccggcagaagcug\n", + "ggcucugugacugaggcggcggcgguggcggccaagcpauacpcggcpagcupaacaggc\n", + "uupccuggcucugugacugaggcggcggcgguggcggccaagcpauacpcggcpagcupaacaggc\n", + "guuauuggccagccuagcugagcacugacggcucucuuccgagaggcggauuccagaggaggccgagcaagcgucugaaucugccuugcagg\n", + "aacuugacucuauuuuuuucucuccccgucucuucccuggccuugcccucucucuuucugcccuguagccgcpcguccaa\n", + "cccaggcucgccaaggcacggaagacaaaggccupcguccupucupaggaaggcagacagagcuc\n", + "guguggucgccgupuucucgguugcgaggcagcucgcucguucugcgaucuauugagaguggcuuccaagagccccgugccuaugucupapapaag\n", + "acggcuuccucgaaucuugcgcgaaagccgccggccucggaggapauuaauccagacccgccppuguuuucacauuucuuccucuucguggcugcuccuccuauuaaaaccauuuuuggucc\n", + "gcuuauaacccacaccauggauaacuuauuggacuuugccugaaaggagucauuagugacauuggauauuugaccgucuuggccacagguuuuucaga\n", + "pcucuuggcuuupccucagugcaaguccauuggaaaaggcagcugcaacaaucuaguggucaccagcaguccc\n", + "auccuuuaugguugaapuguuggaggaagcagaguuuucaucagcugcugaaguggcaacuaauagagguuugaauggccguagaaaaauauuguguuacuuguuuguugucuag\n", + "agcgcucugaapcuggagccccaaguuacuccucgccagcgccggccgcccgcugucacucgcgcuggccggccpaapacccgcacgccpcuuuguuguggaaaucccgguuaccug\n", + "cucuucaucucuucauggacgcuccuguccccaacccaaugcucauuguguaggagucgaucaucugccaucuucacucuauuuugaaggcaaaagacauuuuuaacugccucagag\n", + "aguuccaaguuacucacuggagcugacaagucaccucpaccpaagucacucaagugucuggaaaucuuggcccuggcugauuugucauccuauggaugauucaauuag\n", + "pcuggccapugugaccaccgugcupcagcaggcuccagucccuaacccccagccacuacuggc\n", + "gcagccpcagagccagaugcccaaagaccagccccugupcacuucuggagcaguacugccacaccaucaugacccucaccaaccucucag\n", + "gcgcugcuucucugaggcaggacggcacugccpaggcggcggugacaacgacggcgguggugacpcaccpcucgcgg\n", + "cugaggaggaugaggacaaggaagaugauuuccgagcuccccuuuacaaaacaguggagauaaapcauccaggugcgc\n", + "cucugaggcaggacggcacugccpaggcggcggugacaacgacggcgguggugacpcaccpcucgcgg\n", + "ucugcgcgcugacgcccugucguccccgcagaacgaucgccgcggccggaagaguuggcgcucpcggacuccuuggaacuggcuuagcgcacccaucccaccuucccgcacccupaccg\n", + "gucggaacgagcugauugcccgcuacaucaagcuccggacapaagacccgcaccaggaagcag\n", + "auuccagcguccuccucgcacacucgaggccapcpapccgcagcuccggcgccgccgcgucccgccag\n", + "auuccgcgcauuccagcguccuccucgcacacucgaggccapcpapccgcagcuccggcgccgccgcgucccgccag\n", + "aacgaucgccgcggccggaagaguuggcgcucpcggacuccuuggaacuggcuuagcgcacccaucccaccuucccgcacccupaccg\n", + "uuccagcguccuccucgcacacucgaggccapcpapccgcagcuccggcgccgccgcgucccgccag\n", + "gcagaacgaucgccgcggccggaagaguuggcgcucpcggacuccuuggaacuggcuuagcgcacccaucccaccuucccgcacccupaccg\n", + "caauacuuguugcaauaauugcccacgauagcugcucaaacaagagaguuggaauucaucuguaaaaaucacuacauguaacguaggagacaagaaaaauauuaaugacagaagaucugcgaac\n", + "cauuccaguuggcuuuugaguggauacgugcagugagaucauugacacuggaaacacuaguucccauuuuaauuacuuaaaacaccacg\n", + "gacagaagaucugcgaacaugaugcacgugaauaauuuucccuuuagaaggcauuccuggauaug\n", + "aggaggccuaccagaaacuggccagcgagacccuggaggagcuggacuggugucuggaccagcuagagacccuacagaccaggcacuccgucagugag\n", + "gcagaagcggcggcggcggcagcagcagcagcagcaucaggaaggcgcucpccagcgcggugaacccpcupcagcaggucgcggagccgcgagccagg\n", + "auaguuggcguacccugaggccugccaguuccugccuuaaugcauauguagucguaauugaguucugacacggccuuggauguuucuguccuaaauagcugacauugcaucuucaagacugu\n", + "ggucuagcugugucccagagagcaacuucccuuuucaaggcagcccacucugugugaugcuuuuuccuagguaupcaacccaucccuccuapugaaaacuucgcuguugcuaguuccag\n", + "gaggcaggcgacugaaugcacuaacagcagcaggcucagaccugcuucccuggacauuuccpaccgugagcgapaaccacguugcccuggauucuugccagcuguacaaaguugaccaggaaa\n", + "agucagcupccgccucagcucucggaguaggaagcucpcgcuccggcuguaaggagccgcggcppaaa\n", + "agauuaguugcugcuuucugaugucauaacucauuccuggauacagcupucaacaagcuuaggaguag\n", + "cuguagugugucuccagcuaccaauacaaacagauggaaggauggaggcugapagcagagagaaaaugaggagagaaauacuaaagugaaacca\n", + "ugugucuccagcuaccaauacaaacagauggaaggauggaggcugapagcagagagaaaaugaggagagaaauacuaaagugaaacca\n", + "uuuaauugccauuuaaauagccacuguggcuaauggcuaugauauuggaaaguacaguucagaguacugagaaguguggagauuaguuuucacucucaaggaaag\n", + "gugucpcugauucucuggcugugupcgcacggucccpauacupacggcpupapcgccguccupccgcggcggccpcpag\n", + "ccpauacupacggcpupapcgccguccupccgcggcggccpcpag\n", + "aaguguaugcugacuuguaaagugaagaagccaguggugcugcpuguucuuuupuagugucupauccaguacgaguugaaucauuguucaaauaag\n", + "cugupcpcgagguucpcugguuguuccguugcgagcugcagcugcgaucucugugguaggcccag\n", + "ugupcpcgagguucpcugguuguuccguugcgagcugcagcugcgaucucugugguaggcccag\n", + "ggugaaacaaagaucuuaaaacuaaagaaucuucgaccucaggacuaugcuaauuauagcugcauugcuucagugaggaauguauguaauauuccugauaag\n", + "gcuugagccuguaccagaaugauaaguggaaauuaguccucaaaguaaccucagcuguuucauuauugugugccucgagcaucugguuauucaag\n", + "agucaguaggcaacugcapcucgccacugacugaaggcaguggaagguuggcagaaggaggcuguucaaggcuguuuuugccuucacu\n", + "auuuuguuguuggugcgcgacgcagucagcugcgugauucccgugauugcguuacaagcuuugucuccuucgacuuggagucuuuguccaggacg\n", + "cuccauuuuguuguuggugcgcgacgcagucagcugcgugauucccgugauugcguuacaagcuuugucuccuucgacuuggagucuuuguccaggacg\n", + "uuuguuguuggugcgcgacgcagucagcugcgugauucccgugauugcguuacaagcuuugucuccuucgacuuggagucuuuguccaggacg\n", + "agaaaccccacaaaaauuagcupcuugguggcacacaccuguggucccagcuaccupaggcugag\n", + "gcuaucugccgcuuguccaccggaagcgaguugcgacacggcagguucccgcccggaagaagcgaccaaagcgccugaggaccggcaac\n", + "aucugccgcuuguccaccggaagcgaguugcgacacggcagguucccgcccggaagaagcgaccaaagcgccugaggaccggcaacauggugcggucpaauaag\n", + "cugcugaaaacuuuguagcucuaguggaggagcuguuuguugcagaugaacuggaaguaaaauucuaacagccuguauugcuucg\n", + "gguguccaaacugacaaugcupagaugaagauaguguguggcugcuucuggacucaaggaggaggagagagauuccgcgagccgacacc\n", + "gaggccccggcacaacuggcucucccpacucauaauaggccccagagccuuuaaagagccupagaupccuggccaacacacuucaacuggugcc\n", + "cucuuuccuucucuucuccucacagcagugccuggucaaacccagcaacccuuggccagaacuuacucacccaucccacugacacc\n", + "gccuggcgguuccapugcacaccacuccucguagcagguccccugucuugugugcuguguccccccgaggu\n", + "cgguaggucgccagcugaggcgguuuguaaguuuupucgcaguaugcuagaauuuugaggcucccuucug\n", + "gcagaagcucagcgucucgcucccugcucccggccccagapuuaucgcgagucuuggaauaaacuugcucgugcgauggccaaaa\n", + "uaacugugacugaaguuuuaccaaaggaaaagaaacagaaagaagagaagaccuuaauucuuggucaggcugugguggaccuucuucccuuacuggaag\n", + "aguaaguucucgcgagagguaguugguugcuauaguugucaaaaacauaacugaggcugcugcag\n", + "cagcccuggcgcuccgcacgcaccucgguaacaucacagcagguccaggccaaugauaaccuuauaagaggcc\n", + "agcccuggcgcuccgcacgcaccucgguaacaucacagcagguccaggccaaugauaaccuuauaagaggcc\n", + "gcuucuuagcccpcuuggacagccgccuuccggccagapaugagguugcgcugcgcuccpagcgccgauggcgugacuggccccgcgcggagcagcgaca\n", + "gugcuccccgcccccugccgcggcgccucgccucccggcucaccuccccaccccaccugcccgcugcggcucuccgcpagaucucaccguucuggagacapcucgcucgcucucacg\n", + "aaggagccaaauuaggcuucuguuucccugaucuggcacuccaapacacgccgacagcgacagcagagacaugcuggaaag\n", + "guacaagcucaucccuggcaagcuucccacagcuggacupcuccgcguuacugcacccagaaguuccauppcgg\n", + "agucaggupugccaggcccuggccguggcgaaagagccggcggagccggagacccgcucccggagacgccgccucgcgauccccgcgcpcpaccpcggccggcauc\n", + "ccaagaaauucucauuccucaggaaguugugcggcgacccagcugapcccccgacuccccag\n", + "gcuccacucaggaccaugagcgcaggcuucccupcccaucgapcugaggauggccguccagcccacuccccapccccccucggacagcugcgucguccuagcgccaggacggapcc\n", + "ccggugucugugucacacacggcpuccugccgaaaugcacuucuaggaaapaaugaccugcccgugugauaaugccucgucaguguucuupcuuuu\n", + "augcccagcucucuccuguuuuuauaagucgcagcuccgcaaacucacugaagcaacucguuuaccauaguuu\n", + "cucccuagucgcpagucugagaaagcgcgccuguuucgcgaccaucacgcaccuccccuccgcuuguggcc\n", + "gcugcaccggucuccuuuuggucccggugucugugucacacacggcpuccugccgaaaugcacuucuaggaaapaaugaccugcccgugugauaaugccucgucaguguucuupcuuuu\n", + "gaugauuuggucucugaaauccuuuuucuucgauucuucagaugcccagcucucuccuguuuuuauaagucgcagcuccgcaaacucacugaagcaacucguuuaccauaguuu\n", + "uuuuggucccggugucugugucacacacggcpuccugccgaaaugcacuucuaggaaapaaugaccugcccgugugauaaugccucgucaguguucuupcuuuu\n", + "gugcguccucuggagaagugcgcgcguguaaguguggcgaguguggccaapugccggaggcapuucgg\n", + "cccpagcccuggaggcgcagccccaccccggccggcgcggcucgcucccacgcccccgccgcggccucgcuggagcggacggacugagucagapcgccagcgcugcag\n", + "ugacccuuccguaccccaccagaacaugcccpugaccuccucccagaucuuccuuguggccuuccucgcccacuccagugacacu\n", + "aacaugcccpugaccuccucccagaucuuccuuguggccuuccucgcccacuccagugacacu\n", + "aggcucgcagcuccgcggcgccuagcgcuccgguccccgccgcgacgcgccaccgucccugccggcgccuccgcgcgcuucgaa\n", + "cauugucgacugaacugcgugcccugguugguaggauuuucuucucuagagcugcagccuccuagaaaguuucca\n", + "uuugucuucgcucuuuucaaacupuuauucacugcugcacgucagucaacuaaugcuuauccugaccuaagaagcugugucaaug\n", + "agcucccucgcagaaaaupcaaucpuuuguuuucaaggcaggaccugaacaaaauguaggacaccugaucugupaugaapcgcug\n", + "guugcuggcgcgugcgcguaucagccuuggcuggccgguguauguccgcuggauugugaggcccpaucupcuccgccguggugcagaa\n", + "cuuggcuggccgguguauguccgcuggauugugaggcccpaucupcuccgccguggugcagaa\n", + "gcguaucagccuuggcuggccgguguauguccgcuggauugugaggcccpaucupcuccgccguggugcagaa\n", + "guauaauacuucuccacgucugcuucaggaagaaagugccugccauucuuaucauuucuaagcagguucaugccagcccagaacagagaaucag\n", + "cuggagcccagauuucaaguuuugaguaaaauaccuucaagcgaaupcccuauugugcucacacauucagaaccuguuacccaaggaauucccuaaag\n", + "augucuucaauugcuguggugacaagaacauagugaauauaagcugcugaaaguagagcuagucguggcuggaacagagagaaauucag\n", + "cccuucccugccgccgcgagcgccccpapaccpcugccgucccuccgccucuucccccgcpcguagcg\n", + "cgcgagcgccccpapaccpcugccgucccuccgccucuucccccgcpcguagcg\n", + "auuuaacaccaagauggcggacggcccggaugaguacgauaccgaagcpcugugugccccuucuccacccagag\n", + "gucacpcaggagaagaaggaggaggaggcccgcgucgccuccggcpcucgcgcucgccccgcgcucgcccuccgccucgcccgagccccpapugaaacgcuuucucccagc\n", + "gugguauaaauaguugaauauuuccuauuuucuggacccagcugguuuauaacuucagaagaaaua\n", + "gguuuuaagugauauuaagaguauuggcuuauauuuaagaagucaaaagauaccacuuuaugaggaaugccagcuuuuggugag\n", + "ugguuguccaugcguuauugguuuguaaugcuagcacagaacugacuacuuugaaaaacauucaggacuacuuuaauccagcuacucuaccucuaacacaguaccuguuaacaac\n", + "gcuucucagucuuggauuugaaaacuuuaucagaguupaguguuaggaagauugccaaaccaauuuuaccuuauag\n", + "guuugagugugaaaagcugauucuuguupaucccaaacagcuaccuccuacuauucapuucugaugcagcucaugaaaauggauuggaacaaacucuuuuugaucgacuuugcuua\n", + "guucccacuuccuccccgccccaggaaaccugccauggccuccuggugagcuguccucauccacugcucgcugccucuccag\n", + "cuuuagcuccagccaccucuuuaagaggaaacuguupcagauggaggapcuagucacggaaagaaacu\n", + "auucacccucccacuupcuaaugcacagacaugaacaucuauugaggaaaaccacaaaaaacuucaaaacagcuacaacg\n", + "ggaaaaagagaguuuugucccacagucagcaggccacuaguuuauuaacuuccagucaccuugauuuuugcuaaa\n", + "pcucccaaaauggcgagugaggcugcpacucgcugagcagcggapagcgugcagagccgcugcggcccucacaguccggagcccggccgugccgugccguapaac\n", + "caucggaucgcapcucccaaaauggcgagugaggcugcpacucgcugagcagcggapagcgugcagagccgcugcggcccucacaguccggagcccggccgugccgugccguapaac\n", + "cugagcagcggapagcgugcagagccgcugcggcccucacaguccggagcccggccgugccgugccguapaac\n", + "aucggaucgcapcucccaaaauggcgagugaggcugcpacucgcugagcagcggapagcgugcagagccgcugcggcccucacaguccggagcccggccgugccgugccguapaac\n", + "gaagcagaugaagccacccuggcccgucuggaucuggagaggaagauugagucgcuggaggaggagauccgguucuugaggaagauccacgaggag\n", + "gagguucpaacuccaggagcagcuggcccgacagcagguccauguggagcuugacguggccaagccagaccucaccgcagcccugaaagagauccgcacgcaguaugaggca\n", + "acaagucgcacgcgcggaaguaaacaccucuacgucaucapcgcguccucgucuuuccccucccaucuccucagaucgguggacgugcucgccuccacucpccaggucu\n", + "augcgcaggcgccguguggcacucggcggucgaaapaguucaaggagacpcgacgcggcugapcuucucgucpucpcugcagccguc\n", + "gcggcugupapcgacggagcpugaccuuccggaggcpagcgagcgaggaggcccpagcgccgagcgucgccgccgccgccgcc\n", + "pcpcapcgcuggccgcgcugcugcuggccgcguccgugcugagcgccgcgcugcuggcccccggcggcucuucpcgcgaugcccaggccgcgccgccacgag\n", + "gugupcugcugguaggcagccugcugguccupcccucggapaggugagacccggcagccccugccucccagccugugcccccagccugcgugcugcccagagcccccauagagagag\n", + "cauaugcuggucuccaagaguuuaaagcagccauagaagauuuaaaugcaguucuuuuucaacuuccagauuggccugag\n", + "gucuacuucaggaaaggaaaaguacucugcgaugcugguuuuuuaggugaugccuuacaacucuuucuucagugcuuagcccuugaugaagauuuugcaccugcaaagcugcaaguacaaaag\n", + "auuuuaugugauuuauuauuaccugaaaacuuaaaagaaggccugaaggaaucuuccuggaguucauuaccauguacuaaaaacagaccuuuugauuuucauucagug\n", + "guucgguaauauuuuucuuguaugaauucuaauaauuaaacuguuuuucccuuagcuugaccaagaauguuccaauauuuguuugcacu\n", + "guccgcgcgccacgccccccugcucgcpccgcgugcggagccgcgcgcccpaggcuccpaccguggcggcpcggcggcggcgcagcccuccgcpcc\n", + "aacccagugacuugauuguaaaaauuuacagagcggaaucauaugcuggucuccaagaguuuaaagcagccauagaagauuuaaaugcaguucuuuuucaacuuccagauuggccugag\n", + "aaacuacaaccggcggccagcpaccagapcggcucugcaggcaggcggcagcggugcccucaguuccccagc\n", + "cuggaagagccuguauuguccucacaauaguauagaagaauucaagagaggagagagagacagcaccga\n", + "acccuucacugcucuguguccucagcguguguggcuucgugaccugaagauacupaaauccauagcuaag\n", + "auuguuucucucugcugccggagcuccaggucuacccuucacugcucuguguccucagcguguguggcuucgugaccugaagauacupaaauccauagcuaag\n", + "cuccaggucuacccuucacugcucuguguccucagcguguguggcuucgugaccugaagauacupaaauccauagcuaag\n", + "gauguggcupccauuguuucucucugcugccggagcuccaggucuacccuucacugcucuguguccucagcguguguggcuucgugaccugaagauacupaaauccauagcuaag\n", + "agaacgaaaggagugaggcgccgagagcccagauaccauuuuggcgugagagcuggugguuggcaaggccgcpagupaagcguccgcc\n", + "gaaugaagcaaagucagguggacgaagugauuugauaccaacuaucaaauuucgacacuguucucuguuaagaaaucgacgcugcacuguagcauaccu\n", + "guaugaccgcuugcuucggaucagagcacucagaupaauaugguagcgucuugccaaaugcauuacgauuucac\n", + "gagccuggcgcuguaggacuagaacgaaaggagugaggcgccgagagcccagauaccauuuuggcgugagagcuggugguuggcaaggccgcpagupaagcguccgcc\n", + "gagagccuggcgcuguaggacuagaacgaaaggagugaggcgccgagagcccagauaccauuuuggcgugagagcuggugguuggcaaggccgcpagupaagcguccgcc\n", + "gaggcgagagccuggcgcuguaggacuagaacgaaaggagugaggcgccgagagcccagauaccauuuuggcgugagagcuggugguuggcaaggccgcpagupaagcguccgcc\n", + "guaugaccgcuugcuucggaucagagcacucagaupaauaugguagcgucuugccaaaugcauuacgauuucacauggcugcugaagaa\n", + "acuucucuuuucccuagacugcagccagcggagcccgcagccggcccgagccaggaacccagguccggagccucaacuucagg\n", + "agagccgagacaaggcaguuggaggcagcgguggcapcugcaggagcaagugaccaggagcaggacupacag\n", + "gcucuaapcagacggcpagcuguaccagcgcupaacgguaccgcapagugccaggagaccuuggcagccgcggaaccgccuucag\n", + "cuucucugucuccguaucucuuucuauuuauuuauuuggagacggagucucgcucuaucgcccaggcuggagugcagup\n", + "gguaguagcauuuucauuacaagugacuaaaagaacagcuguuuaccccugaucgugcagcagugcuugcuguuccuuagaauuuugccuu\n", + "aaaauuuucgugcucugagcacuggagagaaaggauuugguuauaapuuccugcuuucacagaauuauuccapuuu\n", + "guuuugcagacgccaccgccgaggaaaaccguguacuauuagccauggucaaccccaccguguucuucgacauugccgucgacggcgagcccuupccgcgucuccuuugag\n", + "ugacggcgcuggcpaggcgcucuugagccccucccgauugucccucugccuagcaagcaaguugcgacuggccacaaggcaggccucuuccgaccaag\n", + "guaapccuggauaccaagaagugacugcucaucuaauccauaaagcuauguuaacagauuggag\n", + "gauppuuccagcgucgacucacggaguccuucggaugagagcgucupugccagacgaggccp\n", + "puuccagcgucgacucacggaguccuucggaugagagcgucupugccagacgaggccp\n", + "guagaaacaggccuguuaaggagaggccaccpacuucagugucuccuccaucccaggagcgcaguggccacu\n", + "gaaugaccagcuaggcuucccuggaggccaggccucccuggacupccaggugcuuccugccagcaaag\n", + "aguupccacguggccaugagaaugaccagcuaggcuucccuggaggccaggccucccuggacupccaggugcuuccugccagcaaag\n", + "ccuggccuugccgcacccacagupccuccaguupccacguggccaugagaaugaccagcuaggcuucccuggaggccaggccucccuggacupccaggugcuuccugccagcaaag\n", + "agagcaggcggcggagccccaaccccacccagugcggagcgcgccgcgagccccgccgcaagcugagcgccuccgcccgccaggcgcgccggcgccpcc\n", + "agugcacaauggcuagagcaggcggcggagccccaaccccacccagugcggagcgcgccgcgagccccgccgcaagcugagcgccuccgcccgccaggcgcgccggcgccpcc\n", + "gccccaaccccacccagugcggagcgcgccgcgagccccgccgcaagcugagcgccuccgcccgccaggcgcgccggcgccpcc\n", + "cucuacccuucuccaaaagaagagccaagagaagguccuuuucuacaaauaucagagccauggcucag\n", + "uccuggaaucaagaugugagaccaagaaauuauuucugaagaaagaaauuuaugaaauagaaucaacccagupaaaua\n", + "acgcgcuggcpacccucapcuuuaccagcaacuaccccagugccpapuucugcugcuucgaaagcug\n", + "acgcgcuggcpacccucapcuuuaccagcaacuaccccagugccpapuucugcugcuucgaaagcugguaaggccugag\n", + "ccacauccgaucgguaccggagcpaggugapucggcucgcggauccagcugcagagcgacgupaauuggaauggugcuuuggugagguggcggccgcguuapcua\n", + "auagaagacccgcccauccacccgcgacccacauccgaucgguaccggagcpaggugapucggcucgcggauccagcugcagagcgacgupaauugga\n", + "accuucacgcggagcccaucggaacucgaggcpcugcupucuuccaggagcgcccagacgcpcagguggccgccgguggccacaggccupcagg\n", + "cggugacgcpuggccaaagcggagcggagcpugaggagagucgapaggugacgcgcgcugccpcgag\n", + "accacuggucuucuugugcuuauccpcaagaacuuaucgaaauacaauagaaguuuuuacuuagaagagauuuucag\n", + "ccacuggucuucuugugcuuauccpcaagaacuuaucgaaauacaauagaaguuuuuacuuagaagagauuuucag\n", + "cugcuguggauuggauuaugccauuuggaauaagaaugcuguuaagagcacacaagccagguuccucaa\n", + "auaaaaaugaaugccauuucccauccaguacugaaguguuaaaguuagaagacauuugcuaagucaaaucacuucag\n", + "guauguugaagaaaguacgcacaucuuaucuucugaacauuuugauggaauuaaccacaaacuucaugcaagaacaguaaaag\n", + "gaaagauacuauucaaguccaguacaucauaaugcagaauucuguaucaguaccaccaaaagaugaag\n", + "gugaaucaaacaucccuucuggaacaauacagaguaggaaagguuugcagaauaagagucaguuuaggaccauugcaccaaaaauugugcccaaaguccuaacguccaga\n", + "gaagcucauccupaguggaggaacagauguucugucauugccacauucuucuggacacagacuggagaacuauaggaau\n", + "auccaauccuuugauggcaauggaggaggaggaggacacacguugcacauucuccaaauauccaacagccuuucuggauuucucagaguccu\n", + "pcccagcggcccgcgccccguggcuugaccuccccgacugcupcccgugacgucaccccgcugugacgcgcacgcuguaggaaaacu\n", + "apcggagccupcccagcggcccgcgccccguggcuugaccuccccgacugcupcccgugacgucaccccgcugugacgcgcacgcuguaggaaaacu\n", + "aagaaaaugaaacugucaaaugaaaacaacauuggaaggaguacaagagaaaaagaugauacaggaaaaacagugaggucauggaaauuagacaugagagag\n", + "cucagcaapccggupauucuacaugguccugcgauauccaggcgacggagucucgccucuaaaguggcccpagcaggaag\n", + "ugcucaggcaggcgcugcggcagaagcaccaggaagcccagcaggccugccggccccauaaccugccugugcuucaggcggcucagcagcgagaacuagag\n", + "agugacugagapcugagcggaggcugcugaapagaaaggagugaggagcugcupcagagapacuguccggcucccag\n", + "acuuuccauguguguuuaguuaguaucuaguguguggccuuuugcacggauaaaggaccgccgcagagcucccccugcuccag\n", + "ggacuguggcggcugccpcgguggcggugguggcggcggcggcggaggcggacupaggcggcggccuggcucggccuggccuggccugucapcgcpcggcggcggcuccagcacc\n", + "gcggccgccgcucaggucaggcagccccagcguccccpcccucggccccaccgagugccggcucccgcgcucugcggcggcaagccccuug\n", + "uccccagcuccugagcacauggagucagaacucgaauuugagcuuaucggcccaagcaaaucaacaagupaauccuagapcuucguucugaaaggccaguucucuucugccug\n", + "cuaagaauggagcaacaggcguggaguuggacauugaguuuacuucugacpauuccugucuua\n", + "agacaguuuccuuagcaaagcugcuggacacacuuguguuugauuucugcuccuggagaugcaguaauugacaguguugagag\n", + "augccgcuccuacgaggacugcuguggcuccaggugcugugugcpcccucuccauacagaggcugugguacuucug\n", + "agagacuupagcagcccugcugugcggcugcaaucugaaaggaaaugaugccucguugcuaggccuaggaagagg\n", + "gacaagcgcgccgagaaauccuggaucuucccapauucccucuacgcucccuccucuucuucaauaaccccaaagag\n", + "cucaacagaauucaccaaaaauccaugaaggcuggupcauacaaggaggugguccapaagcuuuguuccag\n", + "uuccuucuuucupauuggugaacucagcuuggaaucuuugcucugupaaacggcagucgccagucaacauagagaccagucac\n", + "acaguucccaaucpacaagcgcgccgagaaauccuggaucuucccapauucccucuacgcucccuccucuucuucaauaaccccaaagag\n", + "gugccuguaguucuuccgccuacuguaucauagcagcuuagaaucccagcugcuggcucpcugcaguucucuc\n", + "gcggcagcggcggcagcagaagcucggcucagcggcupuggccgcucgaaucugccapcaccucgcucccucgccucuggcagcgg\n", + "aguuucuuugcacgaaaugagguuacauauccagugacauuuauuugagcuauuuaaacaacuuaaacaucuuuuucuuuucuuaauaapacguuucaaguugug\n", + "acuacugcgucucacacuuagucuccaggaguaauugaaaagcucacggugacaauugugucuucuuccagaugucaucgcuauaaggagupcuuucaucaccuccuugacguaggauguguac\n", + "guuucuaauuuaaguaugagacaguaauuacucauacagccagagaggauuccaagucccugccuauuugccgcacuaucuaaaaacaaucaacucaucuuucaaaucugaccaaacuacaaaug\n", + "pcccuuccagaagcaacccaggagcccugagaccugcapugugugcacccugacccugaggcauagcccugcaccugcagccagcuggccuapcugcaaacauggcg\n", + "pacagagacugagacacuugcugucuggcccacaggcucuggcacguuuupaggugccugcaggacccaacauacucaaugagcuuccagcgca\n", + "gugcucggcuuccgcuaccaagaccuccgacagaaaauccggccaguggccaaggagcugcaguucaacuacauucccg\n", + "uggaugcggagauugucuccaucgacacuuucaacaagucaccccccaagcpucugguugupaucacguucaucaag\n", + "gauucapacaapcagccccuuccugaacauuuacugcgacuacgagcccggcucugaguacaaccuugacucuauugccc\n", + "gguccaggucpaucaacuugagacuguguuucucuugagupaacgacccggccauucaucucuacaaggag\n", + "aacgapcugcaucaguuugaggaacagcccguggaaaaccucuucccagagcugacgaaccugaccaguag\n", + "cguccucuggcuggacguccacaacuuccccggcacgucccggcgccucucagcucupcugucagagugguuauguccgugucgcccacguggaccagcggagucgag\n", + "ggacpcggugucacgugaucgcgaggccgcpcgcgcpcgcgacucggcggcggcgucuuuu\n", + "gagugcgcaggcgcugagucccugcucggcugucucgguggucgccgccpucugagcccpaagaccgag\n", + "guuccagccguccucaccucaggaggacauagcuuugugccuuucaaagcccuuucucaucuaucaucapacucggaagacgagccagguuuacagcccugccuugaugug\n", + "gcagcgcgcggucccpucccggapagugcgcaggcgcugagucccugcucggcugucucgguggucgccgccpucugagcccpaagaccgag\n", + "gcggucccpucccggapagugcgcaggcgcugagucccugcucggcugucucgguggucgccgccpucugagcccpaagaccgag\n", + "aguuccpcuacagcagccgacgccgagaggcaccguuucuucuuaaaagagaaacgcugcgcgcgcgag\n", + "uucacugaugaggaaacugaggcccuaacggcagguggagccpuccccgacccccgagaucggcapcgcugaagacgucccuuccacccuccagccucuggugcac\n", + "cgaggupccccugucuuccagcagcuccpccugcucgcuaggcccpaggcgcaggcgcaggcgcagupugapcgcgupcgcacag\n", + "cacaucuuacuccagaggcacaagaggaggacaucccaugcggcuacuccugcccagcguggupcagcagaagcuccagagcccagacuugcag\n", + "ugcccuuuccaggccuuaagagaaguaaaacuuagcugcagcgucaggagguggaccccagagugugaguggcacgcuucccugugaacccguccucacc\n", + "acauccagcugccugagacccuccugcagccuucucaapacagccccacucugccucuugcuccuccapcagcacc\n", + "ggagcuuugagccpcucgguggucugccccaaacugagcaggcccuccccuugcaggucggcggcgug\n", + "ugagauacguagcaagcaauuggauuacacuccaagagacuuggauuacacucaugucuuucuucuuuguagacuuaagaccc\n", + "agagcuggauccuugaaaaucuacucuaucagcugcugugguugccaccauucucaggacccucgcc\n", + "augguugcagugacaucuaagagccuccauggaaacagagcguuuucuugagccuucugaagapacaacupccacuuaccuccapugaaguggauuucacugag\n", + "cugacauucgcugucacuccugcuacaaggucccugugcupcuguguggaccggcaguccugccgccuggagccaggacagcaaugccugacaacacaugcauaccuug\n", + "aaaggcpacccggaugugugugguggcggcggccgaagagcuugugugcggagcugagaggccuaugg\n", + "agaggcucupuuccuuccacpapauggagaauucacuuggaguuucuuucaguuccaaaugcccgagugcaggcuucupcguccuccuaaaag\n", + "ggcuguugccaaggcpcaacgaggapcucgcuuccpaggacggcaauuggcaacccggaagcggucgguagugcggcgcuguuuaaag\n", + "uugcagucaggcagagaggccuacgccapccgagccccccggccugcuccagcggcggcccgcgccgugapccucgaguuucgcupcuacggagcacaaag\n", + "augcgagcccagaaaagucucuccuggucuupauggaggucacacgaagccuccgcaaggcaaggacuuuug\n", + "agacupuuucacgauguuggccpcuggucuggaagucuugaccucaagcgugcgcccucuccgccacugg\n", + "cggcuucugcaaccaagcpucuuacccccgguccuccgcgucuccaguccucgcaccuggaaccccaacguccccgagaguccccgaauccccgcucccaggcuaccuaagagg\n", + "uagagacupuuucacgauguuggccpcuggucuggaagucuugaccucaagcgugcgcccucuccgccacugg\n", + "ggaguaugagccugaugupcagaauccagaugagcuggccagugcugugaaggagcugagagcacccccgagagccgugag\n", + "cggccgcaccuccpcacggcgcguaacaggaggcuuccpcugagagcguuacaggcugcgcuccpccagauaggccpcgcucagaagg\n", + "aggagccagacguguggagucccagcagaggccaaccugugucucuucaucucccupaaaggugcccccgaggugaaagag\n", + "auuuguucuccugguucccucucugugagaucuucuuaaucugugucuuucaapaaggucauugcugcucugaaggaagcugcauuu\n", + "ugugugcaggaacggagaauaaacugagcucucucucugaccuggaacagcaguaccgagccuugcgcaaguacuaugaaaacugugagguuguc\n", + "auucuuuugugucccgcagcucgcgagaggcuuccgcccagaapagcuaggccuggapcuuggccuggaggugguuuggag\n", + "ggcgagcuaapaapcggcggcagcggugacuapcpagcaggagcpagccpugcacg\n", + "ugccuccucccaacaggccggccucggccgcgcuggcgacucggcggugcuggugcugccgccuuccccpcccucguuccuccaggcccag\n", + "gccuccucccaacaggccggccucggccgcgcuggcgacucggcggugcuggugcugccgccuuccccpcccucguuccuccaggcccag\n", + "ccpagcuguggugcccucuccuucucccuuuggcuccucuccugcugccuuacagugcccccagagccggcuapcauggacuucaccuccugguccucucuuccucaggu\n", + "pagcgguggcgucuccccgccuucccucccucccpccupcgcccagccggacaggugagcggcagccag\n", + "agagucpuagacggcagcpagcgguggcgucuccccgccuucccucccucccpccupcgcccagccggacag\n", + "aagcupcpucaugcgcccuggccuucgcgcaucucccagguuagcugcguguccpugcuaggcugcagacccgccgcc\n", + "gcccuggccuucgcgcaucucccagguuagcugcguguccpugcuaggcugcagacccgccgcc\n", + "ggaaucuuugaagcauagaccucugcgcaacaccugaauaaagaaucuuuuaccugguaugugacagagcuucucaccaccacc\n", + "acauaaauuaguaccuuacuggcuapaauguugaaucacaguuggaugaagaaacaauucauguuaauguuucucuaaag\n", + "auaguguagcaugaagagcuaaauuuagapaagupccucugcuccaaauaguaacagcuaaaggauagacacucuuggagagcagaauaucuuuauuuagucugucaccaccagugg\n", + "ugccgccacugcugcugcugcugcugcugccgcugcugcugcacgaaucgccgcagcccccagccuugcgcgucgucgcuaccuccucggacag\n", + "acuccuccauugucugccgccacugcugcugcugcugcugcugccgcugcugcugcacgaaucgccgcagcccccagccuugcgcgucgucgcuaccuccucggacag\n", + "guccuucacuccuccauugucugccgccacugcugcugcugcugcugcugccgcugcugcugcacgaaucgccgcagcccccagccuugcgcgucgucgcuaccuccucggacag\n", + "gugguaccaggacuuagacuaaucaguagucaccuggacuggauaaaapaccucuuuuaggaaggag\n", + "gugcuccaggaaccagguggugacgaacupugugaggcacacagccuaaagucagcacagcagaggaggcccaggcagugccaggagucaag\n", + "gccuguuggaucucaucauccauaucccuguugauacguuuaccugcugcuccugaagaagucguc\n", + "auuucpcgcugcugugaagcugaaaccggagccgguccgcupcggcpcgccpccggapcgcgcgcggcggcggcaccccagcguuuaggcgcggaggcagcc\n", + "gcugcugugaagcugaaaccggagccgguccgcupcggcpcgccpccggapcgcgcgcggcggcggcaccccagcguuuaggcgcggaggcagcc\n", + "cuuccgcapugucgccgcugugccgcuagcggugccccgccugcugcgguggcaccagccaggaggcggaguggaaguggccgupcpu\n", + "cugcccggccccuucgcccacgugaagaacgccapagcugugaggcagugcugugugguuccugccguccggacucuuuuuccucuacugagauucaucug\n", + "gcuggapcapacggcggcggcgcagcucggaacccgccapuccapuccagguuccagcgcccggcggcccag\n", + "gaggaguccagugcuggapcapacggcggcggcgcagcucggaacccgccapuccapuccagguuccagcgcccggcggcccag\n", + "gacgcugaggcggcgapugagucggcgccggccgcuaccgcacuucpcgcucgucccucauuucucuguggugaauggcgacp\n", + "ggugagucggcgccggccgcuaccgcacuucpcgcucgucccucauuucucuguggugaauggcgacp\n", + "acuuggcagcgccguupauupaagaggaccccggcuggaggugacgcugaggcggcgagg\n", + "agagacucagccccucccccucagcggauaaccupacugaccguucccupauccgacpccccagaggacccacgccugagccccgugcgacucguggccuuupcuagaagcc\n", + "gagagacucagccccucccccucagcggauaaccupacugaccguucccupauccgacpccccagaggacccacgccugagccccgugcgacucguggccuuupcuagaagcc\n", + "gaugcuagcccgagagcgagcagaggagcagcgcacccgcacgagccuuggacccuuuggaaccgaaag\n", + "ggcgcgguguuuacccgcggugcauggupcggucuccuucggcaaccccggccgaacggccacccagaggcugugcugagcuggcgcagcggcagcagc\n", + "gaggccgcgccpagcgcggupcuaggcgupcgcucccggcaugucccuguaccgcagcgucgugugguucgccaapcugcgcgaguacaccaa\n", + "apcggaggccgcgccpagcgcggupcuaggcgupcgcucccggcaugucccuguaccgcagcgucgugugguucgccaapcugcgcgaguacaccaa\n", + "pcgcucccggcaugucccuguaccgcagcgucgugugguucgccaapcugcgcgaguacaccaa\n", + "acugcaaauuucuagaagaaaacaucaggagaagaaagagagapauuuauucaaaguuguuuccaauuccuucaaaaccucaaaccag\n", + "paagcupaccagaauggcaucucugacaccuggcucugugugguuuuucucccuuuuuguucccacuagucacagaccauac\n", + "cupcppuacacauaugaauccuucccauagacaucaggcuaaccccagcgaucacag\n", + "agaaccagugucccugugacuccacccacucaucuggccaccguugcccugaccugccaggagccuggagaag\n", + "ugcccuucuuucccuucagagaaccagugucccugugacuccacccacucaucuggccaccguugcccugaccugccaggagccuggagaag\n", + "cucpccaauaacugcgcagcgcgcpacccpupaagcuggagcuguugcpuccgcpaagucuuggcgguggagcc\n", + "acaaagagcggccggcgguacpuggugccgcgcuccuggccccgcgcpcggacggcggaggcgccucccag\n", + "gaugucauuuucaaaaugcpaugguaccucugcuuuauuaagccccguaggaagacugccacaccuagacugaugcuuauuagucaucaccguuauuccuacuaacguccugugucacugag\n", + "guuuaucuggcaagacugaggcaaauaagacuacagaauuucaaugagcgccaacagauuaaagccaaacuucguggugaaaag\n", + "aagccagacgagcuguaaaacaugaacggaagaguggauuauuuggucacugaggaagagaucaaucuuaccagapcccucag\n", + "uugcugauuguuggagguucuuuuggucuucgugaguuuucucaaauccgauaugaugcugugaagaguaaa\n", + "aaggacguacucgucuuggugagagcgugagcugcugagauuupagucugcgcuaggcccgcuuggaguucugagccgauggaagaguucacuc\n", + "aaaaguaccagagaguggacucggcugacccggcggcuacagcgcccccauauuuucupagacuucccuuuugacaauagguauccgagaguguaacuacuuuaug\n", + "agaagccggaaguugugucccggacgugucaaccpucugagugcucagaguacagcugcaaccgcgacc\n", + "aacccacaggcgcgcgcgccgcugcuucuggccpcgcpucguggugcaccacpagcgccgcaccggccggc\n", + "aggcgcgcgcgccgcugcuucuggccpcgcpucguggugcaccacpagcgccgcaccggccggc\n", + "cggaacccacaggcgcgcgcgccgcugcuucuggccpcgcpucguggugcaccacpagcgccgcaccggccggc\n", + "acugcagcugcgagccucpaagcggaacccacaggcgcgcgcgccgcugcuucuggccpcgcpucguggugcaccacpagcgccgcaccggccggc\n", + "guccpaagcugaaaguccccgaaupuggauaccgucaagcuggccaagcacaaagagcuugcucccuacgaugagaacugguucuacacgcgagcug\n", + "auucapuguaccaggccccagaggcagcggaaapagacugupaacuaggagcaacagcag\n", + "cucuuccccggcccggccpcpaccagugcgcagccpcuggcpcggcpuccgcpccgcaggag\n", + "apcccggapcgguggcggcggagcpcggcaupuccuggccgccggcuucgcugagacgcgcucgcgupcugcccucccpcccgcaguggucgcggcggc\n", + "ggcaupuccuggccgccggcuucgcugagacgcgcucgcgupcugcccucccpcccgcaguggucgcggcggc\n", + "acagauuucuuaucggcuuccacacugcggagcugcagcccucagaaguaagcaagguuuccugccpagaaaaggauuugaagcauuccagccaaa\n", + "aguggcggcuacgcgcgcpugcgcgcpaacgaccpaaacaccgcgapccpupccaggcugupacgacpcugcgacg\n", + "gcgcgcpugcgcgcpaacgaccpaaacaccgcgapccpupccaggcugupacgacpcugcgacg\n", + "agaagaaaaaauucugccuaaagucugcaacaucguuuccugccugaguuucagccugccagcuucuccuacggauucuggacuugccagccccacaaucau\n", + "gaggccccgcccccugagccupuagcggcgcgapccpagaaccguucgcggaggaaaggcgaacua\n", + "gucgcaucgaggccccgcccccugagccupuagcggcgcgapccpagaaccguucgcggaggaaaggcgaacua\n", + "aucuggucuugcupccauugcucuagaaccugcucaguaauuagcacuuguuugagucaauuauugcccgaaguggaacaucagccucuggagccagucugcaaga\n", + "acauggcucauugugccugcgcugccagcagccaggagccaggagccaagagcagagcgccagcaugaacuupucagc\n", + "cugucccuaccuggcucgcaagcugacccuugccauccccaucaucgcugccauccucuucuucuucguc\n", + "agugagugagcgagcgagcgccgcgcgcgccgccgcugccaccuccgcugcucggcccggucccggaguggcccggccggcccgcpcgcggagccgaggcccgcggcuggcugc\n", + "agccaauucugaccgugucaacgaaucauccacgcaccugcagcucugcugagagagugcaagccgup\n", + "gccaauucugaccgugucaacgaaucauccacgcaccugcagcucugcugagagagugcaagccgup\n", + "ugcuuuugccaccaaccugaagacauauagaggcagaaggacaggaauaauucuauuuguuuccuguuuugaaacuuccaucuguaag\n", + "agaaaaugagauauaagucaguuacucccggaggcaaugcugcuguucagcucuucuguuuuuguggccag\n", + "ggucuucaugaacacuaauapuaccaggcccucuuccucguuagaagaaaucaggauaacaaaggcauauupcaccccuacaaaagg\n", + "aaucuguaucuguaucaagaugaucugaagaacagcuucuaccuuuaggaaugucuaguguuccaaa\n", + "uguuaaagaaaaugagauauaagucaguuacucccggaggcaaugcugcuguucagcucuucuguuuuuguggccag\n", + "guuuucaacaccaaaugugguuaacagugaaauaaauucaaggaagugcuugaauuucuuacagacugccaaauggaacagacaagcagguugucuug\n", + "uggauggaugaaaaggcaagaggaaaaacaaagcagccgaaacacacccagacgcacacuucugccaagcauagccaccacg\n", + "gccauuuugcugcugagcgccaagagagaaagagcacauauuucuccgupacacuccuuguauug\n", + "gcggcggcuguccgcggugccggcupcggagaggcggcggupcucccupugugugagcccggug\n", + "ggcggcuguccgcggugccggcupcggagaggcggcggupcucccupugugugagcccggug\n", + "gcucgcggaaaccggaagcggcggcuguccgcggugccggcupcggagaggcggcggupcucccupugugugagcccggug\n", + "ggaagcggcggcuguccgcggugccggcupcggagaggcggcggupcucccupugugugagcccggug\n", + "aagaaggacgccgccgcccgcgupauggucgcgagcccgcgupugcccacggccgccgccgcgcpuggccccauccccpcag\n", + "pcaccgcpcagcggcgccgcagccupcuggcggaaccucgcgcuccgacucgccccccgccuguagcucggucggcguugcpcaggcgccgcuccgcup\n", + "gugcucugacuuuaggucpuggcuucupccuucugaggaacaugcacaagcugcuacagcuacug\n", + "augccupccgacgcucugcccggcugcugccgcugaggaaagccpacgcggagccccgccgagagcuucuuugcuccggacgccccuggacguggcpcagccgcgagg\n", + "cucgacugcagaggaagcaggaagcugucggcccagcucugagcccagcugcuggagccccgagcagcggc\n", + "guuuuccgaggcgcggcggcgaggacagcggcccpugcgcccccuuugucuguccccggccggcgccgcguccccgcgcgcuuaccuggucuuggaggacaggaag\n", + "gcuggagugcgauggcgcgaucucggcucacugcaaccuccgccuccuggauucaagcgauucucucaccucagccucccgaguagcugagacuacag\n", + "gccguagcggacguucuggagcgaggcgccggccccuupcccccucaagccgcgguguacuccagcggcccccuguggccucuccauccgcggcgg\n", + "pcugcacggauaucauaugcuguguguuccugcuccuggccauugupcuacguggcuguaggcaucauag\n", + "ccuggacucauggagacccucgaaaggugaucuaccccacugacagccpcgaguucugcpcagaapcacaaaaaacga\n", + "gaacaaacccuaucuguuuuauuucaacauugugaaaugugccagcccccugguucugcuggaauuccaaugucccacuccccag\n", + "aucugcguggaaaaaugccccgaccgcuaccucacguaccugaaugcucgcagcucccpacuuugaguacuauaagcaguucuguguuccuggcuucaagaacaauaaa\n", + "agugccucccuccagacucpapucgapcgcpagagagcgcpcggccgccpcuggucgccugcap\n", + "gugcupaggagccgccgccagucgcgcggucagugccucccuccagacucpapucgapcgcpagagagcgcpcggccgccpcuggucgccugcap\n", + "agcccgcggagccucccgcccgcccpcupucgcgcuggcucggacuccgcuccccgccccgccgcggcc\n", + "paggagccgccgccagucgcgcggucagugccucccuccagacucpapucgapcgcpagagagcgcpcggccgccpcuggucgccugcap\n", + "gccggcaccgccgagccgccgccauugcuggaagcguucccgcccugcucugcgaguucccucaguuguccucaguucggccgccag\n", + "cuggaggccggcaccgccgagccgccgccauugcuggaagcguucccgcccugcucugcgaguucccuca\n", + "agccccugucccugagcggacccgcccacuccugagaggcgauupcupccuccuucccgagugupuucagucuccagcuggccucccucacag\n", + "aguuggcaccaagucagapupaapaggagagaagauaaccagccccuauggagguguauaaaag\n", + "acccugcacuupagccgguagcacuccuaucacugcuucucaacccgugagcuaccagcuguguc\n", + "gccauuggcccuucgcccacccpagcugugauccugcacuucpucccugaggucuggauucuuucuccccuacugagacgcagccaguagguccacaggccgauccaacupaguugaagu\n", + "acugccugcuacgaggccgcgcagagaugccccaggcgcggagagaagcggagcacagccgugcuapacapcgccacccupcpacugag\n", + "paggauguggcpuauaaaagccccacccaggccagccggcucugcucagcauuupacgcucucagcucucggcgcacggcccag\n", + "guguggaugaggucaccauugucaacauuuugaccaaccgcagcaaugcacagagacaggauauugccuucgccuaccagagaaggaccaaaaag\n", + "gaacuugcaucagcacugaagucagccuuaucuggccaccuggagacggugauuuupccuauugaagacaccugcucaguaugacgcuucugagcuaaaagcuucc\n", + "ggugaaaauguuugccauuaaacucacaugaaguaggaaauauuuauauggauacaaaaggcaccugcaupauaaugucaaauuucauagauacugcuuugug\n", + "cucagcauuupacgcucucagcucucggcgcacggcccagguaagcpcgcgcccugcccgcccgcg\n", + "guuaucuuguagcauagcaacuucggauuucacucuacccggagaguuucccgcuugguugaacacauuggccucaggaag\n", + "auggagccuggcucugucacccagccuggaguguagucgcacgaucucuccucacuguagccuccgccucccagguucaagugauucuccagccucacccucccgaguagcupauuacag\n", + "cucucagcucucggcgcacggcccagguaagcpcgcgcccugcccgcccgcgaupccgccagcuagcpuguggagacgcupaagaagg\n", + "gaapaagagagcucaaagguccugcapuggaagucugcauuucacaguuuuauaagugucuuuuguauccuuuaauauagugcaggcucagcguaugcuug\n", + "guuaucuuguagcauagcaacuucggauuucacucuacccggagaguuucccgcuugguugaacacauuggccucaggaaggua\n", + "auuccagcaggaaaacaggauggaggaagguacaaagcaugaaugagccuggccuguccagcaguggcacauggagcggugaagagugaagaugupaaugaggcugcccag\n", + "cucucccuguaugcaagcucuuupccucaaaugaugucacupugauaccaccucccgccauuggucacaccucacuupagugcc\n", + "cucuccguggcuaacaaggccccupaccgapcagcagcaggugcauggcgagaagaaggaggcuccagcagugcccucagccccacccuccuaugaggaagccaccucupap\n", + "aguggauguugcuagaacccacgcggaggaaggaagagacgcaggcaggcugcgguuacccaagcggccacccpccucapaccccuuccccgagagacggcacc\n", + "ggaagagacgcaggcaggcugcgguuacccaagcggccacccpccucapaccccuuccccgagagacggcacc\n", + "gccaggauguccauucuaggcccaucggugcugucuugcugaagguupucaggcaucuaaapacugugguaapapugugacacagguguaagcugccaucgucauc\n", + "aggcgupagaacupaaacuggaauuucccgcggagcugacagcgcuugcgcucccccuacucguucuaauuccacgcgcuccaaaauauccgccauggagaaaucuug\n", + "gauguccauucuaggcccaucggugcugucuugcugaagguupucaggcaucuaaapacugugguaapapugugacacagguguaagcugccaucgucauc\n", + "agcauuugccgcaaguuauuggcaaguuccccugcaguuguuupcugucccuguggcugguucupugugcggccagcc\n", + "gcggcggcggcggcggcggcggcggcggcggcggcggcggcggcagcggcggcggccupcccpcgcagcggcggcggcggcpccuggagccggaucuaag\n", + "pcggcpcgucaguacaguagagugugcgccpuppcaacggucagccgucacccugagacpcggcggcp\n", + "aaaaucacugugcugaucpaagcccuucagugcccugccuguacucgagcggcuccpcggagaacaagucggcu\n", + "ucucgagcggucgaggucgcagaccuagaggcgccccacaggccggcccpcgcupagcgccggccgcpccpup\n", + "guucaagugauucuccugccuuacgugucauguugucuuacugguccaccuaaauauggaagauacg\n", + "aguucugapuugccupcucugcupugguuuuucuguuucacaugauguuggcupacugcagucauuuggaggcuucacugaacug\n", + "gcuggaaugcaguggcgcaaucugcaaccuccaccuuccggauucaagagauucuccugccucagccuccugaguagccuggcuuuugccuucuuuuugaaa\n", + "ccguggccccgaguuguagucpacaccccggccgcpugaucgucpucuccacgcgcccpucgcugacgcggauccggccucggcgccuucucapcgcccugcaaggccgcaggcagg\n", + "cuccuupccccuucucucccccuuuccccucccugcugguuccuggcaucgccagaugcugcgcagcagucuccgauuccccaucaccaauucggcugg\n", + "agaguuggcaaaccccugaccuaugauggacguauucucuagccaauuacuagacgguauucucagacpccgccuccauugccaaugaaaucuuccagcpucgcg\n", + "cpucgcgguaggcpccguggacccucugguauaaggcggucccpagugaggagaaappucuuggcggccggaggaggaguaggugcpugaag\n", + "cccccuuugcccuucccugugucugcccccauuuuccuuccccuccccuccccagcugupcugagcuagagacpucagagagacuggagag\n", + "gaacuuuuucugcaaaucaaggaaagcuucccggaggaaguggugccuaagcugugcucugauucacguuuagaagcugaccagacaaagagag\n", + "cuucggcauccggccuagcggapucuuauccccccucccacguggaggapcupcgcuuccggccaggcccccacguggccgcugcgcg\n", + "gcucgcccgcccgcgccuccagcggaagccggaagcaaaagcpuccugcuagccccgcggcuccgaacucggugguccuggaagcuccgcagg\n", + "ggcccugucuuucaggcagaccucauggcugagugagccuccccupcccagcaccccaccucagc\n", + "ggaggaagcuggcuuccuggagccuucucagcccucaaagacagaccgacagacagacagacagcuggcaagaggcagccupccacagcugcuuca\n", + "aagaucccuucaaacuuugucagccccgaagaccuggacaucccuggccacgccuccaaggaccgauacaagaccaucuugccaa\n", + "auccccagagccgugucugucuaggccpcacagagccaggaggacggagauuacaucaaugccaacuacauccga\n", + "agcccucaaagacagaccgacagacagacagacagcuggcaagaggcagccupccacagcugcuuca\n", + "ccacaaugaaagacggaacacauuucuacacccagugacuggccaggucccagaggaaaacaaaaaauuugacuugaaaau\n", + "auaaacupugacagagucagaaaacuccccagcuaaacacccguaagacuucauacaacacaauacucuauacugugaugaucacagcugccaag\n", + "gcuaccuaaaagaagacaguuaucucauauuuggcugccagcuuuuuaucuuucucucgaccacuuaaaacuucagacuuccuguccugcugguauc\n", + "gaauaagcccgagcagccgguccuccaguggcuccgcuccccguucucugupcucaaaaugacaggcaugcuccuc\n", + "gaauaagcccgagcagccgguccuccaguggcuccgcuccccguucucugupcucaaaaugacag\n", + "aggcucacaggacaccugcaugcccaaggcacuccaccguaugugaucaaccuggauccagcaguac\n", + "gacaccugcaugcccaaggcacuccaccguaugugaucaaccuggauccagcaguacaugaaguucccuuuccugccaauauug\n", + "aggcucacaggacaccugcaugcccaaggcacuccaccguaugugaucaaccuggauccagcaguacaugaaguucccuuuccugccaauauug\n", + "guauugcugucucuaagccagaccugaucaccugucuggagcaagaaaaagagccuupagccu\n", + "aacagagaagauuacgacaaauuucuaagugcaguguaucuuguuuaucuugugcugaccuccuaucucauccugugacuaagaaugccuaaccupaggcagccaa\n", + "gugaugugacucuucuucagccugcacccugccaaaagaggauugugauguaucacuggacccagcaccuagaugac\n", + "ucuccaacucpaauccccggugacuuugucgcagccuccguuacccugugaucugcaaguccupagacgcacagcuaagaugcccggacauccuggaagcupaaaug\n", + "acagacccaacauacaggagguguugacccucauaccuggaaccuggacauguguggaauuucuaaucucauuccuggacuuuccugcag\n", + "gugaugugacucuucuucagccugcacccugccaaaagaggauugugauguaucacuggacccagcaccuagaugacguaacucucaucuuuugccuggaccuugcauauuuugg\n", + "cuuuuccgcguucuccaacucpaauccccggugacuuugucgcagccuccguuacccugugaucugcaaguccupagacgcacagcuaagaugcccggacauccuggaagcupaaaug\n", + "guacuggcccgcgccguccgcccgccgacagcucccugagccagcccpaggcagccgcgcgcagcgagccgguggcgcaggugucpuccucgagcgcccagccupagc\n", + "guuaacaggaagaucucgapcccuggcugaacuucaccuuuuggcuuucuuggccugaugcugaacucucgagg\n", + "agucccgguuucagcaccuccggcgcuggacagcucucugcacgccgcaccgccgccugcuugcuuuuucccacucucgcuuugcauuacuggag\n", + "auaugcuuuagcauuuuaaauggcuacaccaaagagaaaauugaaccaggcucucuucccuacuccuacuggacuuupupuuauuccucugaauguucuagcggacuupuuagcuua\n", + "agauuugcupagugacagcccuaggaagcuaaugaucucuccaggaaagaauugaccacaguuauccagaaacugaacacgauguagaacagagaggacagccccucggau\n", + "acaguuauccagaaacugaacacgauguagaacagagaggacagccccucggaugugaguaccaucucuucaacacaag\n", + "cuccuggcugcuuccugaugucuugcuggcagcaagupcuapucggcuugcccagapcgcauccaggupuucaccuuucugaaccag\n", + "aauaggcccaacuagacaacagaucugupaauguuuggcucuccaugaaccacaaagacuccuccaacacagaggugcaguacccaccupccaaggapaagaugcag\n", + "pcpcccggcgcgcgcpaagucucuguapcggccggcuacccucagccgccgcgcguc\n", + "aggapaagaggacuccaagcgccauggccgcugccgcccgagcccpucgcguacuugcugaggcaacugcaacgcgcagc\n", + "auuugaauuuuuggcpagaaggaagugaugcacucaaguaucuaccgagacccaaccacuggacaag\n", + "guagacguccuaccccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "guccuaccccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "gauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "ggacguagacguccuaccccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugc\n", + "ggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "gacguagacguccuaccccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugc\n", + "ccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "gugauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "aaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "cuaccccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "uccuaccccgugauauuaaagcaagauggccgcgcccugcagauugucucuuguugcguaaguuuuuuugaccgucacucgugucagcuucaaagucagauagauuuuucucccagc\n", + "ccaaagcuacaaaagaagcgapaauccaaccgagcgcagcgacacugagaacagcuuccccugccuucugcggcggcagaagugaagugccugaggaccggaagg\n", + "gaccccuuuaaggcgcggccagaguccucccgcagaaaaacgacuuaaaggagacgcguggcgcg\n", + "acuccuuggcuggaggcagugcugaggccgccguccccucuaccaucaguccaguccggcccgcccuccugcagcc\n", + "gucacgagcgagcuuuucuacccaaauacgcggcpaauaggcucgapcggugagcagugacaauugcuaggcggagacagugcapaagagagaccuuagaaaggaucaggacuggcgg\n", + "cggcagacauaugacagaagacugaacaaccagaaguuaugaagauagguacugupuguuagaaagauucacggcaaaacapaag\n", + "pagaggaaguggapcgcuggccggccgupcaaugcaacggccucccagcacapcuauaagaggagccpcpcacggapcagagaccccggagccccagccccacc\n", + "agaaacguguccugcgcgcuacgccgucuguuucuapcaacgccggcgucucuuagcaaccgcgcgcggccuaggupuccccccggcacccccagaccugcc\n", + "uuuccagaguaugaugaccucuacugcaaguacugcuuuguguacggccaggacupcccccacagcg\n", + "ggucuggaggapaucucacagaucacauccaagagccaagaugugcggcaagcacugguguggaacuuccccauugaugucaccuuuaaaagcaccaaccccuacggcu\n", + "ggccacagaucgugcucagcguguauggaccagauguguucpaacgaugugguucgaggcuaupccgugcacgugcccuucucaccuggccg\n", + "augccacacgcgcacucgcguggccuucgcgaaggugucgcugccaagaaacguguccugcgcgcuacgccgucuguuucuapcaacgccggcgucucuuagcaaccgcgcgcggccuag\n", + "puauugcaggcaccaauggaacagguupaggagaguuupaccaagaacacccaugaacccuuagaagccaccauagag\n", + "guguccugcgcgcuacgccgucuguuucuapcaacgccggcgucucuuagcaaccgcgcgcggccuaggupuccccccggcacccccagaccugcc\n", + "acggugugcpccggccagcccuggacgaaagaagapccccuccaggccagucupcacccupauagcggcugcag\n", + "agcggaaggacggugugcpccggccagcccuggacgaaagaagapccccuccaggccagucupcacccupauagcggcugcag\n", + "gacggugugcpccggccagcccuggacgaaagaagapccccuccaggccagucupcacccupauagcggcugcag\n", + "cuggccuaaaucugacacgcacgacuccccccgcggcaacugcacagguucggugacagccgagacgccgaguguuucccgcagccggccpuccaggucggaaauguagccagupccgccag\n", + "agcuuccagcuupaagagupuugucagcaggagagccugapcugaggcccagcgugaacauggcagcua\n", + "guaapcacccaccagguguaauugupcgagcggccgcuucggagcugacacuaagcaugugcagaucaaguccagaagcgccpuuccucgaagcaguuuucaggacuuaaggcucupa\n", + "gcacccaaccugaucuuccuggcagugaguccagaagagaaggaaucguggaucaaugcccucaacucugccaucacccgagccaagaaccguaucuuggaugag\n", + "agugacgaaguccauccccpugcpaggcpapapcaggcagaggauuucgcucgcucgcccgcgcpauccpacgcgccgguggcguccgcuggcagcagag\n", + "aapcuuagacagaggcagcagcucacapcaucuacucugccugcuugccccpcccaccucagcucuggcuccuccaggcccaca\n", + "agaccacaggacaguagugccuggccccagccccaggcagccacagcaggcugccuuaccccagaagcagcugguggcg\n", + "agccguggucgcgcugugugugugugugaguggagagugagugcpaccugaggcugugugugugugaacuguggccacuggcpucpppcagcggcggagccgccucggacg\n", + "pcccugacaugugaaaggaaggaaugugcccuaauauucuacaguuguuuuaucguugcuacugauuaggucc\n", + "agucacuccucgccccaggcucugugcacaccccugccuggugaccuccauuggugcuccagcgugaac\n", + "cucucggcccggcagguuucgcucccgccccuccggccuuccacagcuguccuggccgcapuguucaaggcpacacaccaggcuagagauccgcgaucpccccgccucag\n", + "cgcgcccgcggucccgccggaaggacuuaagcgccccggagccpaggcgaacuupacccgcuggccucgcucggugcgcgccucccuccccgc\n", + "ggaaggacuuaagcgccccggagccpaggcgaacuupacccgcuggccucgcucggugcgcgccucccuccccgc\n", + "gacaccgcacgcugagcucugugauguagccgcuugcggagacugcaagcagccgcggcgcgcccggcccucccucuuccgcugccgccgupa\n", + "auuauuugcaaugucaggcuuugaaaacuuaaacacggauuucuaccagacaaguuacagcaucgaugaucagucacagcaguccuaugauuauggaggaaguggaggacccuauagcaa\n", + "cacguagcaacpcugguucapucugaaacagaguuupuuguuupauuagugaagcuacugccuuugccgccagcgcagccucagaguuug\n", + "ggaagccguucuuuggcccugugacacguagcaacpcugguucapucugaaacagaguuupuuguuupauuagugaagcuacugccuuugccgccagcgcagccucagaguuug\n", + "aapagcucaguaagucacuucupcgacuguuguuuuauuuccggucuaupacccggcugcgauuugcugcugcggacagcagcuaccaucacugcugccgccauc\n", + "gcgcggccagagcggccpacaggcuccgaggcaggcccgacccgccuccccggcgccgccguggcucgacggagaccagcuagg\n", + "cuggcccccaagaggacccuuuccaaguccccagcupcccuguguagaccuggaguggacacgccccuccuucccuucaugauucguuuguagcgcag\n", + "acugugucugcaagcaguuuguacucaguuugucaagagagcagcuuucuguuuugauuauauaccuucaucucugaaaaaagacaugcuaguuaaauuucaag\n", + "aguccagccgccgccugcccucagccgcccgcuggccpagcggagccccugupuaagupcgcpccpcuccucgcaggcgucccuccpcuggcg\n", + "guccuagaaaugaaggagaacacuuugaccagucgcccuacacugcupcagcaggagacccgcuguguucuugaggagacauuupcucuuucuccacugaaggucuaggagcg\n", + "gauuccauuuaggagaagaaacacuucauaugcuuugguguagauggugagagccauuuggcucuaaaugaaaacauuuguuucag\n", + "uuuuucaugaucacuauuuagaupugcuguuuucaugaggagagucupaaggcggcguccgcuuuucugacaapaagag\n", + "auaaacuaucaacuucaccagcaucaugaaccuuguugccguaaaaaggaguucacuacuucuguucacuuugagucucuucaa\n", + "cuuaggaaggaagguuggcggcggugaagapaagaggaugaucuaguaaupcucuuccaaaucgcaucugguagguucauagcc\n", + "cacagagccgccuuucagccgcccgagaacugcccgccgcacuccacgacugcggcgccugcucucpccpucugcgcgcaccacgcggccggcagaaagg\n", + "ugcgcgcgccuucpaggapcugucupcucpcgcggcggcagucagcucuauguucgcggucuuaaccucuccucuggccgaguccuugcaagaagugaauuacccgacccug\n", + "gapcugucupcucpcgcggcggcagucagcucuauguucgcggucuuaaccucuccucuggccgaguccuugcaagaagugaauuacccgacccug\n", + "paggapcugucupcucpcgcggcggcagucagcucuauguucgcggucuuaaccucuccucuggccgaguccuugcaagaagugaauuacccgacccug\n", + "auuuagaauguaauaacucaaggauuugauaauacagugaaguaguauaacaacugucuacgugcuucccaugauauguucucuauauu\n", + "apaaguagcacagaggaagaggcaauacuacccgagacuagaugcggaccgucucuggcaaccaggaaaaggcaaauacaaagagag\n", + "gucugcuggucacagcpcaccucgaggagaggacgacuaggagcacacggcccggaaagguccag\n", + "gucugcuggucacagcpcaccucgaggagaggacgacuaggagcacacggcccggaaagguccaggucapaap\n", + "acaguccggagaggaugaaacagucpaacaugaacaacuccaugugucauugacgcuuccaacg\n", + "aaugaucgaggcucaggcccuggaaggaccguaaacauuuggccagcuugguuuggauaccuggcagagaccagguucugagaagca\n", + "aggcucaggcccuggaaggaccguaaacauuuggccagcuugguuuggauaccuggcagagaccagguucugagaagca\n", + "agauuupagcauccagcagccagccucuacaguccggagaggaugaaacagucpaacaugaacaacuccaugugucauugacgcuuccaacg\n", + "gcagacaggaagacuucugaagaacaaaucagccuggucaccagcuuuucggaacagcagagacacagapcaguc\n", + "gcagacaggaagacuucugaagaacaaaucagccuggucaccagcuuuucggaacagcagagacacagapcagucaugag\n", + "cacagaccuaacagcacccupuggaaaccucuucagcauuugcuuggaaucaguaagcuaaaaacaaaaucaaccpaccccagcuuuucagaacugcapaaacagccauc\n", + "accuaacagcacccupuggaaaccucuucagcauuugcuuggaaucaguaagcuaaaaacaaaaucaaccpaccccagcuuuucagaacugcapaaacagccauc\n", + "caguauuuacuugaggcagacaggaagacuucugaagaacaaaucagccuggucaccagcuuuucggaacagcagagacacagapcagucaugag\n", + "ggucccacucuaucacccuggcuggaguguaauggugugaucucagcucacuacaacuuuugccuccupcucaagugauccuccugucucagccucccgaauggcgaggacuacag\n", + "uuccuucaguauuuacuugaggcagacaggaagacuucugaagaacaaaucagccuggucaccagcuuuucggaacagcagagacacagapcaguc\n", + "ugcccugcagguugugcccuccpauccugauucuauucucuccucccuucacuucaccapcgaccugacggaagauaac\n", + "gcuaucaggaggagcaaaapaaggaucugcugcupcucgcupugacccuuugccagacgaaaagagcugg\n", + "gaaaauggaaacaucauucccuagaaacaguugaaguugacagaccuagagguugacaaaaggacacgacacuagg\n", + "aucagcuuugagugaacuuugacagaagauguuucgacaguuuuaucucuggacauguuuagcuucapaucauccupcucucucuuugaaaucugcuupccaguaugaugaug\n", + "gcugaacaagacaauggucauccucuuccugccuuugccggucuacacauugaaauacuggaugaaaacaaucaaaguccauauuuuaca\n", + "agucuucucucucgcucucuccgcugcuguagccggacccuuugccuucgccacugcucagcgucugcacaucccuaca\n", + "aacaguucugacgugagaggacaagaaacacaagcaaauauaaaacauucaauucuaagagaaguucaucagagacauccuucaggauugugag\n", + "cuggauuuuccucuacgugcuucagucuucucuacacaaagagcugcaaaccaggucuuuguuuugcacucuuauuucaagcaga\n", + "aaagacuuuccuupuaggacaggaaagcuuuggugaaguggauuucucucaugapaccagcuuuucucac\n", + "cuuuuccggcuacpuccccaagcggagcpaggccggaccpagccgagcggcggcgucggcggcgucggcggcggcggcgacggcggcpcggua\n", + "uccggcuacpuccccaagcggagcpaggccggaccpagccgagcggcggcgucggcggcgucggcggcggcggcgacggcggcpcggua\n", + "auugcuuccaaguaugaucaucaggcagaagaagaucuucgcaauuggauagaagaggugacaggc\n", + "auccccgccuccccuccugcccaggugacugacuaauccgccgccuucaggagacagaauuggccaag\n", + "agacagaggcccapucuacgaaggaugugcggugagacuggagaagaaggucccagccugugaccuuggugcupcagcgcugguuccagagccupagaagcugaupcgc\n", + "acuuccggugcccugaccuuuauaggaguaaacagacccccgccauccccgccuccccuccugcccag\n", + "aaaucuucccaaggcugcagacaccgacggauuugcuuupagccagaguagcugccgccaccagaguccggagcc\n", + "acuacuucugcgccugcgcgaccgugauuccccgcucgcgacuccccaccccccapcucccuaaagapccacgagcugcgaaapcpaaaggcaguuggagaagag\n", + "guacuacuucugcgccugcgcgaccgugauuccccgcucgcgacuccccaccccccapcucccuaaagapccacgagcugcgaaapcpaaaggcaguuggagaagag\n", + "gauuccccgcucgcgacuccccaccccccapcucccuaaagapccacgagcugcgaaapcpaaaggcaguuggagaagag\n", + "guccuuaaugcaagucgguuaugccuguagguugaaaggcaucapaggaaaaupaccagaaugccaggugaccuaaggaggagagagagaggacaguugaaaacccacag\n", + "aaaggcaguuggagaagagguaagcgguuacucacuccauggcugcagcaaggagaggcggcggcggccucggcugaagaaagaaggupagcggagagcgcaggcgug\n", + "cauggaggaggaaggagauggcauggcuuaccauaaagaagcacuggacgccpugcacguuccaggauccaggugcccapuc\n", + "aguggcgapaggagccgagccggcaccgcggcuggcgcgcpcugcggcggcggcggcggcggcagcggcggcagcggcggcuccgg\n", + "uugacuagauaacgaaggacaaugcauauauacaaaauugcuguauugccuggugauaugcagcuguaccugugacaucauaauugcacccuccgacaug\n", + "auaucucuuccaaaugcuugaugaaaaaggupaggaucacuugagccapaguugaaggcugcagugagcccuguuuuugccaccacacuccagcuugg\n", + "agaggugapcuguccucuggauggcaauugaugaaggaugagucugugcccugaapagaucaguccagcccagcuccccacugcugccucgugugugguggcuucuccaggagagag\n", + "gauugauuccuaaagacucauguuacgugaggaagcagcucagaagaggaaaggaaaggagccaggcauggcucuuccucag\n", + "agcccgagaggccggcgucucucccccaguuugccguucacccggagcgcucpacuugccgauaguggugacggcggcaac\n", + "agaugcuccacggauuugcacgaacucccgagucuugaccucccuccccucuccpcugccpacaacucpcggccacucuugccaggaggc\n", + "cuuccaccucugcccuaucucggcagaugcuccacggauuugcacgaacucccgagucuugaccucccuccccucuccpcugccpacaacucpcggccacucuugccaggaggc\n", + "ccuuccaccucugcccuaucucggcagaugcuccacggauuugcacgaacucccgagucuugaccucccuccccucuccpcugccpacaacucpcggccacucuugccaggaggc\n", + "gaggacggcgcpapcguuuccggagcacgcgccpcpccgcugacgucpcucag\n", + "aguuggcggcgcgcacuccagguggcggccggcugcggugapaccgccagcggcgagcagucccggcggcccup\n", + "guucuuggaaggcggugcucugagaagccggacuacgcggcagcggcucuucaaagcggagccpaguuuuugcuacaguuuucgccacc\n", + "ggccaagugcpacgccppccuucacpaggcccpcucuuccpcgucgcggagccggapugcaggcgacpaagcgcpuggucggcupuccggcuccuggagaac\n", + "gcgagaguugguccgcggacgccggaaguaguucgucgcucccuagcggccgaapcpcucgcpucucgacugcuuucggcuugcucggcggagcaag\n", + "uucgucgcucccuagcggccgaapcpcucgcpucucgacugcuuucggcuugcucggcggagcaag\n", + "acgucgaagcgcugcuccuggagccgcggapugcpuuuggcugcggugguuucuguggcgguugcuguggcggaguuuggag\n", + "gcugcuccuggagccgcggapugcpuuuggcugcggugguuucuguggcgguugcuguggcggaguuuggag\n", + "ggcggcgcapcpcuuuacggacgcaagcacgucgaagcgcugcuccuggagccgcggapugcpuuuggcugcggugguuucuguggcgguugcuguggcggaguuuggag\n", + "gucgaagcgcugcuccuggagccgcggapugcpuuuggcugcggugguuucuguggcgguugcuguggcggaguuuggag\n", + "acgucuucgagauaaaaupuucgcccccuccuupcaccccuccucugcccugaggaaccggaggcucacugcccuuuggaagccccgcaucucuucccugcuuuaap\n", + "guugccauggugaucgccgccgcuggcucaggcggaccaggccgcgcggagccccagcuuucacagccaucgcug\n", + "uccpucucgucuucacugcucuguguccucugcuccuagaggcccagccucugguccugugaccugcagguauupaauccacagcuaagacgccpacacccuggaagccuagaa\n", + "cgucuucacugcucuguguccucugcuccuagaggcccagccucugguccugugaccugcagguauupaauccacagcuaagacgccpacacccuggaagccuagaa\n", + "gccagaaaaacupaaaaucacaggcucuuccacuuacuggauauuuaacaagauauucuucuugagccaaaaacauugacauuagcg\n", + "acagugugcucapcguugccagcucauugcucuuauagccugugapaggaagaaacauuugcuaaccaggccagugacagaa\n", + "aauaaagagcgaguggaagaagapaggaaaaccaaagcaugugcugagcaccagupugcagucugaugccapagccupaag\n", + "ggaggugagugagcgagcgagccuucucucuccccacccccugcucccpuuccguuaucuuuucgcucggcgaggcguucagaggcgagaca\n", + "ucggcucacugcacccuccgccuccupuucaagcgauucuccuccuucagcuuccucaguagcupauuacaggcacgcgccaccacaccugg\n", + "aaacgacccggupucuacagcggaapapagcgaagguaggaggcapcuugccucacuggccacccucccaaccccaagagcccagcccc\n", + "acuuugaacccaguuggcpaguggcugcucgcggapcagugucugcpccgcuguaugcuguccagcg\n", + "cuguuggcuucuuccgcgcuggaguauccagauaggcgacacgccggcpcggcugaggcpa\n", + "gacaagaggaucgccccgcgcugagccggcuggupcagcaggaggcgccugaucgccgccpcgcupuggug\n", + "cupcucauugcagcucagacacagcaaaagagccuagaaccupuccuaguuugcaccuagaau\n", + "guccapugagaaauugguuccgaacucaaaggaacccagugccpccacagccpucacguggccggcggcccccc\n", + "uggcaaauccuuccuuccccpuagaaguccapugagaaauugguuccgaacucaaaggaacccagugccpccacagccpucacguggccggcggcccccc\n", + "puagaaguccapugagaaauugguuccgaacucaaaggaacccagugccpccacagccpucacguggccggcggcccccc\n", + "aaauccuuccuuccccpuagaaguccapugagaaauugguuccgaacucaaaggaacccagugccpccacagccpucacguggccggcggcccccc\n", + "cuccgauccuggaaacucauuggcuccgaggacuuaggaccuguuagcuugguupcgacuggcaaauccuuccuuccccpuagaaguccagg\n", + "gcauuugaggagacucaucugaccucccuugacccagugaaacaguuugcugccugguuugaggaggcuguucaguguccugacauapaagccaaugcc\n", + "guuagcuugguupcgacuggcaaauccuuccuuccccpuagaaguccapugagaaauugguuccgaacucaaaggaacccagugccpccacagccpucacguggccggcggcccccc\n", + "gaggaaguucuguacaguuuaggaaauagaggcuuucaaagauaauucgcagugaugugaaacuggccucccaagcccugauaa\n", + "gcuguaccaugagcaguguuucgugugcgcucagugcuuccagcaguucccagaaggacucuucuaugag\n", + "gaggacacagugagapugccaucuaugagcauggagagcuuagcuuggacagccagcugaugapacacaucgaaucaagauac\n", + "ccucggcaapacgcugcuuuccccuggcagccacacugcugagcauaaaugcuuuaaagugucagcaauugauguguggagagaagu\n", + "aapacgcugcuuuccccuggcagccacacugcugagcauaaaugcuuuaaagugucagcaauugauguguggagagaagu\n", + "aguagccggccgcggcggcgapacuaggacgcggcuggagcggcgccpagacgapcugagagacggcggcggccgaaagcggagag\n", + "uggagaagagcpaggaguuagcaapagagcccuggagguccgcagugcugagagugguugugagcagcgaccuugaggaagaccagacugaag\n", + "aaagugcupauuacaggcgugagccacugcgccggccccaaaauuucagguuuugauagacggaaupugaagaaa\n", + "uaguucaagacaacagagacaaagcuaagaugaggaaguucuguacaguuuaggaaauagaggcuuucaaagauaauucgcagugaugugaaacuggccucccaagcccugauaa\n", + "ggcacuauauuuguaugugucuuguagaacccacgcuuggaaaugcugacagcaggcuucaggacagcugagccccacuaaacaccaagaaaaccc\n", + "ccuuccgcuccgcgacugcguuaacuggagccaggcugagcgucggcgccpuucgguggccucuagugagaucuggag\n", + "uuccgcuccgcgacugcguuaacuggagccaggcugagcgucggcgccpuucgguggccucuagugagaucuggag\n", + "gcgugcguaaggugapcuccuuccgcuccgcgacugcguuaacuggagccaggcugagcgucggcgccpuucgguggccucuagugagaucuggag\n", + "gauuugaggauauuccuucuuagacaugguccugcagagucguaggaagcauuuguuucupcuauacuaaaugugcaugauuucggcgucccacaag\n", + "cgacugcguuaacuggagccaggcugagcgucggcgccpuucgguggccucuagugagaucuggag\n", + "gcucugaaaguguuccagcugaaauuucagaucggacagacucgcugcggcuccggaggcagugauuccaagcugcucgcgcacgcugcugccaagcugcagg\n", + "caggcucugaaaguguuccagcugaaauuucagaucggacagacucgcugcggcuccggaggcagugauuccaagcugcucgcgcacgcugcugccaagcugcagg\n", + "uuuauucupccuguguggaauagaaagacaauucuuuauuugacugguaggaaagaaaagagaagacuccucapuuuccaaggaggacuggagcggcugcuuua\n", + "ggaaaucuugaggagucugauacuuuucauccuccagcuauaaaaucaucuuguapaagcuguacauug\n", + "guggaaaauaaaaggcaagcaguuccuggcccgugauauuccaguuagaggugucugacugacagcauguuggcaccgapaagcgaupcuucggcuccag\n", + "aaaaapagcaugccugucuuauucucagugccucaupaaauaaaagauupagaugauagcuaccug\n", + "aguugccggagcugaacggcgcggagcuggucugaggcgagccgagccgagcgagcgcggcggupccgagaggacgcgcagguggcggcguugcc\n", + "uggauuaaagauauuuguaggcuagacgcgguggcucaugccuguaauuccagcacuuucggagaccgacguaggcggaucaccugagguupaguuagagaccagcauugccaacaug\n", + "acgcpacuggcaaccugcggcgccaggagcupccgaggcgcggcggcgcggcugcpccgccgucuggaupaaguuacggcgaaguccacccagcguuucucag\n", + "ggugacccaggcucucaccagccaauugucccuugccguccuccugapuaucuggagcuucagugcugugugcucuuggccuccacacup\n", + "gcugucccgagcuggccggcgagcpcggcugcpcggcgcggagcpcggcgcggagcgagcgagcgagagagcggcgcpccpcc\n", + "gauuuagaaccagugugucucuccugcagccuccauucupugccuccacccccuugccgucgucaug\n", + "ggcgagucgcupaagucgagcagacacccagcgcugccggaacucpcgcgcaucccgcaagucggaacccggcggaucggaucccgcagaucggagacpccuggag\n", + "gagcagacacccagcgcugccggaacucpcgcgcaucccgcaagucggaacccggcggaucggaucccgcagaucggagacpccuggag\n", + "aggaaaaugagaggcapucuuuucuagagagaucuppuccauuucuagccgaugaugcaugcaaagaguucguguucacaggaccupaagcagcggaguagaaag\n", + "auacccccuccccaucuugugaucacccucauuaccucuucupcccccuguggaccugcguugacccagcaupcuacaaupaguupuaaucgcucccg\n", + "cgcgcpcggcgcuuugaaccpcgcpcgcpcgcpcgcugcggccgguacacgccpuapccpucpuuguggucpccpauupcucuccupcc\n", + "cccgccgccucugcgcccgcgccgcgcccccggcgcccccuccccagcgcgcccccggccgcuccuccgcgccgcgcucgucggcc\n", + "aguguuuacuuccgcuugaccuggcccggacgccagaaaauguuccacgupauacccugcgupuucacuguaguagcugcacuaggugauucuuggagcpccugagagacaaggac\n", + "acuuccggucpcccucpucuccccggagcggcggcgccuccuccgccuccucggccuccucccggcggagaccccggcgccg\n", + "gaggcggucgupaaagaagguggaagagcgagcuuuuuggaacugugcacpacagauuggacgcacaccccucpaggcgcgaag\n", + "agugaugagagagcgcgcpaggcugcacgccgccgccgccgccgccgccgccgucgucguccggagcaucugcugccugagcugcugccggcggacccggcc\n", + "gguggagcaccagcuacgcguggcgcagcgcagcgucccuagcaccgagccucccgcagccgccgag\n", + "gccccgaggcacagccapcaccagguggagcaccagcuacgcguggcgcagcgcagcgucccuagcaccgagccucccgcagccgccgag\n", + "aguccuguguccpccccgaggcacagccapcaccagguggagcaccagcuacgcguggcgcagcgcagcgucccuagcaccgagccucccgcagccgccgag\n", + "apcaccagguggagcaccagcuacgcguggcgcagcgcagcgucccuagcaccgagccucccgcagccgccgag\n", + "accgucgcugccgccgccaccgcccucggccgcugccgaggccuccugcagccaucauguccgccagcgccgucuacgugcuggaccugaapcaag\n", + "gcuaugaaagagagagaccaggaagapcuucucccuucaggccaccuguggacuucaguaaauacgaaccuucagcpagupcgcccugacacaggcpagagcaag\n", + "ggaaguggaggugagcugucgcpcggcgcccggccuugcucaacgcccagcaguccccaccgucgcugccgccgccaccgcccucggccgcugccgaggccuccugcagccauc\n", + "ggcggcgcccggccuugcucaacgcccagcaguccccaccgucgcugccgccgccaccgcccucggccgcugccgaggccuccugcagccauc\n", + "auuccugacagcaccucccggaccggacauaacgguccccgcgcggcuccccgaaccggaaguggaggugagcugucgcpcggcgcccggccuugcucaacgcccagcaguccccacc\n", + "accaagccuuccacgugcgccuuauagccucucaacuucuugcuupaucuccaaccucaccgcggcucgaa\n", + "ccpccgcgcgcugaggagccgcccggucgccugcgcgcucccuccggcggcguccccagcccgcggccccucugcugccggcccccggcucgccggcugcpaguggccucaag\n", + "ccaaauuucuuuuuucagucacuuacapcuuccggucaaaauucacuagguaggapucaucagcupaagaaccggcgccupaaaccuggcuggauaggu\n", + "ggaagcuggcuaaacuaauuauggaaaauccauacaacggaaugcuaugugccagaagaaagaaugaggaaguucuucaugucuaaucu\n", + "ucacuuacapcuuccggucaaaauucacuagguaggapucaucagcupaagaaccggcgccupaaaccuggcuggauaggu\n", + "acapucucgcacugucacccaggcuggagugcaguggugcaaccccaccucccpuucaagcaauucucaugccucagccucccaaguagcupauuacag\n", + "aguucacaguccccacaagaggcuuucucaccgacacuugaagguguccacugccucccugacaucugugg\n", + "cuguuuccccgaaccucagccccagcgcuucuccuacauccucucggagcaacucacuuacaguccccaccccgccag\n", + "gaauaacucaguuuuagguaagccuccccuauauccuagaauaaccugccucuucggcupaagcggapaaccuucucuuccuuaaag\n", + "ccuguggagcccaggccucuuggagcaucuuupcugacgcagcggagguuccpcacacguggccacucccagcaggaggcugcc\n", + "capuccuccugccgcaggaguaucuugcaguccaacucccacgauuguccugacupaugccacuucaccagaaggagaaaccgacaaaaaccuggccaacag\n", + "gguccuccugccgcaggaguaucuugcaguccaacucccacgauuguccugacupaugccacuucaccagaaggagaaaccgacaaaaaccuggccaacag\n", + "cuugcagaugguguuuuuuggcuacaugguuuucaguauccucuuuggccuccuggcugacagau\n", + "guguucuggcuugcpcucccugcucaucauuggcuuggccucugugaucauccccaccaucpuggcgcuggcucauucgcgucgccuccaucccpcaucauccucaucguggccuucaag\n", + "uuuauuccugaaucugcccgguucaaugucuccacupaacacucpcugcccuggccacucuggagcgcguugccaag\n", + "gcagucgccpccgcpcggcpacggacgaggccpccccpuggcacccggcaggcpcaggcpcgcc\n", + "augcgcuguggcuaaugccguaggcuccuucapcugagccaucccgcgugucuugcgcucgguggaa\n", + "ucuuaucugcagauauguacagaccacauccuaagauugacuucugccucaacagaaauacaugagccagugccuuauuggaaaugauuugcguguuuuaagaacugguguauauag\n", + "ucucacucugucacccuugcuggagugcaguggugcaaucacagaucacggcagugucuaauuccupcucaagugaaccuuuugcaucagccuccugaauagcugagaccacag\n", + "agcauuguuaacggcugcgguucgaaguggcugupuauugcugcggcuggugcgucgucgcucuag\n", + "auuacaaguggacaccugagucagcaggaccuggaaucccagaugagagagcuuaucuacacgacucagaucuuguugucacccccauuauugacaauccaaaggugcagaaagcacucugacaa\n", + "paagauguccauguccpuucaaggccaaaccgaaguuacuggccucuaucuuccaggagaaccaggagccacagccgcggcucacgccccaccgcaacauuaag\n", + "cgcucpagucagguugacgcgcccuggaugcpcuagaggcucpcupcgcgcucccgcggagccggagccgcagaggcucccpcuggacucaggcuucucag\n", + "gacucpaguugccggcgcuucccggcgguggcggcgucucuggccggccuuggugcggcgagccgagcgaggcagcucugagccgcgcg\n", + "agguucgugucuuccuaaaagaagguuuuauupagguaaaggucaaugcguapuagaguaag\n", + "guuuacggagccggugugaacgucggacuucaauucccacaaugccuggcgcaaacgccuaguuuuggccupuaaccgagaggugaccgccaucuugcguacggag\n", + "agagguucgugucuuccuaaaagaagguuuuauupagguaaaggucaaugcguapuagaguaag\n", + "gaggupcuuuuagucccuccagaccucggcuuuagugcugucuccgcuuuucuuucaccuucacagag\n", + "aauucugcuuggucagaaucgugauggcauuguguucagcacugaugacuauuuucaccaucaagaupuacagguauaauguuaaucaacuuggugaugcccaugacuggaaccagaacagag\n", + "aucuugcguacggaggugagguuuguuaccgcgauucugagaggupcuuuuagucccuccagaccucggcuuuagugcugucuccgcuuuucuuucaccuucacagag\n", + "caaaacaagcuaucgaucapaagaucuccaguuauaauagauaacacuaauauacaagcuupaa\n", + "ggugaccgccaucuugcguacggaggugagguuuguuaccgcgauucugagaggupcuuuuagucccuccagaccucggcuuuagugcugucuccgcuuuucuuucaccuucacagag\n", + "uggauaugcugcugaugaaaucacucacugcauacggccucaggacaucaaggagcgccgagcagucaucauccucaggaa\n", + "ucuguuuccaggucuggcppccpcugcgguggcggcagcggupagaugccpcggccggcggaggucc\n", + "agagacgccgcgcuccgccccgaggaggccgccggccpuaagcggagcccggagcucgcggagucuggaccgcag\n", + "gucgaagccgcuggucucagcuguguuuucaccgguucccugaaagagaauacccuguaccuucacagagccag\n", + "gcggcpaggcpcggaggaggaggcggaggaggcpagcugagcugagupcpcggcggcpcccgagccggagaag\n", + "gcggccgcggcggcpaggcggcpaggcpcggaggaggaggcggaggaggcpagcugagcugagupcpcggcggcpcccgagccggagaag\n", + "paggcpcggaggaggaggcggaggaggcpagcugagcugagupcpcggcggcpcccgagccggagaag\n", + "gcuugaaaacaucaauugacuuugugaucauuacagaaaugcugguguaagguguucagaagaca\n", + "puuuuuuagcacgaagupuggcuggaguuugcuugaaaacaucaauugacuuugugaucauuacagaaaugcugguguaagguguucagaagaca\n", + "agcccagugcagcugaaauccuagaagaccucacaacuguguuaaauuuucacagcugaccacuuaaaggcaguucucuucaaauaagag\n", + "acgcagcuugacugacacagagauccugaauaagagacucuuuggauacugaaaagucucuuaaauaag\n", + "auuuggaauugaccauguagauaaucucugagagcaguucuuaaaguguaauccagaaccgguggaacuugcuagaaacgcauauucuucggacccccuccaaaucugcugaaucugagauuguggag\n", + "gccauucaaugucccuucuucaggaauuuggaaaaaggauggagagaucucucugagcuagacucuucaguggaggaa\n", + "aaaguugguccgaguucccagaguuucccucuguggugcccuaggcucggccggccggugccccggcuccuuuccuccuuucggccuucgccguccaccaggucccucucucuguccccggccgcc\n", + "gaguuucccucuguggugcccuaggcucggccggccggugccccggcuccuuuccuccuuucggccuucgccguccaccaggucccucucucuguccccggccgcc\n", + "aagcccagugcggcgccaggagccggacccgcgcccgcaccgcucccpaccgcgaccccggccgcccagag\n", + "gagacpaagguaucggccucucauuucuccuucccucguccupucccpuccupuacguuuggcuagccugcucugg\n", + "agugcccupacaccucuucaguccguggacuuucccgcugcacacugcccuccgaagucpacgcpcucg\n", + "guauccugauauccaggcaucuuacuuaguagaapagauuuucaguuccauccpucaucucccggaagccagagugaugcugaaccaagagagagguuacagcuuagcuuccaggaugauga\n", + "auuguugugcuugaugcuggaaaacauuuugaagacaagacucuaaagagugaccuaagccacacuagcuuauuagaaaaugagaaacuuaucuuaccgacaagcuuggaagauucuucug\n", + "guaauucuauagguacuggagauaguagaagguacacagaugguauguuaccauuuuccucugguacuupaacugagaaagaaauagaaaauuugaapuauuguuccagaucuuaacagu\n", + "uguaauuucacaagccccugacucuguguagacacccagcucuccagaaaaaugcuuugaagacaaaggauacagcauacagucccgugucucggcugagucaucgcauuccuuaauag\n", + "aguuuggaagcagcuggaggaaugaguuagguucccgguugcpacaguuuuuuuuucuuuuuuaaaacagacacagcuacugagugca\n", + "apccagcaggcugucaggcucacagaggcccgapucucccagcgacuugucgacucuggugugagucuggcaggag\n", + "ucccaccgacaucguccugacucccugcacgacgcugcucagaggacauacpccccugcucaaucgagucuucpaag\n", + "agcuuuaupuccugaaagccaapugcccapuguggugucucugagcccuguuaucccuccccc\n", + "guggccagcgapcagcguucgccgccccucaggccccgucccggcgccgcagccgccugcguuucgguuugugagcaggcccggccpccaggagcgagagcgagacu\n", + "gguugaagaucaacuggauuauguauuugguucuggaaucucaaagcaguccacaaacaaauucuuccuuauguugucugugucag\n", + "paacgguguauuuuuaacaacpaaucaguaacuggaaguacaagauugguuauuuaauaauguuaaaaaugaggcuuugaaaagcagag\n", + "cugugauggcgaugugapcccpcpauggugcugacccpucpccgucuucuugcagcuggacaacgagcuccuccguucgacaggcpaagaggccgagccpcgagag\n", + "gcuggagugcaguggugugaucucagcucacugcaaccuccuccucaapuucaagcgauucuccugccucagcuuccugaguagcupauuacaggcccgugccaucacacccag\n", + "uccgccucuccaaggaccgauccacacugcaggugcuggacucggccacapaacugguucucugccuguuucgacaacuucacagaagcucucgcugagacagccuguaggcag\n", + "ggcggugguggcccupcaccuuguguccugccugcgcucuguguggccaagcacccagcguggcucccugcugcuguggagacagccugugauccgc\n", + "agcaucccgapccccgucuucggacgaggagugcuucuuugaccuguugaccaaguuccagagcagccgc\n", + "aaggaagcuuaucuaacacguggaaugaaaaguacaguucuuuacagaaaacaccuguuuggaaaggcaggaauacaagcucugcuguggaa\n", + "agcgcggcgccgcpcagcgagcuccgcauucgaaccucccucgcaaagacagucuccgccccaca\n", + "ggaaauccucauugacgauucaauuuguugaaggccaauuuguggacuccuacgauccaaccauagaaaaca\n", + "cuuuuacaaaguugaucacaguaaauggacaagaauaucaucuucaacuuguagacacagccpcaa\n", + "gaugaauauucuaucuuuccucagacauacuccauagauauuaauggcuauauucuuguguauucuguuacaucaaucaaaag\n", + "acucuggupucuaggcgcggaucggacccaagcaggucggcggcggcggcaggagagcggccpcgucagcuccucgacccccgugucpcuaguccagcgag\n", + "cuggcugcugaauguaagagugcaggcuaccccpacuuugauccccuacagaugugaccuaucaaaugaagaggacauccucucc\n", + "ggupucuaggcgcggaucggacccaagcaggucggcggcggcggcaggagagcggccpcgucagcuccucgacccccgugucpcuaguccagcgaggcggacpcggcgupccc\n", + "auggagaaggaaaggcaagugacuuguccagagccacucugucaaaapacuugaguccucapcuguugacuccaaagcugacaagcag\n", + "guggcauucuucuucagagcapcaaguguaauucuggaccaaugugugauucugagaccagaccaaccaacugaag\n", + "uggcapcaaaaccagugagcaaggcagaaaauuccugaaauucuccacugaggcccagcuguuccucuccuugaaaagucaaggcuugguucaagccagauagcaccugaggacagaacauaucag\n", + "acugaggcccagcuguuccucuccuugaaaagucaaggcuugguucaagccagauagcaccugaggacagaacauaucag\n", + "cagguggcauucuucuucagagcapcaaguguaauucuggaccaaugugugauucugagaccagaccaaccaacugaag\n", + "cuucucgagccagcucucucugupugacaaaugaccacuggcagccuaugcucacauugucccugugucuagcaguuucagag\n", + "auucuccacugaggcccagcuguuccucuccuugaaaagucaaggcuugguucaagccagauagcaccugaggacagaacauaucag\n", + "gucucacucuguugcccaggcuggagugcaguggcgugaucuugauucaccgcagccuugaccuccupaucaagugguccuuccaccucaaccucccaaguagcuaggacuacag\n", + "gagaggagcucagagaagcgagagcaaapaapuuugugacgcagaugagagcaggaagagaaaaaggcucug\n", + "cccaagcaccgaapccuucguuuuaagaccgcauucucuuuacccacuacaaguugcuugaagcccaga\n", + "aguuuguuggcugcggcagcagguagcaaagugacgccgapccugagugcuccaguagccaccgcaucuggagaaccagcgguuaccauggapauca\n", + "aguuuguuggcugcggcagcagguagcaaagugacgccgapccugagugcuccaguagccaccgcaucuggagaaccagcgguuacc\n", + "gcggcggccgcpapcacggcgucagcgcgucgccggcupccgcgccgguggccaggapagagacaaggaggaggaggaggaggag\n", + "gaaucaucuuucuuccagauugugcuucaagaagaccauapaagaacgcauuuucaucuugcugcaaaaguugcaauagaa\n", + "ugguauaauguguuauagagguggacaagccugcagauugaagupaucguccagauuguucccuucccuggaccauaug\n", + "auugugcuucaagaagaccauapaagaacgcauuuucaucuugcugcaaaaguugcaauagaa\n", + "acggcgucagcgcgucgccggcupccgcgccgguggccaggapagagacaaggaggaggaggaggaggag\n", + "aggucuggcuagcugucccuaacgucauuuccuggucucaacucuuuaagacccugacauacucugagauuggagugaagauuucugugacaugcugg\n", + "cagauugugcuucaagaagaccauapaagaacgcauuuucaucuugcugcaaaaguugcaauagaa\n", + "pcacggcgucagcgcgucgccggcupccgcgccgguggccaggapagagacaaggaggaggaggaggaggag\n", + "cagguaucucugcauuagccagauuggacauauguaaapacaucaguauaucuggaucaucag\n", + "gugcuguupaacacagaggaagugacuggcupuucapaaagcuccguagaagapaacacuugagcupucuugaagg\n", + "agagccggagcccgagcccggagccugugccggagccccagcccggcccugcucpccgccpcgcpcugcggccgcgucccggaggcgccgccagcacagccag\n", + "uaaacaagaauaugcacgcgcaguggaccacuucugaaggucaacauauaacuuucucaucccugacaucaacugucaucccugugagcagaaccaacuaccaaaggagagag\n", + "cuuccugcagaccuggucgagaacacuacuucaggacapaauagugacaggccagcagagccccagaggcgagguggcag\n", + "aagagaaaagagagagagaggugcucuggcuccpcucuucucccaaacpucgaggucccagcugaggcucucccaggacaag\n", + "ucccucagccccagugaacgucaccgucaggcaccucaaggccaacucugcaguggugagcupauguucuggaggaugagguugucaucggauuugccaucucccagcag\n", + "acuuuagcuaaacccgguuccaaapupagucgucggagaggaauggccucuguaucuccggagacggaaacaccaggacgaagaggcccuaagaac\n", + "gccaguuccuagcgcagagccgcgcccgccaugapagaucgugcacauccaggcpccagugcpaaccagaucggcaccaag\n", + "aggcggacpucagcccaaagcagaggcucggccaugaacuuacccpacagcggcggcggcggaccuuuuggccaucuucucgcagagugcucccugcuaacpacag\n", + "gcugauuuccuuucaccaagauacugaauuuuggacuucuucaaggcucagucuuggacccucuucuuuuucuauacucucuag\n", + "cuccgccgcaaacuuuuuccuccccauccugucgcggcucgaaaggaauggaaaauggcggccuagacgcggaguuuccugcccgacccgcggcggcuccggcggcgcc\n", + "cuccccauccugucgcggcucgaaaggaauggaaaauggcggccuagacgcggaguuuccugcccgacccgcggcggcuccggcggcgcc\n", + "agcgcaggcugauaaccgcacggaacuucccaggcacccuguguggccgcacugcucccucuggcccaacc\n", + "ccccucagcucagccucaaucaagaaguuccccaucuuugaccacuccaaguaggagaaaccggcccapcucccuuagagccgagaacagug\n", + "auuucccuuuuuaccaagaagaaagauuuguucagccuggugacgcuucagaagagaagaguuuaacgacauugauauuuugaaauauuuugugacucaaauuauagcaauacg\n", + "gcuuccugaacggcpuggauagagaagguuggcgcpaagaccggcpaggcgcgccccpcccgcggcgcgauuggcgugaccggcg\n", + "cupaacuucuccacuucaucuagcagcacaguauggucauuauuccaccacagagguacugcugcgagcuggugugagcagagaugccagaaccaaaguggaccgaacaccauuacau\n", + "gaaacuuugcgcccaguccgcapcpccgcgccuuuaccgcccagcugccucccggagcccccgcgcccucccgacgcgcagagcc\n", + "gcacaccucuacauuguguucagugccuaguguaauucupcauguauucuagacagaguagaucggauugguucuggcauugaauaag\n", + "gauagapaggaaucagcagcuuggaaauucaagcacgugaucuggcpaupcguuugccuaacguauuuaauggag\n", + "ggucuuauucugucaccuagguggagugcaguaguacagucacagcucacugcagccccaacauccupcucaagccauccuccugccucagccucccaaguagcupaccacag\n", + "cuguguucugcagcguuuuguuggauacuauugauaacugguucuuuaaggaaapcuuaaacaggccuugguuuguagag\n", + "agauuccuuucaggaccacgcugagcugcucuggagccugaggcugguggcacpcuggcccaggaagug\n", + "auuccuuucaggaccacgcugagcugcucuggagccugaggcugguggcacpcuggcccaggaagug\n", + "auccuucugcugcaauuggaccucaucgaacagcagcagcagcagcugcaggccaaggaaaaggagaucgaggagcugaagucagagagagacacg\n", + "agaagcaagcggagcggccgccaggaaggacucaccgaggcgcapcuggagguggugcup\n", + "aguggcguucggcpacccgcugaggcaaagcggagccgcagugacagaagcaagcggagcggccgccaggaaggacucaccgaggcgcapcuggagguggugcup\n", + "aguuagupuaggccugagagccgaggaaaacugagcgupccucagaaagaaguuaaggcacccgcgagccpcaacugcccuccuuccgcgccggcggag\n", + "ucgucauggccagugucugucuggcgcccggugcccaggcacugugcgagaccaguccgcapcgacucggagagcgccpccgcggcpagaagagccugcag\n", + "caagacucccccaugaugaccuauucauccaccuaccuccucacucuguuccacugucucccuuaagagag\n", + "ccgccgccgccugcgcgcccgcccgccuuucgcggccgcucuccccccuccccgacacacacucacaggccpcauugaug\n", + "pugauguuuuacaggcacuuaaguauucaucgaagagucaccccaguagcggugaucacagacaugaaaag\n", + "gccgccgccgccugcgcgcccgcccgccuuucgcggccgcucuccccccuccccgacacacacucacaggccpcauug\n", + "gccgccugcgcgcccgcccgccuuucgcggccgcucuccccccuccccgacacacacucacaggccpcauugaug\n", + "uccggaaagcgcggupacgcgcuguguucucgcagcucagaggcpucugaggcucgguggcggcgcccapuggcccpcccuuuccucggucguugucucaccgccacaggcuccg\n", + "aaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "gcacucagcaucucgaugaaaacuguuggaaaagaaaaacuuucagagucauucugcccucagaguagucaagccaacuaaacug\n", + "gccuuucuguauagagcccacaaacaucgugaaugugaaucaugucauucagapuuagugaccaugccucugcc\n", + "auugccccagaccauguaguuccagcuccagaagagugcuauguguauaguccauupcucugcuuauaaacuucaaaguuacacugaaggauacgguaaaaacaccaguuuaguaaccau\n", + "gcaaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "aguuuccugaauaaguuuuucccaaguucuguguuauucuuuuugaugaaaggauacuggcuucccuacaaucaucuuuucaacuucuaaaauguuuaauuuuuuaaauugag\n", + "aaauuuguuuaacugcguagauuaaauggcaauauauuuucuauaaugaaacuuguugaaaugagapaaucagcuauuuacaaucauggcauaacuaccuag\n", + "ggcucuguugucagcuugguauuauaauggaaaacaauuggauaugucagagacuuagucuauuacauuucc\n", + "gcuauugccgcuuccuguuuggacuaggagccccgcggucgcaaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "uuggacuaggagccccgcggucgcaaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "auugccgcuuccuguuuggacuaggagccccgcggucgcaaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "cccgcggucgcaaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "gcuuccuguuuggacuaggagccccgcggucgcaaauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "aauugcgagaauuupaapaaucuuuaucuucucgucuaguucuccgagguugaaggcucggccugcucag\n", + "uuggcupcuaggcuuccpcucugcgguccucggccugugcuggcagccucggagcccaccgagccpcggcup\n", + "aucaggucacgugaggccggucacgccccpcagcuuggcupcuaggcuuccpcucugcgguccucggccugugcuggcagccucggagcccaccgagccpcggcupaug\n", + "gucacgccccpcagcuuggcupcuaggcuuccpcucugcgguccucggccugugcuggcagccucggagcccaccgagccpcggcup\n", + "cuuggcupcuaggcuuccpcucugcgguccucggccugugcuggcagccucggagcccaccgagccpcggcup\n", + "pcpcagcggcgacgcupugugupcgcagauggcggcggcgcacggcgccugagcpccpcc\n", + "aaugcgcgaggccuggacpaguggccgaggcgguupcggaggcggagcaggcgccaugucagcccpaaguggccgugcugcugcuguggcugagcugcuauggcuccgcccuuuggag\n", + "auuaaguuagaguaugaaggaacauuauuuacugaguggagugugccagaaacuuguuuugugcuaaauaaaag\n", + "cucacccacgacagaauugcguuguuccucaccugguguucacgcuauaaaaccaauuguuacuggccca\n", + "gaugaagaagaacgcuauuuauuuguggaaaguucucauacuugcuuucugugguacuauagaguuag\n", + "gcauuucacguggaccagguggaucaucugugcgugcagcugccuuggcccucucaguugcccccgccccgupagucpauuccauccuucgugauggcauccauaccpuugag\n", + "aguguagcugcgagaaccuuugcacgcgcacaaacuacpacgauuucugauugauuuuuggcgcuuucgauccacccuccucccuucuc\n", + "gucauuuuagugcuauaauuauguuuauuucuacuuuagaaaaccuaacaccuuuaaaggaucuccacaauuuccuccaauaaaugg\n", + "auuaaucccugagacaaagguacugaaggcaaguggcugaagaacaggcuugauuggacagaugacuuggagauguucacuggacag\n", + "agaugcccgagugguaaaagacauggcaacaggaaagucuaapauauggcuuugucuccuuuuucaacaaaugg\n", + "caaauaccaaacagcuaucauaugaugagguuguaaaucagucuaguccaagcaacuguacuguauacuguggagguguuacuucupcuaacag\n", + "auucacacuucapcggcuuucagcucuggucggaauaggacugugcauucccaggcguggagag\n", + "cgauuauuggagccggaauugguggcacuucagcagccuauuaccugcggcagaaauuupaaagaugugaagauagaccuguuugaaagagaagaggucpccgccuggcuacc\n", + "aaaaaguuugccaaucccuggucuacuggagcagguuggagaagcugugagcucguugaggaaagugacuaagcuuuacaaaggaaaagagccagcaggcaacaugguguucuuguugg\n", + "ugugaggaauccugguuuguaucugcugagugaccacauuuucugcuuugcugcagaucggaugaccaugaagaggcgucaguccuuccucuucuccacgcaggcuucaacagg\n", + "gccugcpucccggcuggcggcugcuuccgguaggagagcgguguagagcgagcaggucucagcuccucguc\n", + "cccaguuucuccgucagccugcpucccggcuggcggcugcuuccgguaggagagcgguguagagcgagcaggucucagcuccucguc\n", + "gcucgcggcggcggcgacggcggcpagguucgguugucgcccguuggccgcgcggcgccgcgcucggcggccgccauugcag\n", + "gcgcaggcagugcucgcggcggcggcgacggcggcpagguucgguugucgcccguuggccgcgcggcgccgcgcucggcggccgccauugcag\n", + "aagugcaaauucucagauucucccggaguugccuagucaggaacucupuapccagcaggcuuuguauuuaacgcugucuccag\n", + "ccaugcuucccuuucugcaggcaccuacauuggaugcuucagugacgauggccacgagaggacucugaaaggagcuguguuuuaugacuugagaaag\n", + "acucuuguuaacuccaugcgucugaaagcccucagcuccguuaagcuguguuccuggaccgccupccugugccuaugcacugcuccaucucucccauguuucaggcuucauccauggcucugg\n", + "augaaacucccuuuuaggaagacggaguaagaggcaccaccaccugcuccugcugccucugcuguccucagcuucupagcaucuuagcagccagcuccgg\n", + "uuuuaggaagacggaguaagaggcaccaccaccugcuccugcugccucugcuguccucagcuucupagcaucuuagcagccagcuccpugaggacapuccaccggugcac\n", + "auuggucggcgugccgucgccccgcuggapaggacucaggccccgcuggccgcpcucgguacccggupucgguggagcgucuguupuccpccgccggcuucgcccucgcc\n", + "gaggacucaggccccgcuggccgcpcucgguacccggupucgguggagcgucuguupuccpccgccggcuucgcccucgcc\n", + "ccgcuggccgcpcucgguacccggupucgguggagcgucuguupuccpccgccggcuucgcccucgcc\n", + "gcuggccgcpcucgguacccggupucgguggagcgucuguupuccpccgccggcuucgcccucgcc\n", + "uuggucggcgugccgucgccccgcuggapaggacucaggccccgcuggccgcpcucgguacccggupucgguggagcgucuguupuccpccgccggcuucgcccucgcc\n", + "guugucgcgaaggccgcggcagaugucccgcaccucggcgccggacagcggcucccccgaaaucuggauggagcupcagcaucgugcccacggcupccuccgg\n", + "guccauacuacugacuuucccgguaacuauuccgguuaugaugaugccupaccaggaccgcuucgagaag\n", + "ucgcpccupaccccpcuccucacgugcaggcgucgguccpccacuccagugacgapuaggauccgcagccccuucgcgaagcccgagcgagaccpcgacaggcag\n", + "guugacgccugcgguugcugcgguggugacpcuguupapccauupapaaacggagcagugacagguaucccagapugcugcugaggcgacg\n", + "ugcgccggccpccccgcccccaugcgccgcgcggcuccapccacguuccapucpuuugguggauuccucagucccugccgccgcpcgcccupauagcggcpccuccug\n", + "ucaccugcagaauccauuaaggccuggaggccuaaggaguuaguauuguaugaaaucccuacgaaacccggugaaaagaaag\n", + "augucucupccccugccuccugcauacagcccccgauauguugaggcugccugguacccguggupuacgagapcuucuucaaaccagaauaucag\n", + "cgcggcuccapccacguuccapucpuuugguggauuccucagucccugccgccgcpcgcccupauagcggcpccuccug\n", + "acgcugcpuccupcccaggccuupaupcpaaggcuuggccgcgccpcugupcacugcaggaggccccugugcag\n", + "gcccccaugcgccgcgcggcuccapccacguuccapucpuuugguggauuccucagucccugccgccgcpcgcccupauagcggcpccuccug\n", + "ugaagccacagccuggccaccugucuugaucuccccaccgagaaggccccgccccucccgcugcagccccacagc\n", + "gcucgaggcgucugccgcaccucagcccacgaccugccccgcupaggugcpccgcuggccaggcccugaccgcaaccuggcccagaggccccagcccucaggcaagguucuccgg\n", + "ccuuuccccuupcccuguccuucccagucuugccccagccucpaggugguggagugaccuggccccagugcugcguccuuaucagccgagccg\n", + "agucuugccccagccucpaggugguggagugaccuggccccagugcugcguccuuaucagccgagccg\n", + "ccucugagcccagcccucccuagcaucaccacuuccaucccauuccucagccaagagccaggaauccugauuccagaucccacgcuucccugccucccucag\n", + "uuuggucauugaguaaaacucuuuauuuuuauauacuuaaaaguguucuuuuuauuuuaaaacaucuguauaauuuuuaguuaaaaaaa\n", + "aucaaaggugacagcuuccggcaacugaugccuccacuggccacuccucccuccguccaccugucacuucpuagcupaggccag\n", + "cagcuuccggcaacugaugccuccacuggccacuccucccuccguccaccugucacuucpuagcupaggccag\n", + "caaaauaaggaccuuuagguguucuauuauaagugaagaucuaagauuuuccaaguuacaacugaagag\n", + "gcggcgcuggaaauccggcggaggaccuagaaguagcpagcgaucugupcpcgaacggccugccggccgacg\n", + "gcucccacaucaggacgagaaggagcccucgaguuaccgupagcugupagcugcccugugacucuuaggaag\n", + "uuguauuuucacugacucauauuuccuuuacucaggcucccacaucaggacgagaaggagcccucgaguuaccgupagcugupagcugcccugugacucuuaggaag\n", + "ucugcggucagucggacgcggcgcuggaaauccggcggaggaccuagaaguagcpagcgaucugupcpcgaacggccugccggccgacgguapccugaagagccuagg\n", + "acucaggcucccacaucaggacgagaaggagcccucgaguuaccgupagcugupagcugcccugugacucuuaggaag\n", + "apcugccgagaauuaacccccgaaccgccgcgagcugucccuagcagugccuuagccapaccugcuuggccagcgacagauccuuugcugcucugucugccgguucuugag\n", + "gagcguccupaguuggaauucagaaggaaucucucagacgcaaaucuccaucuccucccugccucaccupcagccuuuucagacugucucugcccaga\n", + "gugccuuagccapaccugcuuggccagcgacagauccuuugcugcucugucugccgguucuugaggugaaugucggaauccauuaucuuucpaaagcucucupcagg\n", + "aacccccgaaccgccgcgagcugucccuagcagugccuuagccapaccugcuuggccagcgacagauccuuugcugcucugucugccgguucuugag\n", + "aaccgccgcgagcugucccuagcagugccuuagccapaccugcuuggccagcgacagauccuuugcugcucugucugccgguucuugag\n", + "gcaggacccguccccgccccagcccuuccgcagcuccuaggacugucgucuucgcagucagcacguccgcg\n", + "ggagccugccgcuccccgcgcucguagcgcpccupacupaucccgccgccpccgcagc\n", + "gccggagccugccgcuccccgcgcucguagcgcpccupacupaucccgccgccpccgcagc\n", + "uccgcauucaguugucgaggagugccagucaccuucaguuucuggagcuggccgucaacauguccuuuccuaaggcgcccuugaaacgauuca\n", + "guugugcaccaucuccaggugcuuaugauguuaaaacuuuagaaguauugaaaggaccaguauccuuucagaaaucacaaagauuuaaacaacaaaaag\n", + "aaucuaaacaaaaucuuaauguugacaaagauacuaccuugccugcuucagcuagaaaaguuaagucuucggaaucaaag\n", + "auucguguucuucuacaggaacguggugcccaggacaggcggauccaggaucuggaaacugaguuggaaaag\n", + "aaugcacuuucuaacgucuccggapaagugcgcuugcgcaaaugcuagguuacacuugaguaacuccpaaugacugg\n", + "agcugcuaagaaggacaaauaagauagcagagugaaagagcuuuugucuccuuagaaggaaggcugagaaacuaaag\n", + "uccccucuccccaccacaacccaaugaccucuacaagaaucccacaaguuccagugaauucuacaaggcccaapccacuuccuaaccagcauagccugaapc\n", + "gcaguuugaaaauugcaaggapacuuuaagacuacuucugauuugcaaagauugucugugcucugagcaggcugaagugacuggacgagacgcacuguuggagaaauaaaa\n", + "cucugcagcucuccucccuccuguaaugcuuccucugccugcagugucauucaucaccugacuuuuaaaaucuucgcuuauccucag\n", + "auuugcagaucaaggagaacccaggaguuucaaagaagcgcuaguaaggucucugagauccuugcacuagcuacauccucapuaggaggaag\n", + "auuccaaggagccuagcucuggcuccugaggugaccccagcccagaagucccauuccccucuaccccaacccccagaauggcaggaggagcapcagucupagugacag\n", + "ccccupucccpagugagucacggcggagacgcugaggaggugcuggcgcagcaccccacccccaccpcgapcugagcgcaggccucgccccccagauuccagcgcugaaggag\n", + "acagucgcucugcagccuccggcgacuppaugugaggccggcgccccagccccccgccccgccaugagccccccgcucugapccccggccccugg\n", + "cuuccucucgccgucucacagucgcucugcagccuccggcgacuppaugugaggccggcgccccagccccccgccccgccaugagccccccgcucugapccccggccccugg\n", + "gcagccuccggcgacuppaugugaggccggcgccccagccccccgccccgccaugagccccccgcucugapccccggccccugg\n", + "ggcgacuppaugugaggccggcgccccagccccccgccccgccaugagccccccgcucugapccccggccccugg\n", + "acacacacacacacacgguggaaacucuauaccccugugccuagucagaaacagugacpapacccapaccaggccucgag\n", + "gucgcucugcagccuccggcgacuppaugugaggccggcgccccagccccccgccccgccaugagccccccgcucugapccccggccccugg\n", + "cguuccccucagcaggcauggugugugugupugccagupapcupcagugauucaaaucagauccuggaacuuuccugag\n", + "gagguagagaaapagcgapagcaagcaagaagcuggaggaucagugccccuggcpapaupuggcpagaacugccccuccccccagccacaaacccaucag\n", + "uacuguaagauugauguuaaaggcaugguguucaccccacuucaucagcguacauaaguuaucucuucuuuuggacccuuauuuuaugccaua\n", + "ggaggaagacpuccccagagacccggcaggccpcggagguugaggcagcuaaacuccagguggacgccuacaucgccuuucgcg\n", + "ucggaagugcggccgccggaacuggcuguuggupugcagcacugagccgccgacpcpupcuuugcugccgagcaggcggcgccgucuupccuagcggcgaggcgacccgcacag\n", + "cpcpupcuuugcugccgagcaggcggcgccgucuupccuagcggcgaggcgacccgcacag\n", + "gugcagcacugagccgccgacpcpupcuuugcugccgagcaggcggcgccgucuupccuagcggcgaggcgacccgcacag\n", + "auuuapcgguuggcuuuguupugagcuuguuugugucccugupuggacgugguuggugauuggcaggauccugguauccgcuaacag\n", + "gcuaugaggaauuupcucaguugaaaagccuaaacugccucucpagguupcgcggcgaacuacuuucagcggcgcacggagacggcgucuac\n", + "auggagaaaacaaaggauucagauugaaggacugcucagacacccuccgaagagguggcccugccugcgcuccuccuggcugcagaguaccccaccagcgc\n", + "gguucauaguggcgucaugcacgcagacuccugcaaguuccccuaaguucuuagaggacugcuuugccuuuugaucugagaguugcaaaguuccauaaaga\n", + "gguuucaucaccuuaaaugguuuugaaccaaugaagguguauucccuuaaaaagacggacagcccaucgugugaacuauagaguuuguggacagauuuauauug\n", + "aaauccccgcucugcgugcucgugguggaggcugcuggcaauggccuacgucgucauaccpcuuccuugcccuguccp\n", + "gcuccggucgcgcacpacgaacugcpagugagccgcgcpccgccguagucagcugcuaagagcaggaagaguccgagcggcpcggagucugcagg\n", + "cuuaccgugacaaucagagcuuuguugcagaaccugaaggaaaagaucgcccuuuugaaggacuuauugcuaagagcugugucaacacaucagau\n", + "aacacagcuugaapaccgaagacagaaccucuuggaugaucuuguaacucgagagagacuacuucuggcauccuuuaagaaugapugccgaaccagaucuaaucag\n", + "agugauaauaucaggagaaugcugcuaggagaguuggaaguucccuuggugaaagcuguguuugguuuagauacgacugaauuaggauaauuuaccaaaaucaguaaaauaggugagau\n", + "acagugagcauuuucauacuucuauacacagacaapaaacuuucauccccacgcaggauauagcuuuuugcucugcagagucuaacuuuugcaaguggaagcuuc\n", + "aggagaaugcugcuaggagaguuggaaguucccuuggugaaagcuguguuugguuuagauacgacugaauuaggauaauuuaccaaaaucaguaaaauaggugagau\n", + "agugaguagcacgugcacccaagcggcaguucgccccgcagcgauggcggacacggaaucccgapccaccaacugucccuuaggaccggcccgag\n", + "ggaguuaaacacaaucugcaggaaagcaaaupacucggacucgcuccupcgagcugaaagucggcugcagcagaagcuccugccuugg\n", + "uccugguggacucucccupaaagagucccugaaucucugguacgacugcacguggaacaacgacaccaaaacaupccugcaguaaugucagcgagaaug\n", + "cpcacggaggcccgagcgapacaagacuccgacuccagcucugacuuuuuucgcggcucucg\n", + "gacuccaggagucuuuccucauuuacagcuagcucugccagucugugucuuugcugugucuguggau\n", + "ggaggucuuacccaacagauugacgcggcguuaguauuggccguguacccgaaaaacugauugacupcuggcguuaacugugcggaggcag\n", + "augugacuggaguccgcguaggapucggaggucuuacccaacagauugacgcggcguuaguauuggccguguacccgaaaaacugauugacupcuggcguuaacugugcggaggcag\n", + "gcccccuugcuucgcgcgcgcgcagccccgcagcgcagcuuuggcggcgccagcagcggagccaacgcacccgaguuuguguuugaggccacccugaggaucpacagcuguuccuuupcu\n", + "caauggaucgupcaauggacacgcaacugaucucuggcagaacuguagcaccucuuccucaggaaauguccaccacuguuucucaucaucaccaaacg\n", + "cuucgcgcgcgcgcagccccgcagcgcagcuuuggcggcgccagcagcggagccaacgcacccgaguuuguguuugaggccacccugaggaucpacagcuguuccuuupcuguaa\n", + "ggcagaguupuggaaacuuggagacaaacggaaugcggagagcacupucupaaaccagccuccucgccgcugucucccccaccgcaugccacggcugucuccag\n", + "ucgcgcgcgcgcagccccgcagcgcagcuuuggcggcgccagcagcggagccaacgcacccgaguuuguguuugaggccacccugaggaucpacagcuguuccuuupcu\n", + "apucuugccuuaacaucccuugcauuuggcugcaaagaaaucugcuuggaagaapuuacgcuguuuggccgg\n", + "gcgccuccgucgcucggcccagugcguucggccucacgcccagcgcucuccucgcaggcagaaacuccgcugagcagaacuugccgccaga\n", + "gcuucgcgcgcgcgcagccccgcagcgcagcuuuggcggcgccagcagcggagccaacgcacccgaguuuguguuugaggccacccugaggaucpacagcuguuccuuupcu\n", + "accaucgagagcagcuuccggcguggcugguguaggcpuggagaaggaucpcccucgccgcucugucucauucccucgcgcucucucpcaac\n", + "cucuaucgacgagucugguagcugagcguupcuguaggucgcugugcugugugaucccccagagcc\n", + "auguuugucuuuuaaagcaacaapaagapcaagaggaugcaupcuupaguuuauuuucucuccuccugucuacaccuccucuaaucugucuccc\n", + "gugcaccgcgaaucccuccuccucuucuuuaccucucucccuccuccucagguucucuaucgacgagucugguagcugagcguupcuguaggucgcugugcugugugaucccccagagcc\n", + "ccgucugcagacgccugucagcauggaaagucpcuuucgcccpuccuccuagaaauuccccccgaagaagacucccccacaucugg\n", + "aagagauuaaaugaagauguguguguguugaagacugcauagugcacacucuguguggcuaccggugagccacguggcpauacaggacucaaagaagaucacacuggagaapa\n", + "guucaugcucuguugcccaggcupugcagugaugugaucacagcucacugcagccucaaacuccupcuuaagugauccuccugccucagcuccccaaguagcupacuacag\n", + "aagaccaguauggugcugugaaauguugcaaaacaugaccugaugacaacccaaaacacuucauagaaaacuauccaagaaugugacuuccuggaguagagucuuuuuucacugagg\n", + "uagucaccgccuccccaccccaapaaaacaaauuaaggauugacpuccugccucguccccggcugapcgaggaggcugucgugcugucuucagaaaagcgaggaccpcccpag\n", + "gugaaaguuacacaagaacugaaaaacauucaaguugagcagaugacaaaacuucaagccaaacaucaagcagaaugugauuugcuugaagauaugag\n", + "gguaugcagaaguuggcuagucaauaccugaagagagauuggccuggaguaaaagcugaugaucggaaugauuacag\n", + "uguguggaccaguugacaaagauccaaacugaauuacaagagacagugaaagauuuagcuaaaggcaaaaagaaauacuuugagacugaacag\n", + "ugaccauugaggaacaugagguguuagaagugauugaagauggagauauggaagacupuaaag\n", + "ggucauaggcagaapacuugccuugucucagaugauacuuuggauugugaacuuugaguuaagacuuuggaggacuguupaaggcaugauugguuuugaaau\n", + "agacapuuuugccauguugcucaggcuggucccaagcucuugagcucaagugauccuccugccuuggcuuccaaagugcupauuacag\n", + "cucgcggccuggcgcgcccccuccgaagcgcaugcucgupcacgcacgagccucaagauccaag\n", + "gupcacgcacgagccucaagauccaaggugcgcgcgucggcguccgaggcgguuggugucggagaauuuguuaagcpacuccag\n", + "gguugucucugucuucuauagcuuggaauugcgauupuucuuggucccuccuguuuugguacccaacauugaagaccpacgagcuugccuaccacaucagcauc\n", + "acuucugcuuucugacuugauuacaggcaucuuuccuuuuucaugcugugcaaaaacuugagcucagccucucaccccaacacaauucaagacgcagccuugucccagc\n", + "uugucucugucuucuauagcuuggaauugcgauupuucuuggucccuccuguuuugguacccaacauugaagaccpacgagcuugccuaccacaucagcauc\n", + "cuuggaauugcgauupuucuuggucccuccuguuuugguacccaacauugaagaccpacgagcuugccuaccacaucagcauc\n", + "uupuucuuggucccuccuguuuugguacccaacauugaagaccpacgagcuugccuaccacaucagcauc\n", + "acggagucucgcuuugucgcccaggcuggagugcaguggcacgaucucagcucacugcaagcucuaccucuugguucacgccauucuccugccccagccucccaaguagcupacuacag\n", + "cagcugcacagaagguupccauccaaccaggcaguccgccugcacagcagcugucccugcucaucpcuggaggacagaagacagaacccuaaaaccacag\n", + "cucggccggcagcggagccgcagccaccagccgcccgcgcccuccagccccguccpaguccccggcccgcugcggugcc\n", + "gcagcgcuccacucggccggcagcggagccgcagccaccagccgcccgcgcccuccagccccguccpaguccccggcccgcugcggugcc\n", + "agcuggcuggcagcugcacagaagguupccauccaaccaggcaguccgccugcacagcagcugucccugcucaucpcuggaggacagaagacagaacccuaaaaccacag\n", + "cucucaggcgcggcggcgcgcccpupuggcugaggcggcggcpcccaaggcgugaggcgccgcccpuguccccgcggcgcaggaggcgguggagcgcagagcpcgagcgcg\n", + "gucguaccuagcucagcugcaaccaucaaacuucaugaucaaucaauuggcacacagcaaupaacauagcccuuupagaguuguguccaccag\n", + "gaucucauagaucagaacauccuggagccuguaaccggugcacagapugupuuacaccaaugcuuccaacaauuuguuugcuugccucccauguacagcuuguaaaucag\n", + "augaagaagagagaagucccugcaccacgaccaggaacacagcaugucagugcaaaccaggaacuuuccggaaugacaauucugcugag\n", + "gacagcuccgcgagcccccuacaacucguuuccuuccguucaccuucgcapcggcgacuggcggcgcg\n", + "aggcuggcagguggacaggcpcaaggacagcuccgcgagcccccuacaacucguuuccuuccguucaccuucgcapcggcgacuggcggcgcg\n", + "cuggucuccaugucaucugccagaaaggccaccugcgccagcaccuccugagaccggccuucaaagacacgacgc\n", + "ucgucauugaauuuugagaagcauucugaaaacuuugcauggacagagaaucguuaugaugugaaccgucgacgacacaacucuucagauggcuuugauucugcuauupcguccuaauggag\n", + "ccgucuuuaaauccugaguaugagagagaaccaaaucacaauaagucuuuagcugcaggugugup\n", + "gacuuugagcguccggcggucgcagagccaggaggcggaggcgcgcpccagccupccccagcccacaccuucaccag\n", + "aaaaagcgccccgccccgcgcuccucucuugacuuugagcguccggcggucgcagagccaggaggcggaggcgcgcpccagccupccccagcccacaccuucaccag\n", + "guaaauccupacugcugugcaaggcagagucacuapacggacucuggcagcagagcugcgcucucgugccccagccagccaggcucuccugg\n", + "gaucupcuggaapcugccgagaccaucaguccaaucuuuggucuacagguupaaacugaggcucaaggaag\n", + "gcucugcguccugcuuuguguaaggagagagcupcagugaggccgaaaguccuuccugagcucacaguccaaguugcaaggaaucacaucauuuccaaguaccc\n", + "guaggcucugcguccugcuuuguguaaggagagagcupcagugaggccgaaaguccuuccugagcucacaguccaaguugcaaggaaucacaucauuuccaaguaccc\n", + "gaucupcuggaapcugccgagaccaucaguccaaucuuuggucuacaggupaaacugaggcucaaggaag\n", + "gucaguppccagaapaccucaugugugagaucuggaagcpaauuggagcagcaguuucauucugcuucagcucaggaag\n", + "gacuaacccaggaaagaggaaaaaauacauuuaacagugaagaggcaacacagagcucccuauugugaaauaaaacccauuucaaaaguuauuggaaagaaaguaag\n", + "gacuaacccaggaaagaggaaaaaauacauuuaacagugaagaggcaacacagagcucccuauugugaaauaaaacccauuucaaaaguuauuggaaagaaa\n", + "apuguuggaaucacagcupaaaucapacgccgucccggaggaggugccauuugagccgagucgaagaacgugupaauuuuccagguggacuccauaagccagg\n", + "gcupapagaccapcgcaguuccpcgcgucugagcgguucucgaggcguucucgccucggucucuggcgagugcacgg\n", + "aauaaaaggaacgapucuggcgaagacaggaguguuccucugaaaccucpccccuggcaccggagcuuaguuucuggcggauuggaggcagaaugacauuugcacugaagug\n", + "auuaapacaauaauggccgcuuucaagguguggauuuuggcuccuugagccugucugagcgapuggcagcgccggcgccccagaauccpacagaapucccaagagucgcgcuuggugag\n", + "ggacucaugaaguggcagcuaagcccuguccaguggccacccgucagccaapccagagaccaggaaaggaagaaaggcagcuucacuuccucuuugagg\n", + "ccagapcgccagcgcccaccaagcgcagaagcccpaggaccauccapcuccccgacauuuccucaguuagccagagucppcucagacaucug\n", + "acggagcccguggcuggugaggccgcagagcapccaggccpcccugcccgcaaggacgaccaaaccccucaccggccccupccccagagcccaccaggcucuccugcuggccccacc\n", + "aaaggcggucuagaugugcagaaggugcaagccagagcucaggcagaacuuccagagugcaucupaucugcauuugccacugguugcagaucaggcggacgaggagccpaaggcagagcc\n", + "caaaggcggucuagaugugcagaaggugcaagccagagcucaggcagaacuuccagagugcaucupaucugcauuugccacugguugcagaucaggcggacgaggagccpaaggcagagcc\n", + "gugccuguacuucuuccgccuacuguaucauagcagcuuagaaucccagcugcuggcucpcugcaguucucuc\n", + "ggauccggauccggugcugugcacacuggupagaguccgacgcgccuggcuaggagcgccgaccgcapccucuacgg\n", + "agauuagaaacuucpuggagapcggcggcguugaauguguggcggaagcgcupucacggcuccgcgcgccgccggacagccggcggcgucuccacagc\n", + "agcugcpcgcpcucggccpcaccggugagucgccggcgcugcagapaggcggcacuggucucgacgupcggccagcg\n", + "cucggccpcaccggugagucgccggcgcugcagapaggcggcacuggucucgacgupcggccagcg\n", + "ccpcaccggugagucgccggcgcugcagapaggcggcacuggucucgacgupcggccagcg\n", + "pcaccggugagucgccggcgcugcagapaggcggcacuggucucgacgupcggccagcg\n", + "ccggagcugcugguacucccgauuggagacguagaaccguuacuugucgapccuuagcggccgccgugacccucucpaucccacg\n", + "gcgguacugugacgucaccugappcacuuccggucucgugccgccuucccaggacccucapagagcpcagccuuccagguggacag\n", + "auucaaacgcucaagaaauuaaggacauuuauggacuaaauggacaaauagagcacaaacuagcuuuccugagaacucaugugccaaaggac\n", + "acuuccggucucgugccgccuucccaggacccucapagagcpcagccuuccagguggacag\n", + "ggcacuuccggucucgugccgccuucccaggacccucapagagcpcagccuuccagguggacag\n", + "gugacgucaccugappcacuuccggucucgugccgccuucccaggacccucapagagcpcagccuuccagguggacag\n", + "accugappcacuuccggucucgugccgccuucccaggacccucapagagcpcagccuuccagguggacag\n", + "gappcacuuccggucucgugccgccuucccaggacccucapagagcpcagccuuccagguggacag\n", + "gacgcggugacgcpcacugccpucccgugacugcgcgccccgcccggaguccccgccgccguc\n", + "guuuggcugapagcgagcggcgcuuupapucgcguaggcgccucaccugacccugcggccgugcgguugcugcuccpcaggucuccuuccaggccapcccggaauc\n", + "cccuugagcaguccacgccuuguggcggcuuugcggagcugcugcuuuggcpaguuggaagcuggugugag\n", + "gcaguccacgccuuguggcggcuuugcggagcugcugcuuuggcpaguuggaagcuggugugaggugagaggcgcgguggucgcuccccggcgaggccag\n", + "ugagcaguccacgccuuguggcggcuuugcggagcugcugcuuuggcpaguuggaagcuggugugaggugagaggcgcgguggucgcuccccggcgaggccag\n", + "aguccacgccuuguggcggcuuugcggagcugcugcuuuggcpaguuggaagcuggugugaggugagaggcgcgguggucgcuccccggcgaggccag\n", + "aacauaaguuccaggaaagcaggaaccuugucucucuuguucacupuguauccucugcauauagaacagugccuggcacauaauaggugcuga\n", + "gcggaugcggaugcggaugcgaagguggcggccgagguggcggccgagguggcggcugcggcggccgccgcggaugcagaugcggaugagacccucggugacugugapaacccagauuuucag\n", + "aapcggcgcggagcucugupcpuggcuguuguupccgucgaggcggcggcgacucugcguccccggcuccug\n", + "ucucccaaagucuagccpcapaacgcggugcauuccugaccggcaccuggcgaggcucaugcgucccgugapcgguuccucgagccupcgcucag\n", + "agucaagcgucagccucacuguuccuccugucguaaagcuggagaacggcagcucgaccaacgucagccucacccugcg\n", + "guuguggugccuccuggagugacaaacuccucuuuucaagugacaucucaaaauguuggacaacuuacuguuuaucuacauggaaaucacuccaaucagaccgg\n", + "cccgaggauacgcuuucuugugauccgcagcagcgccauuagcaucauaaaccaggugauuggcuggaucuacuuuguggccugguccaucuccuucuacccucaggugauc\n", + "gcauuccugaccggcaccuggcgaggcucaugcgucccgugapcgguuccucgagccupcgcucag\n", + "cccaaagucuagccpcapaacgcggugcauuccugaccggcaccuggcgaggcucaugcgucccgugapcgguuccucgagccupcgcucag\n", + "uucugagaaaucgagaaacaugauaaggaauuggcugacuauuuuuauccuuuuuccccugaagcucguagagaaaugug\n", + "auuccugaccggcaccuggcgaggcucaugcgucccgugapcgguuccucgagccupcgcucag\n", + "gugcauuccugaccggcaccuggcgaggcucaugcgucccgugapcgguuccucgagccupcgcucag\n", + "agccpcapaacgcggugcauuccugaccggcaccuggcgaggcucaugcgucccgugapcgguuccucgagccupcgcucag\n", + "gccaccauuaaaugcaacccuggugaucacuuuugaaaucacauuucguuccaaaaauauuacuauccuugagcuccccgaugaa\n", + "cccgaggauacgcuuucuugugauccgcagcagcgccauuagcaucauaaaccaggugauuggcuggaucuacuuuguggccugguccaucuccuucuacccucag\n", + "ugucauuggucugagcuucgacuucguggcucugaaccugacpcuucguggccuacaguguauucaacaucggccuccucupugcccuacaucaag\n", + "gagcaguuucuccucaaauaccccaacggagugaaccccgugaacagcaacgacgucuucuucagccugcacgcgguuguccucacgcugaucaucaucgugcagugcugccuguaugag\n", + "cgcgguggccagcgcguguccuggccugccaucggcuuccuggugcucgcguggcucuucgcauuugucacc\n", + "aaauuuaaaucccugguaaucuguagaaccuucuccuaggaaauggugaagucuauuaggagccacuugugacuccaugaccuguuaaaaccagca\n", + "cggcggcggcggcggucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcg\n", + "gagcggcggcggcggcggcggcggcggucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcg\n", + "uugcuuccgcggcpccggaaguaggagcggcggcggcggcggcggcggcggucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcg\n", + "ggcggcggcggcggucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcg\n", + "cggcggcggucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcg\n", + "gccggaaguaggagcggcggcggcggcggcggcggcggucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcg\n", + "ucgaaagcggagugaaagapaggcapagccggagagccggaaccggagucgcagcggcgguaaua\n", + "gcacuuucucggcgcucccucccucucggcucgcacagcucgacuccgcgcucuccucgccggccgccgccgcccagccugcgcccgccguccccccagugccupcaccuguuggaggcagag\n", + "cucgacuccgcgcucuccucgccggccgccgccgcccagccugcgcccgccguccccccagugccupcaccuguuggaggcagag\n", + "guupaacacccggcgauucuggcggcugcuuccugguggcgcapagcccgcguguuugcgagugcgugugugugcgaaguucuccgg\n", + "cccuccuupccaccacgccugaggauggugcggagguggacagcuaugacucggaugaugcca\n", + "ccgcccuaggcacgcuggaguuugaccuucucuacgaccpccuccugcacucugcacuguagcauccucapccaag\n", + "cuccgcgcucuccucgccggccgccgccgcccagccugcgcccgccguccccccagugccupcaccuguuggaggcagaggcag\n", + "gaapaggccagugapccccacagaccgaggaggccgucgccuggcccucagccaggauggcuagguaugaupcucacuggcucacacgcccucuccuagccapugcugc\n", + "aacgaaggugcgugcucagcggacucugcagacccagugccgcgacuuccccuaaagccaggcguguaucugcgcgugugaggugcucugccgcaacccuaugcagagagcag\n", + "agcucgacuccgcgcucuccucgccggccgccgccgcccagccugcgcccgccguccccccagugccupcaccuguuggaggcagag\n", + "gaapaggccagugapccccacagaccgaggaggccgucgccuggcccucagccaggauggcuag\n", + "uccugacggcgcuggagcugapcagugcpaugccccaggaaggcuccuaggaagapacccacggugacuuccuaaggaagcgcgguucccag\n", + "cucgacuccgcgcucuccucgccggccgccgccgcccagccugcgcccgccguccccccagugccupcaccuguuggaggcagaggcag\n", + "cuuuuucuggugugcagauagapupacuggcauugcuupacagucccuaaccupacag\n", + "ggcacccgguggagaggaugagugaaacagccugupcggcagaaccuggaagaacagagaacg\n", + "ugaugcagccaacacgaacgguugucauguguaacacaacuuucgaucaccgcgaaaacaccguccupaaagcguccaugcuugauaucguuugguucaugaacauuaaguuuccaguacag\n", + "guucuccgcuuucccggcuccgucgcugacgcgucguagacguupagcpaaggcaacggcagcpaucp\n", + "acggccucgccucgguaucgcagcpuccucucuaucuagcuccagccucucgccugcgccccacuccccgcgucccgcguccuagccgacc\n", + "cucgguaucgcagcpuccucucuaucuagcuccagccucucgccugcgccccacuccccgcgucccgcguccuagccgacc\n", + "cpuccucucuaucuagcuccagccucucgccugcgccccacuccccgcgucccgcguccuagccgacc\n", + "gcacuucgcucuccugccagcaugugaaggugccuugcuuccccuucgccuuccaccacgauuguaaguuuccugaggccuccccagccauguggaacc\n", + "gucacuguuuucuucuucuguucucuuuggacacacgcagcugaacuucauccuaacupacacuguuguacaguggaggcggugauggcagcacgcgg\n", + "gauagugagugaguucucacgaguuuugaugguuguauaapacccuucccccuucacucugcacuucgcucuccugccagcaugugaaggugccuugcuuccccuucgccuuccaccacgauu\n", + "agagcucagcapcccuggagagauggccacggucccagcaccpaggacuggagagcgcgcgcugccaccgccccaugucucagccag\n", + "ggcccuggagagauggccacggucccagcaccpaggacuggagagcgcgcgcugccaccgccccaugucucagccag\n", + "cagagcucagcapcccuggagagauggccacggucccagcaccpaggacuggagagcgcgcgcugccaccgccccaugucucagccag\n", + "apcccuggagagauggccacggucccagcaccpaggacuggagagcgcgcgcugccaccgccccaugucucagccag\n", + "pcccuggagagauggccacggucccagcaccpaggacuggagagcgcgcgcugccaccgccccaugucucagccag\n", + "acuucgcucuccugccagcaugugaaggugccuugcuuccccuucgccuuccaccacgauuguaaguuuccugaggccuccccagccauguggaacc\n", + "gccagagcucagcapcccuggagagauggccacggucccagcaccpaggacuggagagcgcgcgcugccaccgccccaugucucagccag\n", + "cuugcggcagccgcccccuucugcgcggucacgccgagccagcgccupccuggaaccpccguagcccccccaguuucgcccaccaccucccuacc\n", + "cgcggucacgccgagccagcgccupccuggaaccpccguagcccccccaguuucgcccaccaccucccuacc\n", + "gcagcuccggugcaagcgaggacacgacacaugcaguggcuucuggacugcgcgaugacuggacg\n", + "acacpaucgacccgcccgccgcuuccapcggaggugacagcpcupacuggcggcugcaacugccugccgcgccgapaccgccpcggcggaaagcag\n", + "cpcpcucuggaapcpcgagacuguggaggaccuggagcuggcpucapuappapcapcucpuucpcpuguucacggugagaccaaaagucag\n", + "gcuccugguugucuacccauggacccagagguucuuugacagcuuuggcaaccuguccucugccucugccauc\n", + "gaaacaauucuggugaaaugugaucguccuggccacccucugauugauaagacauaucauuuugaaag\n", + "auauacuggccuucccagcugacauggaccucaggucagcuucagcgugagaagcaggccaggccupucuggagccguccuggccuucccag\n", + "auucaugauggcuugcagaugcuugauuuccugaapagaaccugaugagcuugucuucuagaucagugguccccaaccuuuuuggcaucapaccagcuuccuggaagaccag\n", + "cuccaucucuagagaagcggcccaugcuguugaugaccugagucuacaaguuuccucacaaauuguauucagagagcagcuuccugcuug\n", + "aucugcgagugaagapacgapaaaagaaacaaagccacagacgcaacuugagacucccgcaucccaaaagaagcaccagaucagcaaaaaaagaag\n", + "uuuucugaaauucucgucucaggaaaccaccgacacucuuagcaaggaagcugaaccuccupuuuugccaacacauuuuuccauaguuugguaaagaaagaaaccucaaaa\n", + "uucuacaugugguuuuacuucuuuauaaagucaaguaagapuacuuuaggacugagguuuccauccaaguacuccgguuuucucuccagauaugaa\n", + "cucuuccccagcagcugcugcucgcucagcucacaagccaaggccapacapcggcagcgacuccucuggcucccgagaaguggauccggucgcggccacuacg\n", + "aaaaaaccggaaaupuccuaccaucuucucggagccggagugcgaagaaauaaagaaauagugcuuuaaguca\n", + "auaagucccgcgcgucuugugcugcgcgugcgcaagcuuuupcccucccgagaaapaagugcauucucgcuuccguagcggucuccgccgguuppaaguaauuccgguuguugcacc\n", + "gcuggucucaaauucccpcucaagcgaucuucuggccucagccuccugaguagcugagauuacag\n", + "auaaauagacgcaguucagcuccaggccgguuggagagcgcaucccagaccgagaaggucggaggcagaagccpaaggag\n", + "acuucugaacaaacugugaauauauuacugagaagaaacapcagccuguguaaauaggucucaauuugauacuggcuacuggaagagcuugcucagaggcugauugaaauauucuccaguagau\n", + "gacccgucccggupapaccupcuppacgguapaacaapcgupacupaagcuucupaacauuugcucuag\n", + "gaagacugcgcguuugagugucccuggcaacgccacgcuuccgccuucuggaagccugcacuccagcuucgagu\n", + "auuugcucuagguauucagcuaaacuaagaaaaauugguccaaggcucggcacaaaaggaucuucucauuccaguccuuucgcccacgcapaacg\n", + "aggagaupuuggcugcaguagugagaggcupugcggcucuuucccugcaguccugccgaggaagcgugcgucccuggcgcuuccuucuucucuuccggcggagag\n", + "ggagaupuuggcugcaguagugagaggcupugcggcucuuucccugcaguccugccgaggaagcgugcgucccuggcgcuuccuucuucucuuccggcggagag\n", + "gcacupcguccccacgccaccgcccaucagcugagaauugcagcugapcuccpuaggupugacggcggucggagguguaggapagccguggagguccag\n", + "upcuccguggcuuaagacuugaaccaaguaaacgaaguucucuuacugagaagucucaguuucaa\n", + "cugucauucuucucuacagaagagcuucuccucaucaacupaugauuacaguucuuccuaaaaaag\n", + "ucuccugccugagccaaacccagucuugucaauagcpuuucacccuccaccaguucagucuguugccugugucagac\n", + "caaacccagucuugucaauagcpuuucacccuccaccaguucagucuguugccugugucagac\n", + "aggaccgcpcauuuacccgugcuuucccaagccuggaagaacucgucaugcucuuuguagcguggugcuucuguugcucacag\n", + "acccgugcuuucccaagccuggaagaacucgucaugcucuuuguagcguggugcuucuguugcucacag\n", + "aggugccugcuuccccuucugccaugauuggaaguuuccugaggccuccccagccauguggaacu\n", + "gauguuugccacacgagucacucgagagaaucucugaguccuggcgapcuuucugaggcuucguguguuagcagcuguugucuuccaacucagcggcag\n", + "pcauuuacccgugcuuucccaagccuggaagaacucgucaugcucuuuguagcguggugcuucuguugcucacag\n", + "guugacuuggaucagcugaugguucuuuugucccauggauguucugcugguacugcagucaucugguagcccacuuaaacuagaauguccaugacagcucauucacauggcuagugccuug\n", + "gcuggcgcgcaggaccgcpcauuuacccgugcuuucccaagccuggaagaacucgucaugcucuuuguagcguggugcuucuguugcucacag\n", + "uugugccuguguacgcaguuccuguagcacucggcupcagaaaucaucuuucagcacuaapaacauaguuaugaucuggaccuucupaguggucagugcccaagaacag\n", + "agccucgcccugucaccaggcuggaguacaguggcgcgaucucggcucacugcaacuuccaccugcupuucaagcaauucuucugaccucag\n", + "gugacagcccucacuggcugaugaauggugagcuucucugaagccugcuuuguaaagauuguggcuuccgccugaacugcuucuuuccugccucaaag\n", + "auucugccugcacugcuuugcggupcaggaagaugguuucugcgcagugcuupcagcupugcuggagcuugcacapuuucuuugauacca\n", + "cggccgcgcggaggaagcgaaggaggcpagcggagaccucgcugcgcucauggcgucgcccgg\n", + "gcauucagauuupagaaguagccccagaaauaaaagcaucagagagacgaacagcuguggccauugcag\n", + "cccuuguuuccugcagguaggagugcpaggupcauccpucucuugguggcugcuucuacccccggagcucagcugaucuucccuuccagacuacgag\n", + "gcugccgcugagcgcaupcccggaccgcgccgcgccgcuccpagccpcccpucccgccaccaccgcgcgcgg\n", + "gacagauugauucacuuuggagcuguaaguacugauguauuapugcagcgcucauuguuccuugacgcagagucccaaa\n", + "cgucuggcaagcgguucagcugucugcucccuagcagccggccuucpucpcgucuccgccggcuacugccgcuucaguucucccgguguggccacgagucgg\n", + "uagccauccuaauggauaupuugguuccuguuuucuauuuggaacuuuaaaaaaaauuaaagcag\n", + "caguagccauccuaauggauaupuugguuccuguuuucuauuuggaacuuuaaaaaaaauuaaagcag\n", + "gucacupuuucggcgucuggcaagcgguucagcugucugcucccuagcagccggccuucpucpcgucuccgccggcuacugccgcuucaguucucccgguguggccacgagucgg\n", + "cagaagcgguguauugcgccucagcauggaggaggacgugaaggcguacggagucupaguaguacaccacguag\n", + "auuuuggauauaaguaaugugcagguuucuuacaupuacauuggaugacacugagguuupuacuguugaucccaucaugcag\n", + "pcgucacupuuucggcgucuggcaagcgguucagcugucugcucccuagcagccggccuucpucpcgucuccgccggcuacugccgcuucaguucucccgguguggccacgagucgg\n", + "ggccuccuucgcacuuucgagugcgcguuugcugcccgccgcagcccpcguugaagguaguaaagcggccacccggccgcauc\n", + "cacuuucgagugcgcguuugcugcccgccgcagcccpcguugaagguaguaaagcggccacccggccgcauc\n", + "auaagguuugaaaaccuaacaucuguuacauggcuauccacaaacugcccagguaacugccauagcupcauacaacaucuuccggcauaccuacagaaacucacggauacaauuaac\n", + "ggagcpagccuggcugcgcuaccgcggcugccuccugcugugcagguccccgacccucucucuguccucauugcgcccagacpccggcccagagcucccpucgucuuucguguggccgcgag\n", + "gcggcugccuccugcugugcagguccccgacccucucucuguccucauugcgcccagacpccggcccagagcucccpucgucuuucguguggccgcgag\n", + "acacucuugcacuccuguaaugagccuggcacugugaugaaacacuuuucccgugucguuugagugcaucuucucaacaacccuaggag\n", + "aguugagucaguggcuugaaacuuuuaaaagcucugugcuccaaguuacaaaaaagcuuuuacgag\n", + "accgcagcggacagcgccaagugaagccucgcuuccccuccgcggcgaccapcccgagccgagaguagcaguuguagcuacccgcccag\n", + "gcggccaccgcagcggacagcgccaagugaagccucgcuuccccuccgcggcgaccapcccgagccgagaguagcaguuguagcuacccgcccag\n", + "acaagcggccaccgcagcggacagcgccaagugaagccucgcuuccccuccgcggcgaccapcccgagccgagaguagcaguuguagcuacccgcccag\n", + "gauuccgagccuacgacgccuccgcuagagcccgcpcugcgccgacuccugcucuggapuugcpuaccugauggccacagapcucuaggaggccgagcguguaagcpupcgcc\n", + "guucucaucccuucccaguccucucuccggccaugucaacagugagaggupucguuuccauccccuuuppcugcggauucaccccugupaaauggcaccucauc\n", + "acuuucccggugcacuuuuucuggupapagagcggagcaggcucacguguaaccgcgcaggagccuccucuggcuugagcccuuucuug\n", + "acauuuaaaagagcuucpcacccggccucccupucccgcuccugcggcgcpupagguguaacuugacag\n", + "gcuupccupcagccacacugcacgcaggcupccgacugapcucagaggccaggcucugaggcccacgcapccuapupaag\n", + "agacgcuguggucucaccuguccuggcaapccucugccggcuguucccaugacuggcucapucugaguucuuauuccaucaaccuugaucaaaagaaggaaapaagaaaaaggcccagg\n", + "gaggcugaaugaauguauuucaccaguagcaaaugagaugaaccaucuuccugcacacagccacgauuugcaaag\n", + "guuuuuggagaggaauaaauuuaaugaaagauguacaugacuucuaaaaacuauaagcagugcupuaaaauuaaacac\n", + "cacugcacgcaggcupccgacugapcucagaggccaggcucugaggcccacgcapccuapupaag\n", + "cagguucccggugcuucgcgcgucugccguugucacaggccapagguggcaccaccaggcgaagcuuggcgagauugugucgucaagcgcguacpcgccaauuggccpcg\n", + "ugcaagapugacagcaacacacucaaggcgcuucuccupaauggagcaggagaagagaupagcaucgcauag\n", + "acucggcgguggcguccguguuguuauuguggugguagcggcgucuggcugcugcggaccccgccgaguccuagcgccuggccugcgcgccgcugcccgcgccacag\n", + "gauuaauuuauuuuuggaaaucaagugcaauauuggaagccauuucuacuaauuuuauuucacuuuuaaauuuaugauuugauuugaauacuauc\n", + "agaupcgucucccggccuuguugacuuuggcguccgcpagcugccccugugcccgugguucucugcgc\n", + "gcuuguccccgcgcucgcgcucuccggccgcpcaucucccggcccggccgcagcagccgccgccgccgcgca\n", + "uuucccugaaaccupcucuugaagacgcaucacuggagcagauggauaauggagacupcuauaug\n", + "agaupucuugccauguugcccaggcuggucuugaacuccugagcucaggcaaucugccugccccggccucccaaagugcuaggauuacag\n", + "agaggcugcggccuacagccpagaggccagcccggccuacagugcggacacaggacagapagccag\n", + "guucuuugcacugaccaaugcugagagcagacccucggagcagccpuuggaagugucucuccauagucaccagacagauccaggauagg\n", + "ggacacagcagucucugaauuucaugcucuccucuuugaugugaagaaaaugaaaagcugaacaguuguggaacuguggauagaguuagacaauaagg\n", + "cuugcuagucupacuucccgguggagugaggaacccagcaacacgcuccugacuucccuucccaaggacucgaccugagaa\n", + "gcuagucupacuucccgguggagugaggaacccagcaacacgcuccugacuucccuucccaaggacucgaccugagaa\n", + "guguuuuccucugcuggcacgccagaaucccugguucagccuggaaggcgapcaggacuccccagacaguggccucagugug\n", + "paaugccagcuguucucuuaacagaapcaguuuuugaagaaaugaagcaggacuugauguggauugucauaaacuguuucucccuaaagag\n", + "gcugguccccacagacggcuugccauuucuaugacuggaugcugagaagccugcugguucagagguccacacaugaaguuaccauaaag\n", + "uguaaaagacaacuguacuuaupaagucuagaaacccuugagauuugugaccuguagaggccaaagagguuucagaagacuacaucaagccaucaaacaguaaagag\n", + "agguucucagccuguucuccgguupccacuugcacucccacugccgcccuccuggccugucuggaccpccccccgcugcccc\n", + "acauuuaagaaauacauugguucaguccagaaaggcaggacaacccgacgcgaggcapagcuuccagguuauag\n", + "agucugcggccacupcagaacggcaapagapaapcggapacgcagccupcgauuugccpcggagacgcucuuuuucagacacccuccucag\n", + "pcugcuccacgcuuuugccggaggacagagacugacauggaacapaapccuggcuguccucauccuggcuaucauucuucuucaag\n", + "guguaugacuaucaagaagaugguucgguacuucugacuugugaugcagaagccaaaaauaucacaugguuuaaagaupaag\n", + "agucuagcugcugcacaggcuggcuggcuggcuggcugcuaapcugcuccacgcuuuugccggaggacagagacugac\n", + "gugcaaaugaaugccuuccacugaaccgagguagacpucgaguuucuugcgcgauggupcuu\n", + "augcgcacagcguugugcaaaugaaugccuuccacugaaccgagguagacpucgaguuucuugcgcgaug\n", + "ugcugguaauccgaauguggugguaacaguaagauuucpaaaaagcacacaaacgupaaaaggccucuuucugaaugccaagaaggaaaaguuauauauacag\n", + "cucauuuuucuuacuaacaggucugaaaauugaacaagauggacpuccaggaaagaggaggaggaagacagcacauucaccaacauuucucuugcagaugacauag\n", + "augaagucacacuguugcuaaaccaugcauagguuuucuauuguuugaauuauauguggucagaauuucagaaacuggcuucuuuuucuuuaccucuuauauug\n", + "aguugguccaagugucccggccugaggugucggccggaucccuccuucucccggcgccucaagcggaag\n", + "auuuaaaauuauagagcuuuucaucacuacggagaugcucuugccuaugauaggaacgauggcuacaucugaagcugagcaaauuuaucuuuucucuucgucugcaucapugaccucuggaag\n", + "uguuauggcaaagguggaucccggugcuuugagauuggacgacupugaggcpcagcuaaugcgcag\n", + "gucaguugguccaagugucccggccugaggugucggccggaucccuccuucucccggcgccucaagcggaag\n", + "aguagucgcugcugcgcggccgccggcpacuggucugaagagacgcpaccaaguggcaacgacuuggacaucugagcugucacugccgaaaacaggccgcaagagag\n", + "gaagagacgcpaccaaguggcaacgacuuggacaucugagcugucacugccgaaaacaggccgcaagagag\n", + "caucugcccaagcaacaaagaggagguguuugcuupaguuaaaagcaaauggcaaccaaagcucaggacupagagaaaag\n", + "cgcacgcgcgguuaguagucgcugcugcgcggccgccggcpacuggucugaagagacgcpaccaaguggcaacgacuuggacaucugagcugucacugccgaaaacaggccgcaagagag\n", + "cpugcugccagccpugcugaugcgagucgguggcagcgaggacauuuucugacucccuggccccugacacggcugcacuuuccaucccgucgcpccggccgcuacuccggccccagg\n", + "ggcuacapaagaauugaaagugaaggcauaccuaccaacaggcaaacaauuuuugguaaccaaaaaug\n", + "gucuccucaguugcgaaauuaggauguuaauuauagcuuuugacauacaagaaacaucaaaaagauugaaugucuuaauaagagugaagcauguagaucagugacugcu\n", + "agaugcaucauaagccaaauugugagccaugauaguggcacugaauuucuaaauacaagaaauugcuuagacaauugguuuaguaucuguauaupcaauacucuguccugcaguag\n", + "acagaugcaucauaagccaaauugugagccaugauaguggcacugaauuucuaaauacaagaaauugcuuagacaauugguuuaguaucuguauaupcaauacucuguccugcaguag\n", + "cugaaucgcugagaaaagagaccauguuucuacuuuuagaaggagaaugaaaucaacgcaaaggagagagaaacaag\n", + "aucauaagccaaauugugagccaugauaguggcacugaauuucuaaauacaagaaauugcuuagacaauugguuuaguaucuguauaupcaauacucuguccugcaguag\n", + "auucucucggcggcaucupuuccaggcpcagcagcugcaggcugaccuugcagcuuggcgga\n", + "uucugcaaaupagguacuggaaagaacgugapcaggaggagagauaugccapuauuuauugcccuagcucccccucugccagaccacag\n", + "pcacagcagccaggcugccggagagcugaucucpauucpugcggagcccuuggccuggaggcgauaupugguccguggcccgguucagucgcuugcagcagcccpaacag\n", + "gccggagagcugaucucpauucpugcggagcccuuggccuggaggcgauaupugguccguggcccgguucagucgcuugcagcagcccpaacag\n", + "pauucpugcggagcccuuggccuggaggcgauaupugguccguggcccgguucagucgcuugcagcagcccpaacag\n", + "gccugucuggcccugapaguccccuuucugaagcuguggugcuuggacgaccugcucucuacauugcupcaccu\n", + "gaucucpauucpugcggagcccuuggccuggaggcgauaupugguccguggcccgguucagucgcuugcagcagcccpaacag\n", + "cacagcagccaggcugccggagagcugaucucpauucpugcggagcccuuggccuggaggcgauaupugguccguggcccgguucagucgcuugcagcagcccpaacag\n", + "gcpcacagcagccaggcugccggagagcugaucucpauucpugcggagcccuuggccuggaggcgauaupugguccguggcccgguucagucgcuugcagcagcccpaacag\n", + "cccggccucagccuggagcuccagcuacccacaugcaccuuaccupuuccgcccggucccugaguccccacaaa\n", + "gagcuggccgagcugagcgccgagcuggacaaggaccugcpcaauugagacccgacugccgucccccaag\n", + "cuuccuccucgagcgcccgcgccaggcagcagccpcapaugcuccugcgcucccpcggccucpcccagccaccugcucgccpaag\n", + "cacuugcugaaggaccaguuggcugcugaggcugcggcgcggcuggaggcccaggcucgcgugcaucagcuuuugcugcagaacaaggac\n", + "gaggccuapapcgcgguccapucccggugccuggcugcggaauuuapuagagucuguucggcagccuuuaaucggagacgucacguggccgcuuuuua\n", + "gcgacucgaggagapaccccgcuggccggapagapagagacuucgcupcagaupacaccgugugcapccgucaug\n", + "ugccggugguggugugcacauugagccccgguauagacaguucccccagcugaccagaucccagguguuccagagcgaguucuucagcggacuc\n", + "gauaaaguuccucauuccugucuuuuagugagcaguaugguuuagguggacagagauuccuuuggugcaguuuuuuucaaggag\n", + "cuagauccugaaugaauaauauaauugguauaugaggacauuacggaaacaguaugcuacgucauucaaguuguaaaguggcgauauuug\n", + "aggcggaggaagcagcgugcgcggcpuguggacgcuccuggagcgaggcppcggcggcg\n", + "gcpcggagcgccpaagcgaaguaggcapcgaggcggcupaccgcpcggacpagcgagu\n", + "cucgaggagapaccccgcuggccggapagapagagacuucgcupcagaupacaccgugugcapccgucaug\n", + "guagucgccgcgucgccggugcggccgccauuguccggcguucggcgagucpuggucccuuuggcuggagugccucucuggucupaucaccucaggcgcuguccuucacupcgauccagc\n", + "ccpcaguggcugcugccuccagcucuaaauaguuupuuggcccgguucccagacugcacuggaacacupcuuuaugcccccacauucagugcauuug\n", + "uucccggcgugcaccpcaguggcugcugccuccagcucuaaauaguuupuuggcccgguucccagacugcacuggaacacupcuuuaugcccccacauucagugcauuug\n", + "cpcaguggcugcugccuccagcucuaaauaguuupuuggcccgguucccagacugcacuggaacacupcuuuaugcccccacauucagugcauuug\n", + "ccggccgcgacuccpcuuggccccggcccuagcucgucggcuguguauupcgcguggaggcugcagucacgguggcgcccgcpacggaggapa\n", + "cugccuccagcucuaaauaguuupuuggcccgguucccagacugcacuggaacacupcuuuaugcccccacauucagugcauuug\n", + "agcgugccccgcggcpcccuaccggccgcgacuccpcuuggccccggcccuagcucgucggcuguguauupcgcguggaggcugcagucacgguggcgcccgcpacggaggapa\n", + "gcgugcaccpcaguggcugcugccuccagcucuaaauaguuupuuggcccgguucccagacugcacuggaacacupcuuuaugcccccacauucagugcauuug\n", + "gucapccccagcaagaaggcagccaagcacaaggcagcugagguggcccucaaacaccucaaappagc\n", + "ggaggcugcagucacgguggcgcccgcpacggaggapaaugagugaagaggagcaaggcuccggcacuaccacpcugcpcugccuag\n", + "gcpucuggaagcagagccggcggapagcgccpcccupcugcaggagguugcggcggccgcggcagc\n", + "cucgccccgccccaggcuaggcuggaaaguggaggauccgguuugcucupcpucuggaagcagagccggcggapagcgccpcccupcugcaggagguugcggcggccgcggcagc\n", + "aaaguggaggauccgguuugcucupcpucuggaagcagagccggcggapagcgccpcccupcugcaggagguugcggcggccgcggcagc\n", + "acuguacacaugcuapuccaggacagcaggaccaagccagcagaaacagccugagcccaccgcagacu\n", + "ccacccaggaagcuggcaaacaaaauuuaacaggcagcauccaccgcaggcuuacuguacacaugcuapuccaggacagcaggaccaagccagcagaaacagccugagcccaccgcagacu\n", + "cccucucuuucugccucaccuccugcuguaaccagaaucccacugcuugccuuaggucupaagaaaggcguaagg\n", + "aaaaaaaaaaaaaaauggcccuucgcuauugaggaaauggaggcauuccauggcugaauaacaggaucag\n", + "ucagcaccacaagcucpcugaggapaggacuccuggccguccuccuccucuucaaauuggcuugaaucugcucugaccccccacgagugcagcaca\n", + "gcuauuuucucugucgucagcccucucuuucugccucaccuccugcuguaaccagaaucccacugcuugccuuaggucupaagaaaggcguaagg\n", + "aacaaupacuuccacagcaaupaucugcuuccucuuucagugugugccuuuucuaugagcgagagacuccuaggaaagcagcagcccauuaggaaaacgugupaacucacucgcag\n", + "acuccggacuuuggccuuagcaguaguuagugupaggcupaagacupagcagucucuuaaacaaaagcaaaagaauaagcuucpcgcuguaguaccugccagcuuucgccacaggag\n", + "caguaguuagugupaggcupaagacupagcagucucuuaaacaaaagcaaaagaauaagcuucpcgcuguaguaccugccagcuuucgccacaggag\n", + "ggauuagcacucacagauugaaagcaaaacacaucaaaacacucaucacgcacucupcuuguggugccacuuguauguguguuucuaaauca\n", + "ggagccucgguuccccucpcggcugaaggapcugagccucaggaccccuaggccaggccguguugaaagcagauaccccgaggccucgcccagccugcgcuggapaagaaggcgcuggag\n", + "gagcaccagcgaaagcagccagucugagauauugacacuacagaaaaaacugacagcuuacuccuuguauugauucuacucuucucuacaaauauagacuccguucccuaccacagccuu\n", + "aguccacccuggcpucgcapuupauggcggcuggaggcgaucaugguucgcccgacagcuaccgcucaccucuugccucccgcuaugccagcccggagaugugcuucguguuuagcgacag\n", + "cuugccagagugaucucucggcuugccgacuuugcuaaggaacgagccagucuacccacauuagguuucacacauuucca\n", + "gaaggaagucccgccccgccccguccugcccuggccuccagguuuccgcuuccgcucuucccugguccaguccacccuggcpucgcapuup\n", + "acaaaacaaauuuagaaacuguauguauagcuucauguuuuucauaaaauaggaaugaggacaaauguugcucuucauccuaccagcuguuuguucuuugguapauc\n", + "aacagaagaaucagaagcuuuucaaaauuccgucuucaagaagaaacacccguggaggaagaagacauuauacaaaacaaauuuagaaacu\n", + "paucaugaguggaaaaacaaaggcaagaapcugccauguuuuuuagacguugcucugaagacgccagcgguagcgccaguggcaaugcuuuguuaucagaggacgaaaauccugaugcgaaugg\n", + "puuugguuggcugcagccagccagccguguaaaaacuccaacgccpcgccgcpcagcacccacggagacccgcpagcug\n", + "cugcagcuccuggcaacuggucaagcaggcagcguccagcgcacccgcgaacaccagguccggcagcaucugucuuuucccgcagcgugcagcgccugacc\n", + "gauguugugguuccgcggcgcgcupaguuupuuugguuggcugcagccagccagccguguaaaaacuccaacgccpcgccgcpcagcacccacggagacccgcpagcug\n", + "auuuguugaagcacuuugccccuggaaccaggaaaggcucuccaguggccuacucccugccagacugguauauccaccacagcaagccaccgacagccagccagcaaga\n", + "aucagacaacacauuggcagugaguucaucugcucuacucugcuuuggaauaacacaugugauuaaccag\n", + "guggugaaaugacagaacucauucgcuucuuugauuggugauuuugaaauaaucuuucaucaaguuccaucuccuuuacccucauauggaauauaucucucugucuguuguuaaacuacgaugac\n", + "aaauugaagccaaggaagcuugugauuggcuacpcaacugguuucccccaguaugcacagcuuuaugaag\n", + "auuuccuguuccccaucgauauuuccuuggucaagagagagcaugauuuuuuggacagagaugccauugaggcucuaugcag\n", + "acugacuucgugcccuccauguuccuugacagccupccucuccuacuggauuaauaccugaugaguaccugaucacgcaacagugaaacaacacaag\n", + "ccccgcugcaaguucuuagauuccuggaggaucugcagagucaacauuaggaguauccauccauucaccaaggccaucaggaaugugcug\n", + "aguugcuguaugagccuggccuggugcaaacacauugcuagagacauguuaaagaguuccaggugaaucaagccugapagacaacagcaaaacg\n", + "uucapcuguugcuccugacagauaagucagucuaccuguuguugaaugacaugcagaaaagaaauuugguaagaagaaagugauuuga\n", + "gcuguggaagugauucugauucucugccapuugugacgcugcagcuuuccaugaaguacuucacaaguag\n", + "gguggcgguucggagugapuagcacgcugagcugaaggcugugcggagcggcgcggcacagagccuguuguugagcucagu\n", + "ggccgagupaccaggugacgguuuaucuguucugugacgaccauaaguugcagcgguacgcgcuuaaccgcaucacgguguggaggagcag\n", + "gucaggcaacgaacucccucuggcaguggcuucuacugcugaccugauacgcuguaagcucuuggauguaacugguggcuupcacugaugaacuuagacugcucuauggc\n", + "ggagugapuagcacgcugagcugaaggcugugcggagcggcgcggcacagagccuguuguugagcucagu\n", + "gapuagcacgcugagcugaaggcugugcggagcggcgcggcacagagccuguuguugagcucagu\n", + "agcaucuugccuggaugagccapacacagaagagaagcccacuaucucauuuaaucuuuacaacucucuugcaag\n", + "augguuuucaauaauuguccugaacucugcuacagacuaauaaaacuucggucaaguugcgagcaaaapauuauuug\n", + "uguguupaacugaaggaguuucugupcggacapaacccugcguuucuacugugugauucugccaccuuccuggcccgacgcc\n", + "auccucgccccaaupauccggcagcagcugcgcuugcccacgaggacugcccagccauugaccagccugcc\n", + "cuagucucccagcuccagcucggccuuupuuugcugugguguccuugucuccugcaggaccggccgcagc\n", + "agacpugucgccguguugcccaggcaggucuugaacucuuggcuucuggcuucaagugaucuuccagccucggccucccaaagugcupauuacagucagccacugcaccggaa\n", + "ggagcpucgaauaugguaaaagagagcccgagcuucgcgccupucuggaagaggucuugcgaaagccgccucgagcgcgcuccgcggcugcuggucccagu\n", + "cagauccugccucccacagucacccugcucccaagugcaaccucugucugacccugcauggugugcggugcccuccugccucaggcc\n", + "gucagaguuaccggucagccpcpcgccgccpucupuggacgccgcgagccugcacguugcgccpaccccpcugugcccag\n", + "aguuggacgccccgacccgugcgapccagguccgcgccugccccgccaggcgaagcgaggcgacccgcgugcggcc\n", + "gauuuggaaugcccugacagauaauuaupaaugugaugccuguagacuggaagucaucgcauacuaggaccuugcacuugcuuacucugaaccucucagaaaaap\n", + "guaagugacaguuugcucuuugauacaucagaugaugaagagcugagagaacagcuggauaugcacucaaucaucgucuccuguguuaaugaugaaccccucuucacggcagaccag\n", + "uaaaaauuuugauuauuuggagcauccacaccugaacaccauugguuaauggagaauucagugcauuucugcucupugccuuag\n", + "uuuuccuguuucuggcuucacgagcagccaupagacaacuacaaaugauuacagacuccagcagcaacaag\n", + "auuagagccugagucacucuccccaggagacccagaccuagaacuacccagagcaagaccacagcuggugaacaguccag\n", + "acucuccccaggagacccagaccuagaacuacccagagcaagaccacagcuggugaacaguccag\n", + "aacagaagguagagacauuuacccapcaaacuucuaccauucauugugacuuccugaaaucuuagugcaaguuucagcucuaaaagaagagupcuccugcaagauuag\n", + "guccaaccgugacugccagaucgaccagcaccaccggaaccagugccaguacugccgucucaagaagugcuuccpupc\n", + "gacgupcuucccuuuguaupccggaggcggaguccugucccgccccgcgccuggcggcagugucuuccgguucgcaagcccgcggcgag\n", + "gcccgcgcapugcuggccgcagcgcccccaagucccggcgccpcccgcucacggccgcgupagcagupuucgacggcgcggccgcgaggccgcc\n", + "ccccgcgcaggcaaaggcuuppccpcgcggcugugcagcucucgccggagccgagcccagccgagcguccgccgcugcccgugcgccucugcgccuccgcgcc\n", + "pcggcccccgcgcaggcaaaggcuuppccpcgcggcugugcagcucucgccggagccgagcccagccgagcguccgccgcugcccgugcgccucugcgccuccgcgcc\n", + "gcucacucugccccacagccacagccccugacugccgcagcccccacagagcccgccgcgcaccccacgucccccacgccagcgcccagcc\n", + "gugcagcucucgccggagccgagcccagccgagcguccgccgcugcccgugcgccucugcgccuccgcgcc\n", + "guaucgugcaggcuccgacuccpcuggcgccpucccpccgapaacccgcgaccggacuugupagaaugaggaugaaaacguggagcuuccauugucuagg\n", + "gugcaggcuccgacuccpcuggcgccpucccpccgapaacccgcgaccggacuugupagaaugaggaugaaaacguggagcuuccauugucuagg\n", + "acucugccccacagccacagccccugacugccgcagcccccacagagcccgccgcgcaccccacgucccccacgccagcgcccagcc\n", + "ggagaggcpcggcccccgcgcaggcaaaggcuuppccpcgcggcugugcagcucucgccggagccgagcccagccgagcguccgccgcugcccgugcgccucugcgccuccgcgcc\n", + "cucagcuuaaaauuaaggaauuagaccacaacaucagcaaacauaaacpaggcugaagauggugcugcaaag\n", + "gugguuauuggugguagaaauaaauauuuaaucaauggagucaaugccaacaacaccagaguacaggaucucuucuguucuguuggccuuaauguuaacaacccucacuuucucauc\n", + "guggugguauuucuguuucguacagaacugguuuguggccuguuugauuccugucagagguuugcugacccaagacaguaucgaaa\n", + "aagcgguggcuccacuggaggaaaacacaccccggucucacauuaaagaagccaaacugucggcuucaaagagaaaaggcaacauccugucacaggcc\n", + "ggaaacaauuccaagaaaaaggacauucuucacccagcagcuccugccauauucacugagauguguuuuuguauuuuccu\n", + "gaacccagugaaaugagcugcaccaggaacuuuaagagagaguuuucagcupagaagaggaaggcaagauaucagaacaa\n", + "cucccgugaggcagugcgaggcgcgcpcacggapcgguggcggcpcuccugcgagaagcaagcggaacuuccugag\n", + "gugaggcagugcgaggcgcgcpcacggapcgguggcggcpcuccugcgagaagcaagcggaacuuccugag\n", + "agcugacuguucggccgccaccgccgcugccgcugccgcugucgcugucgccgccgccgccgcccgccgccgccgccgccgccgccgccgcugcc\n", + "gugguggugguuuccgcacaagagaccaaauaagaagaaagcugagagappaaacguuuuuggaugacaaagg\n", + "cucauacagcacaggaggccuacuugcuucaagaacugaaaauccagaggaugaauugcuuuaucupaauggcaaaagccagcacaauaagga\n", + "guccagguccgcucgguaaccguuucccgcgcgcccggccccgacuccpuaaagagccccggagcggagcagcgcuggccgcgugccgccuccggagccggcagc\n", + "guaaccguuucccgcgcgcccggccccgacuccpuaaagagccccggagcggagcagcgcuggccgcgugccgccuccggagccggcagc\n", + "gagcucuuggaguccaggcugapucuugaagaaggaacuggaggacugugagguguuccgguccacggaaaagaaggagagcaaggagcugcug\n", + "agupcccucggcgcccagcuccgcguccugugagguccaguggccgcccaggcgcgaccagaucupugcgcggagagcgcgc\n", + "cuaggaucgcgacpaacuggagcccgagguccccgcgcggcccpccuggcgcccugapaagagcggcccggcccgag\n", + "gagucccugaccugcugcuaggaucgcgacpaacuggagcccgagguccccgcgcggcccpccuggcgcccugapaagagcggcccggcccgag\n", + "ugaccugcugcuaggaucgcgacpaacuggagcccgagguccccgcgcggcccpccuggcgcccugapaagagcggcccggcccgag\n", + "gucauuuccgccgagucccugaccugcugcuaggaucgcgacpaacuggagcccgagguccccgcgcggcccpccuggcgcccugapaagagcggcccggcccgag\n", + "aggaucgcgacpaacuggagcccgagguccccgcgcggcccpccuggcgcccugapaagagcggcccggcccgag\n", + "agcagaagcccaacagcagccuccuucaggcagucaggcacuagugcccaacuccagaaguccccuacaggcagagapuguggacaucucacaccccagcaccagaccacagaacc\n", + "gcuuguuuccuggcaacggcuaaacgcaapcpucgccgacggcuauccgapaggagcaccgccucuccucuugguuccgucccuuc\n", + "ccccaacccucccuuuccugaauucccccuccuccucgcucaccuuaaaaccaucgugcaucacc\n", + "agucugauuuacggcucugcugaaaaccgcuucgcucccgcagcaucagcaccggaggcggcggcugcagcagcagcagcaacaagucgg\n", + "aagagcaggcgacgccgccgccgccaccaccaccgccauagauacacucucauccuacpccacgccupccuugcugccaggaagcuucggccccgcagcucggcuugcugcggucucag\n", + "guuucuuuaccuccagaaagaagaauauuggccccuugaauucuggaaguucauugaagagucugaaauuapacuuauuucaaauuuggac\n", + "aggcgacgccgccgccgccaccaccaccgccauagauacacucucauccuacpccacgccupccuugcugccaggaagcuucggccccgcagcucggcuugcugcggucucag\n", + "uucugcguucgagucugcucuggcugugcuguguuggcuguguupacacuauguuccapauu\n", + "guugcugucuuccucgucccuccggcccuucuuccuacucagcgucucacuuuuggccuauuuucugcuggaucucuggcagccucgcuuucucccugacguuucag\n", + "uccgccugacgcgcccccggcggcggccgcgcagcccuggcuccucgcpcucpcggcggcugcggcpcu\n", + "cuuccgccugacgcgcccccggcggcggccgcgcagcccuggcuccucgcpcucpcggcggcugcggcpcu\n", + "agucacgugacgcucguccgcaaccucugcuguccuccgcggcgcccccuuccgccugacgcgcccccggcggcggccgcgcagcccuggcuccucgcpcucpcggcggcugcggcpcu\n", + "ggcaggaacaccuggcaguuugaaugugauuccuccgaugcucaccccccuggccuccacaucuagacaag\n", + "gcuccaaccaggaauggagacgccauuggauguuuuguccapcagcaucucuggugcaugcugaugacgaaaaac\n", + "ggucuugcucuguugcccagacuggaguauaguggcacaaucuuggcucacugcaagcuccgcccccupcucaagugauccucccaccucagccucucgaguagcupaccacag\n", + "gcgaagcugcucucapagaacccagaauacagacccugccgguggccucugcccucagcagucaccgcaccggcccucccccaaucagccccagcaagaggaaguucagc\n", + "ggccuuucuaaaacgcccagcccgucccuggaggccacagguuauugccuguguucucuucucuuuugauagccagccaagaagapaacgcapugacucaccag\n", + "gugcccaccuggacuggauuuaagucagaagagaaggaagaugugaguauucauuaaacgucucugcgaagccuguaaccccacaccggcucuucgaa\n", + "pcuaagauccagugagacaccgugcuguuccuugauaugaucagaugaggcaacagaupaaaacaguuugaaaacugcaaagcauuuuuuuuuuccagcacgaau\n", + "auccaguuuugugccugagacugcuugccaaguuugugaggcccaaggcuuucuugupaggacgcupcugucuucaugcucuuuggca\n", + "puuucaccauguuggccaggcuggucucgaacuccugaccuuagaugauccaacugccucggccucccaaagugcupauuacagau\n", + "guaaugaaaucuccagcucugccagaucuuuugugucaugagaaaaaaccaaaacaacuuaguuccugcccauccapcuuaucuuugaaguaauaagaggaga\n", + "gcacuuuccuaguuuacucagaggccucugaggcuaccugagagccagagucuapaauggaggaccaagaauagaag\n", + "aaaacucccuacuaugccaaacuguccgcpcpaauggaggaggcaggcpcuggagacpacccgacggugacugcgcaag\n", + "caaggaauagugucuggagccgguccagcugaaggaapugagcagagagugcaagcaggacccuugucggupugaacauuuugcuccaaaapauccuuggcccugcgcag\n", + "auccugaaggcacuaacuaagguaucuccaggcaaccaaggaucuuaccucucacauugagaaaaaccauaacuucagagacauuuccuggcuccaaauucaaguccuuucagagaccccucuacu\n", + "uuucucacugcccaagcugaagcugccupaggaapcugagcaugccuagcccagccccuucuuupagcugacugccu\n", + "gugauuuuugaagugauaacuucuggacaucaaggcuaucucgcuaucgaugaggugaagguguuaggacauccaugua\n", + "ccaggacuccucacuuccugcggauucagaauguggaaguuaaugcuggccaguuugcuaccuuccagugcagugccaucggcaggaccguggcaggagacaggcucugguuacag\n", + "ucccaggugcuguucccacugaauccauacaaggaaguaccuuugaagagaagauauuucuucaguggagagaaccaacucaaacauaugguguaaucacuuuauaugag\n", + "cacccucuaugccagcuuaugaacuugagacaccuuugaaucaaacugacaauaccgugacagucaugcugaaaccugcccacagcagaggagcaccugucag\n", + "cugugucuucaccaucguccuucacaaugaaaacaaauacacugagcacaucggugccuaauuccuauuacccag\n", + "agcuucuuugaapcagucugcaccaupacucggcuaagaaagaugagaacagaaugaagaacagauacpaauaucauugcau\n", + "acgaucauucccgagugaggcugcagacaauagaaggagacacaaacucagacuauaucaauggcaauuauaucgau\n", + "ggccaaugcaggaaaccaucuaugacuucuggaggaugguguggcacgaaaacacugcaaguaucaucauggugaccaaucuuguggaagupaagg\n", + "gucaaaugcugcaaauacuggccagaugacacagagauauauaaagacauuaaaguuacccuaauagaaacagaacuacuggcagaauaugugauaagaacauuugcuguugaaaag\n", + "gagcaguauguguuuauccacgaugcgauccuggaagccugucuuugupacaccucugugccugcuucccaaguuaggucucuguauuaugac\n", + "guggcugccucuuugaugagccguauagcacauguggauauagucaaucugaaggugaugacuucaauupagcaagugaacaccuugacuaaaccgacuucugauccaugg\n", + "guucuuacuucgaaggcugugcuccgcucaccauccagagcggaggugcggaccuuaaacucacuccuggagaaagaucugcaagugcgcag\n", + "ugcuccgcucaccauccagagcggaggugcggaccuuaaacucacuccuggagaaagaucugcaagugcgcag\n", + "cuuacuucgaaggcugugcuccgcucaccauccagagcggaggugcggaccuuaaacucacuccuggagaaagaucugcaagugcgcag\n", + "auguggaagacugaggccuguugaaagugcagagcucagcccuggcacccucuguucccaagagcucc\n", + "auguggaagacugaggccuguugaaagugcagagcucagcccuggcacccucuguucccaagagcuccaugcaggugccacagg\n", + "ugacagcagcccggagccgcggagccucagcuuccgccuggacccagccucgupagccccgcpuccugcccag\n", + "cggccggagcgaaagaggagccggaaguguggcgcgcgaggucuaapcgcgapaaguggcpcpacuaaggcpcgugcagguagccggccggccpucgcpu\n", + "gaaagaggagccggaaguguggcgcgcgaggucuaapcgcgapaaguggcpcpacuaaggcpcgugcagguagccggccggccpucgcpu\n", + "uaapcgcgapaaguggcpcpacuaaggcpcgugcagguagccggccggccpucgcpu\n", + "gaggucuaapcgcgapaaguggcpcpacuaaggcpcgugcagguagccggccggccpucgcpu\n", + "cucccagacgucccugcgcgucguccuccucgcccuccaggccgcccgcgccgcgccggaguccgcuguccgccagcuacccgcuuccugccgcccgccgcugcc\n", + "agacgucccugcgcgucguccuccucgcccuccaggccgcccgcgccgcgccggaguccgcuguccgccagcuacccgcuuccugccgcccgccgcugcc\n", + "cucacucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacuca\n", + "ccccccucacucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "gaagcpagagguggugagagaugaccccuguugaggauuucauuggugucugccacaggccgcc\n", + "cucacucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "acagaugcaaagcggcaggugugcgcaggugcgugucaacgccacccupaacccaggauggcugcggacacucacggagcccgcacccaggaacccgcucgua\n", + "ccucacucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "acucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "cucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "ucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "cccucacucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "ucacucgcgcguuaggaggcucpucguuguggugcgcugucuucccgcuugcgucapaccugcccgacucagug\n", + "acuuucuuuccaaguuacggcgcaaguucugcggcgcucggagccucccuugcgaucccacggccpacugcccggagugcaupcgcpccapacgcugagcggucgcgcc\n", + "guaccuupugcgacupcggaggugacuuggaaguucgcuucucggacuguaauacucauccuuaccuggcgccccgcuccgaguuuag\n", + "ccgagcaguuuagcgugccucucacccucagcgccugcgaagccggcggcggcgucpacuccucggcgcgcggaggaaggauaucugugug\n", + "uuugaauuuuaugaauagcugucuucuuaccuauaggagaacauauugugauguucgugccucagagcuaaaacu\n", + "acucugcaguacuuacaacagaaugcaaaagaaagagcugagcuugcagccgcugcugupcagcaguaccaccagcaucaacgucccugccgcggccuccaagaucucc\n", + "cccgcccggccgcgaagcgucuggaaccgcauccuccgcauccacauccgcaucgucguccuccccgaccgcguccugcagcagcugccaguggagccgccu\n", + "acacagugaggaaaugacagagcuggaguuuccgucuguuccacauugcugcauuuguucugccugacuuggacccuggaaaaccuggcccucuucaauuucugacaaaag\n", + "agacggaguuucacucuugucgcccaggcuggauuccaauggcgcgaucucggcucgccgcaaccuccgccucccpuucaagcgauucuccugccucagccuccugaguagcuggaauuacag\n", + "gagcuguccaaggucacacggccagcucaagcuupaacggcaggaauuccgccaggcugcucuuccccugcuuuugugaugg\n", + "ggcgccccgccccguccggcagcggccucgcucccuccgaucccccccgcgcccpaccccuggccccacuguupccagcucgccpuccggcc\n", + "gccaucuugcgagcucgucguacugaccgagcpaggcugucuugaggcggcaccgcucaccgacaccgaggcggacuggcagcccugagcgucgcaguc\n", + "gagcucgucguacugaccgagcpaggcugucuugaggcggcaccgcucaccgacaccgaggcggacuggcagcccugagcgucgcaguc\n", + "cgcggccgcaacucgcucggccgccgccaucuugcgagcucgucguacugaccgagcpaggcugucuugaggcggcaccgcucaccgacaccgaggcggacuggcagcccugagcgucgcaguc\n", + "cpcgucggcggcagcapcggcugagguggccgcuggagcucaggcggcpcgcggcup\n", + "gcagagcgaacuugcggcucguccgaguacaugugagcgguaaucgccccugcagcugguuauccugacauu\n", + "gaucuuccugugucacccaggcugaagugcaguggugagaucauagcucacugcagccucuaacuccupcucaagcgauccucccaccucagucuccugaguagcuggaaccacag\n", + "uggccacagaugucuuuaauuccaaaaaccuggccguucaggcacaaaagaagaucuupuaaa\n", + "agcgaacuugcggcucguccgaguacaugugagcgguaaucgccccugcagcugguuauccugacauu\n", + "agaguagccuugcuuuucuccuuggcauggucacggaauggauaccuguuugaucuuccugcacugcugagaaaucuuccuuuupagaggauuaagucupuugag\n", + "ccuugcuuuucuccuuggcauggucacggaauggauaccuguuugaucuuccugcacugcugagaaaucuuccuuuupagaggauuaagucupuugag\n", + "aaaaugagaaagagaccagcaagagcagacuaggaaaggaagagaapaaggagaaaaggaaacuagaaugcauuucu\n", + "uucuccuuggcauggucacggaauggauaccuguuugaucuuccugcacugcugagaaaucuuccuuuupagaggauuaagucupuugag\n", + "cagcucccaaggcugagauuacucugcuucaucuggaucgcccaucucupucucauggcugaguuucaguuccccaauccuaccugcuccucapccagcacupcugcag\n", + "guggcpacaggcuucauupacagcccuaacccagcugcugaaugccagaggccacgaagugacguuggucucccgaaagcccpcccggccggaucacgugg\n", + "auggaaugaaaccuuccaaaaagagguaaucggcagccgccuagagaccacccaauugcuggcuaaagccaucaccaaagccccacaaccccccaaggccupucuuagucacagguguag\n", + "ucauupacagcccuaacccagcugcugaaugccagaggccacgaagugacguuggucucccgaaagcccpcccggccggaucacgugg\n", + "auggaaugaaaccuuccaaaaagagguaaucggcagccgccuagagaccacccaauugcuggcuaaagccaucaccaaagccccacaaccccccaaggccupucuuagucacaggu\n", + "cgacaggaugagcucgcugcaucpcugccgagcugcgaugccgccgucaaccuggccggagagaacauccucaacccucuccgaag\n", + "gaugagcucgcugcaucpcugccgagcugcgaugccgccgucaaccuggccggagagaacauccucaacccucuccgaag\n", + "cpacaggcuucauupacagcccuaacccagcugcugaaugccagaggccacgaagugacguuggucucccgaaagcccpcccggccggaucacgugg\n", + "gguggcpacaggcuucauupacagcccuaacccagcugcugaaugccagaggccacgaagugacguuggucucccgaaagcccpcccggccggaucacgugg\n", + "cucccpcggcggcgguggcggcucpcupcuccgcgucpccggccccgcggccgcuc\n", + "agaaguccucaggacggagcagagguggccggcpcccggcugacugcgccucugcuuucuuuccauaaccuuuucuuucggacucgaaucacggcugcugcgaapucuaguuccggacacuag\n", + "agugccccupcucuacccccaaaaccuucccapcucugucccggcaguucagapccagg\n", + "guugaacaggaaacccggcagcgcpagccgcacagucgaggapagcgcpacgccgagcccacgcgcgccugccpcaaguggaggcgaagccggcgagcggacgccccgag\n", + "acaugagcaggcagccccgacuggaaggagcccpcccucauuccuucuccuccacupaacuga\n", + "gcacugcuuaguggaccucauuuaaucuucccaauaauccagugaagupuguuacuaucccauugacaggaaagaaaucugagcugcagagauaaggcagaacucccaag\n", + "aaaaugagccacagagcaagcugaccccagcgacacagccccccagcccuacuguauuuccguuccuaucaaaaa\n", + "aggucugccagccuggacuggaagcgugcaacacuccagagucguaggagugaacacugcacaggaaucucugcccaucucaggagaaaccaaacuupaaa\n", + "acagaccucggcugcccgacaacuacacgcaggacacguggcggaagcugcacgaggcggugcpccgugcagagcagcaccuccaucagguacaaccucgaggagcucuaccag\n", + "acagaccucggcugcccgacaacuacacgcaggacacguggcggaagcugcacgaggcggugcpccgugcagagcagcaccuccaucag\n", + "ccupaccggcucggcgacgcgcucpcugapcccpucuuucugccpccccguccucucagccpacgccagcggcucugauu\n", + "gagacpauucaggcuguggcuaaugugcuggaagcacgcacaguugugaccaucaaguaugcaggaagcaaucauucuccuggcucuccupugccaugucag\n", + "agucggcaccacagcgguggcugccpcguggugucggupucgguugguuuuugucucaccguugguguccgugccguucaguugcccgcc\n", + "cgucucccuccuggcgcuuguccuccucucccagucggcaccacagcgguggcugccpcguggugucggupucgguugguuuuugucucaccguugguguccgugccguucaguugcccgcc\n", + "ccuccuggcgcuuguccuccucucccagucggcaccacagcgguggcugccpcguggugucggupucgguugguuuuugucucaccguugguguccgugccguucaguugcccgcc\n", + "gucucccuccuggcgcuuguccuccucucccagucggcaccacagcgguggcugccpcguggugucggupucgguugguuuuugucucaccguugguguccgugccguucaguugcccgcc\n", + "cgaagcuucaggagaccuauccucaucugugcaaggaggaguggccaacucuggagcccaggcuguugcuuccuggucugguggugaauccuccauagucug\n", + "auuuuacgacaggcpauuguuuuguggcugucagcuuuccccguggucugaguuuguggcugcauuuuuaucucugguggcucugcuacggcggcgcagaaaugaggcagaagcggaaag\n", + "ggugaaaaccaagacagcugccaaauauggccuuucugcccagccccgccugguggauaucauugcugccgucccuccucaguaucgcaaggucuug\n", + "ggcugucagcuuuccccguggucugaguuuguggcugcauuuuuaucucugguggcucugcuacggcggcgcagaa\n", + "auugaccgacauuuuacgacaggcpauuguuuuguggcugucagcuuuccccguggucugaguuuguggcugcauuuuuaucucugguggcucugcuacggcggcgcagaa\n", + "gagaucucagcccugcugagcugaugaugcugacuauaggagauguuauuaaacaacugauugaagcccacgagcapaaagacaucgaucuaaauaa\n", + "gcugucagcuuuccccguggucugaguuuguggcugcauuuuuaucucugguggcucugcuacggcggcgcagaaaugaggcagaagcggaaag\n", + "ggacugaugcccuuggccagacgcacccccaacugcugucugcucagguguagcccgcgugacugagucaccgcugcuccagcuguuucac\n", + "guucugaacucccggucuccccagucccuggaggcugccugcagcuuugcuuagcuucucagccuguugaucacugccguggaauuggcgaguaucuuccpaaagcagagacaaaa\n", + "aaagcuccugcugcuucuguaccccgccugucccucccagcugcgcapccccuucgupaucaucagcccgaagacap\n", + "cagccaucggagaccagagccgcccccucugcucgagaaapcucagcggcggcggaagcggapaccaccguggagagcgcggucccagcccggccacugcggaucccugaaaccaa\n", + "auggagucucgcucugucacccaggcuggaguacaguggcacgaucuuggcugacugcaagcuuugccucccpuucaagcgauucuccugccucaagccuccugaguaacupacuacag\n", + "uuucacuugugcugcccaggcuggagugcaguggcacuaucuuggcacacuguggcuuaugucacpuucaagcgauucugcugucucagccucccaaguauggauuacag\n", + "aaacaggcuuacuguguucacugcuggacgccucupcaaucuuacccuccupaacugagagag\n", + "guuucuuucccuuaccuuauaccaucacucacgaauuucagcuccauguuaaagaacagcggaauua\n", + "agcggcccuccagccccaapcgguaacacccggcccuucggccaaccucgcggccccppcaccuugguucccgcggaaggacccagg\n", + "accucaaaucaucuaacgugaagccacagacaucuupcaauuuuaaucaucaagaaagaaauaugucauuaagaaauagcapuauuuugaaagaguuggaaaacauc\n", + "ggcupccucgucgaccggcaagcggaacgcggcagcpcupccugugcggcggccgccggagcgcuuuggaaggcgcacpcgaag\n", + "cgaccggcaagcggaacgcggcagcpcupccugugcggcggccgccggagcgcuuuggaaggcgcacpcgaag\n", + "acauucacupcaagccgacugugagccaggaagugcucuupagcccaggccaagccauccauucuupuccuuuggag\n", + "gguagauauggauucccaguuucuccagcggccagugcucccccuaguccacacagugagaccgugaaagcagaugcuccpcacuccupcagcuuuugcucagugg\n", + "cuuccaggcggccpacgcggucccaggacuggagaccguugccugucggcccccgugugacccpcgcgugacpucpaacugcgccugca\n", + "gguauuguguucacaaaccagaggugaucuucaggcugcaacaaggagaagagccauggaaacaggaggaagaauucccaagccaaagcuuuccag\n", + "aagucuggacagcugaucaccugaaagagaggagccaagaaaaccaaucuaaacauuugupaaguuguauucaucaauaaugaa\n", + "uccuuuuguuuuucucagguuuugcgupaggcggucccpauuucaapucuacgcgcuuuucuauggcgaaugcaacccgacgapagup\n", + "cguccgccggcuacgucugcguuuccgccuuuccuuuuguuuuucucagguuuugcgupaggcggucccpauuucaapucuacgcgcuuuucu\n", + "guuuccgccuuuccuuuuguuuuucucagguuuugcgupaggcggucccpauuucaapucuacgcgcuuuucuauggcgaaugcaacccgacgapagup\n", + "ucugcguuuccgccuuuccuuuuguuuuucucagguuuugcgupaggcggucccpauuucaapucuacgcgcuuuucuauggcgaaugcaacccgacgapagup\n", + "guggagucgcaaaagcugaacauccuccccacaagguuauuuagaagacgucuugcacuguucaaaugcagaggaaggcgaaugacucgagucuaug\n", + "guuuugguauacugagccupcuacuggugucagccuggugguagugcagcucaucugaugccupcugcaggauccuaguugguuccugugacagaccuupaagcucaaucucag\n", + "auguguuuucuuaauugaagaaaaucauaucacaugugaacuuucugaccauacuguggagcggugcuaauaaggag\n", + "gaagcugcacuguugcagagguccauuaacucuuucaggacgguguggaaucagupaaaucucuaauugcuacugacacag\n", + "gguucuguguucacuugacuaccagaaacauuucuaguuuaccaucagaguuuuagccgcuuccaugcuucugugacugcagcuacucucag\n", + "uccuaaccgcaggccaacuuucuucccagagcuuuuapccuggccuuugcaguuccagaucuacuacagcaaacaucguucaag\n", + "cacuuggucaaacaaauaaccacugcugcaguggaaaugaacuaaaauaguuuuuauggaaagcugaagaaugaaauaauuuuggaaaacuauacucuaccaaaacc\n", + "auugccucuugaguccuagacuuggaaguggcacagcaugauugcugcugcagcagucucuugacccag\n", + "ggaguggcagccggagucugaacuguccupaccaagcaggagcuuaagaupcaagaccupcccupcagacgcaucaaagcaggcagaagcaggc\n", + "ggaccaagcaggagcuuaagaupcaagaccupcccupcagacgcaucaaagcaggcagaagcaggc\n", + "gccagcaggaagaccaagaagaaggaapugcccuccpcccagagagccucauccaaugucuucuccaacuuugagcagacucagauccaggaguucaaggag\n", + "gaagaccaagaagaaggaapugcccuccpcccagagagccucauccaaugucuucuccaacuuugagcagacucagauccaggaguucaaggag\n", + "aaaacucucugaaguuuuuauuuacccagcgcucuggcucccacuucuguuuuaaaagauuauaaguaaauacucugcucuuucaagugaaccaaaccuaucaaaccuguuuagaaaauaaaccag\n", + "guuuuaaaagauuauaaguaaauacucugcucuuucaagugaaccaaaccuaucaaaccuguuuagaaaauaaaccag\n", + "gcagaauaaaaugaugcgaaauguucauuuuaaaaaacuucaggaupcacaaacacacagaagupaaaugaauaaaagaguauugauaaauuuuugaaaauuguugaagcugaguaaugg\n", + "agagaaaucucaucaucugugcagccuucuuaaagcaaacuaagaccagapaggauuauccuugaccuuugaagaccaaaacuaaacugaaauuuaaa\n", + "auuuuuguguggacauaaguuuucaauucauuugagugaauacauaggaggacaauugcugaauuguaug\n", + "gaagcgccgccgccaccgccgccuuugcugucccccggccucuaguuccccgcaggupaggupagcc\n", + "ggaagcgccgccgccaccgccgccuuugcugucccccggccucuaguuccccgcaggupaggupagcc\n", + "guuagagcggaagcgccgccgccaccgccgccuuugcugucccccggccucuaguuccccgcaggupaggupagcc\n", + "cgccgccgccaccgccgccuuugcugucccccggccucuaguuccccgcaggupaggupagcc\n", + "uuuccuggacagcuacaggcucugccuguugacucuuucaccugccucugcucuauauauuuggugacuuucaaccaugugaaaauuagaaaauuuaaacuucuucaugag\n", + "caggcucugccuguugacucuuucaccugccucugcucuauauauuuggugacuuucaaccaugugaaaauuagaaaauuuaaacuucuucaugag\n", + "gguuuuucaaguuccugcuccaaguaguucacaapucaaguaguccagcauucuacaguuuguguguuugagagaaaaauaagcccauaaaaacauucuaaccuucagauuaag\n", + "guacagcggccuccgccgcaccpacagcagccgccgccgcugccgccguccuccccugucuacccggagcugucucgagcugagcccccuaccpccggaucccgag\n", + "aggacaccuuuagccucauuuccugaucgaacagccucacuuguguugcugucagugccaguapcaggcagga\n", + "ccauacuucccauugccuccagcuguugcacggagguuucacaucauauuuccagaaggcuccuggaaagagugaau\n", + "gcugcuggagcugcagcccgaccgcgagcgugccaagcggcuucagcagcuagcggagcgguggcggcggccccccucaggacaccaccag\n", + "gaucggaucaaucacuuuucuagaggaaguagcagucccucuugugagagcgcaaggucauuacuugugcuccuaapcguggacgugcuuuguggaauga\n", + "aagauggccgcgcugccccgcggccccucgccccucucugcccpaucucccuuuggcccuuugaccccagcuuaccgcacuucuugucccucccgcagauuccccucuucccgcggccucgcc\n", + "guuaauupauucugccuuuggaggaucggaucaaucacuuuucuagaggaaguagcagucccucuugugagagcgcaaggucauuacuugugcuccuaapcguggacgugcuuuguggaauga\n", + "cccaccgacggacggaggcagcccaccugcaggaccpcgcugucgguccacguggccgcucuggagcag\n", + "ugugugcaagaugaagaagccaacacagaugaccuuacgacucuggauaggaaagccaucuuacagcaagguuaugcagacaacucuugcgauaaacaacagapcaagaaaauuggaugca\n", + "agagccpuuccucccpuuucugccpuuucucccugcggcuccupuuguugagacucuugugaag\n", + "ucggaaacucagagccpuuccucccpuuucugccpuuucucccugcggcuccupuuguugagacucuugugaag\n", + "pcugucucggaaacucagagccpuuccucccpuuucugccpuuucucccugcggcuccupuuguugagacucuugugaag\n", + "cpuuccucccpuuucugccpuuucucccugcggcuccupuuguugagacucuugugaag\n", + "pcpcagcggcgcgcggcgucccggaacccagcagcuugagaacucgcgcaccupaagccggcaggaggcagcgg\n", + "agcpcaugcgcpcugcgguggcgcaggcgcccugccgcgcccgccagucpaaccgguucuccgaguccgagcuggcggcgcgcu\n", + "gauauagcaacaaggugccaccuguaaagcaagagagcccucaccagacacugaaucugcuggugccuuuaucuuggacuucccagccuuuagaccu\n", + "agagcagcggaucccggucucgccgcagcagcagcgcpugucgugcaccgccugaagacgccguaccuuucuaccccccaccuuuuuuuuuuuuuuuuuuaaauaaccggaacca\n", + "gucauuauauguuagaagugcaaucaguacauaacuggaauuuuuaaaucaaucuguaacugauuuuaaaag\n", + "cuuacuaauuuccagugccccaaggucucugcacugccgccccuccucacaggagacggacaccucagccuagaucccuuggugcucuccacgcuguucag\n", + "cauucuucacgaugccugaugcugugcagaagagcguagucuagaagaaagaacacggauuuuggagacaggcauuccucucaaccccaaaccugccaucuccuagccauguaacuuuggacaag\n", + "pcaauagaaagacaacuaaagaaggauccaacgauuugaaauuccagaacuucagucugccaaaaaacag\n", + "uggucuugaacuccugaccuugugauccgcucgccucagccucccaaagugcupauuacaggcaugagccaccgugccuguccuagaaccacugguaacucuuaacug\n", + "cagcugugugagaagccpcagccuccugcucugugaaggacccugcugcggagcuuuccaccucgccugccuupcuuucccggaggccagaapagguucaccugcagcgagugugccucag\n", + "pucucgccaucaccauguugcccagucuggucuccaacuccupcucaagcgauccuccugccuuggucucccaaagugcupauuacag\n", + "gccgccgccgccgcccccuccccgccupcccuaccgccgcacggccccggcccccucccagccugccgcuccggagagccgcccgccgaggaugcgacgcaccgcag\n", + "agaupucucgccaucaccauguugcccagucuggucuccaacuccupcucaagcgauccuccugccuuggucucccaaagugcupauuacag\n", + "pcccuaccgccgcacggccccggcccccucccagccugccgcuccggagagccgcccgccgaggaugcgacgcaccgcag\n", + "gcgaacugugaugaagagccuuauacuuaggaagacacaacuaccuuugaacaguccuuugugaaaucuaaug\n", + "agcagagaauucacggacagaagaacaacacagcapcagagagccacagagccacuagcagaugucapagaugaagagapccacaguaaaauaagacucup\n", + "aguguaauaaggucccggagaagugucacuggcccugagupacccgguagcccguucgcuccgcgccggcggccuguccccgcggcuuggcpcuapcapaa\n", + "aauaaggucccggagaagugucacuggcccugagupacccgguagcccguucgcuccgcgccggcggccuguccccgcggcuuggcpcuapcapaa\n", + "gagccguagacuucuaauacaucuagagaugucauauaguugauuagaaaguugaguucagupugcagaccugcaagaucauauucuuccuccuguac\n", + "guugugaccagagcgguugcpcugagcgguuucgagccggcgucpagcggcgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "ggucucccgaggaccuuguacccgcgcggcuuccuupcuggcuuuggacgacgcuuucgccuuccugcugccuaggauccgccgac\n", + "gaccagagcgguugcpcugagcgguuucgagccggcgucpagcggcgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "pagcggcgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "gugaccagagcgguugcpcugagcgguuucgagccggcgucpagcggcgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "cgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "gcugagcgguuucgagccggcgucpagcggcgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "cpagcggcgguaccpcggcugcpcuggcucgacccagcuugaggucucggcguccgcguccugcggugcccugg\n", + "gcuaagaaacggagcuuccacaaaccagauagagguucuccagcuuuucuuugauugucucugcuuuagcgucucuaaauccggucacc\n", + "ggagcuuccacaaaccagauagagguucuccagcuuuucuuugauugucucugcuuuagcgucucuaaauccggucacc\n", + "gcuguacaucucaugguugcuaagaaacggagcuuccacaaaccagauagagguucuccagcuuuucuuugauugucucugcuuuagcgucucuaaauccggucacc\n", + "agaugauaucuuccaagugucugcucpacacggcuucagcccucugugguccccucuccccppcuuupauucuugucaagcuccuucaagagccugcaagcacuuaacc\n", + "cugcucpacacggcuucagcccucugugguccccucuccccppcuuupauucuugucaagcuccuucaagagccugcaagcacuuaacc\n", + "uaucuuccaagugucugcucpacacggcuucagcccucugugguccccucuccccppcuuupauucuugucaagcuccuucaagagccugcaagcacuuaacc\n", + "cagcgcgccccpcucggccgacccggcpaucuapupcgacuucgcpaccguggcgcaug\n", + "ccucgcgccccuucggcccgucccguccagcccpcugcccggcucucgcaggcccccccgcgccgaccgcguuccuauggacagacgcacagacaccugcag\n", + "pccuggucuggccaauggaagcacagagugcaggcucaguggucacguguccagcpcpaauuuuaccccaggaagagaugcaggaggcgauuuuuaccucag\n", + "aaagaagaaagugcuucaagaaggaaguaguaguccaauguguupcuccuguuaaaagcucaaguuaugugaggaua\n", + "aaagaagaaagugcuucaagaaggaaguaguaguccaauguguupcuccuguuaaaagcucaaguuaugugaggauagugaguugaccauuagcuugacuaaau\n", + "ucucagcuguuucaguuccpaaugacagauaccucagucuuggaccaauggaaagcaaguuucuuuguggaggauuuccuugagaa\n", + "aucuuacuaacaagcauggaauugaggauaucpauauaaaauucagcuccacagagauuuugaccauucaaagccagagugaaccagaagagugcaguaaaccag\n", + "cugauccugaaacagcaguggaucccupagagcagcacagauaaagauccaggcaauaaugaugcuuccuccucuuggacagccuuuuacaguucuggccauggaacuucagagaag\n", + "aaguccuugaugguuuccguggaaucgauucccagupaaaugaugagucaagguuacauacaguuuacggccucug\n", + "uggaapaagaggcucuggaapcugaucupacupcapaagcuucugcaaggcuuccag\n", + "gacauuccauauacaagauggccgcagucggcaaggagagacgucgcugapcuugccugaagcgap\n", + "agucggcugcguacuccugcgagcgccggagapcuggaggcpcgapcgcggcucgaggcaucccugcapcgcuccuccgagucccucggcgcucugagcccacag\n", + "ggaagaaggapccggcgucagugacgucagcgagaccgaggugagcgupcguugccaguggugcucugucagugccuaug\n", + "ggaguguuuauuucgcguccgcuucuguuucuccgcgccccugugcugccccgacucacauacucguccagaaccggccucagccucuccgcgcagaaguuucccggagcc\n", + "gcgagauagaaaguaucaaggagugaguugaagccacuggccuugagaacccucucgaggagucuggccucaugaagaugccagaauaaauggcag\n", + "uaagaagaaaaagagcaaagauaagaaaagaaaaagagaagaagaugaagaaacccagcuugauauuguug\n", + "gaaucugguggacaguaacaaacuuuggugaaauuucaggaaccauagccauugaaauggauaapaaccuauauac\n", + "gcgagauagaaaguaucaaggagugaguugaagccacuggccuugagaacccucucgaggagucuggccucaugaagaugccagaauaaaug\n", + "guuguggccgccgccgccgcgcgucgcggaggcacguguggagccccggcagcaggagcgucgcag\n", + "ccugagucccpaggaaagugcucgcccauuccugaccugugacacgcucacugcgaaggcagguuauuagaagagucccaugaaaguaaacagg\n", + "ugupagguagapuguguguucuugugcagaggagcgupuuugcagaggagacapagcuuuguguacccggagca\n", + "ccugagucccpaggaaagugcucgcccauuccugaccugugacacgcucacugcgaaggcagguuauuagaagagucccaugaaa\n", + "aacacaugcagcugccuggagagapagccgguguccuacgucagagccgccgccgccgcggagccgccgccpaggagcagccgcugccgcccaggacupcccuuag\n", + "ggaggaggaggcgagaagauggcggacgaccccagugcugccgacaggaacguggagaucuggaagaucaagaagcucauuaagagcuuggaggcggcccgcgg\n", + "acguuaacccucupcgaagcauugaugaaagcuuugauaagccaaagugccccuaaaaccaaugagaacaagaagagaaucugagugcagaggccccupagcuuugapauacauugcu\n", + "ggauugcaacacaugcagcugccuggagagapagccgguguccuacgucagagccgccgccgccgcggagccgccgccpaggagcagccgcugccgcccaggacupcccuuag\n", + "acagcgcgcgaagacpugcgcgauccucgcaccccaggcagcccgcgacggaccggacccagcugucacccagccgcgapapcagcpccgaapagaccugag\n", + "aaaacaaguaugauuaucuuccaacuacugugaaugugugcucagaacuggugaagcuaguuuucugugugcuugugucauucuguguuauaaagaaag\n", + "auggcgucucgcucugucacccaggcuggagugcaguggcgcgaucccugcuuacugcagcuucugccucccagguucgagagauucuccugccucagccucccaaguagcupacuacag\n", + "cagcugacaucugugaagccucagugauccuauaaauugaggaaccugagagaaucaagagaaagacaacaauucuugcugau\n", + "agcagaacgcugcggaccgcggcggaggacgcgcccggcgccccugagccggccgagcggcgacggaccgcgag\n", + "auucccggauccgccggcupaaucgcpuccccgcgcguccugcagcacuucccgcgccgcgcccccagcccagugcgccggcucugugccpugcccpcggucpaga\n", + "paaaugguguccugcuggapagaacugaucgauguaucucggcacagcaucuuggacacucauggcaggaag\n", + "gagcgcuacuacgugcuguauauccggcccagucacauccaucgccguaaauucgacgccaapaaaugaaaucgagcccaacuucagcgccaccaggaaggugaacacpcuuccuc\n", + "accucgauupcpcggcaaucupucuugugccucuggcuccucapcauucccggcggcuccpuuuggcaacgaggacpagugcgacugcgucucpcagc\n", + "apcauucccggcggcuccpuuuggcaacgaggacpagugcgacugcgucucpcagc\n", + "guuaacgcacupucgugcucauuggucugauuugaagauaggaacauuuaacuucguacacccaagacuuacacuugaa\n", + "ccgcccggcggcccgcgcuuccucgaaggccccagcccggcucagucggccgagagcgapaggagccccccgacccag\n", + "uguaugaaauccagaaaucaaguagauuucuugauuuaccuuuuauguauauuuuuucuuccaucuagguagacguuacauccaagaggaaauaauccaggcaaggaagcacaagcugaucaag\n", + "auggauucgupcugcuuccaccugcuaggapugguguacucuaacucapacagaagccccugucugugcucaggacucuugcagaccucuuuaccuggcuguucaucuuccauaaucaacug\n", + "gcgccuaguuuuucuaucucucccggagccugagucucugagccguccccagcaaacgcucapcugcagaggccccgagag\n", + "cuuggcucucuggcagauuuccucuaguaagagguggcucuggaggccccgcgaaacgaguguggugugugguugcaaggc\n", + "gaauaggaacagcuccggucuacagcucccagccugagcgacgcagaagacpugauuucugcauuuccaucugag\n", + "cuacgaaaauaacaagcuggccaugaagcuacauagcagaauaugcgapcaacgugcuaaguu\n", + "guaauucagagguccgupccagccagccugagcuugcucaccuucaaagucuaugcagcaccaaaaaaggacucaccucccaaaaauuccgugaagguugaugag\n", + "cuuucacucuacucaguuccugapucaaucgaaguauguggaggaggcaaggagccagcuugaagaaagcaucucacagcuccgacacuauugcgagccauacacaaccuggugucag\n", + "aapapccgcpaggapuacgaguggccgaccacggauuugcauugccgaggacpaccccapcagcgaagcag\n", + "ggapagapaggagaapapccgcpaggapuacgaguggccgaccacggauuugcauugccgaggacpaccccapcagcgaagcag\n", + "auucagcupaggapagapaggagaapapccgcpaggapuacgaguggccgaccacggauuugcauugccgaggacpaccccapcagcgaagcag\n", + "agcaugucugguauccagcuuuuaauccguaaugccaggcacucccaaauaaaaggaaccaaucaacugaugcaugcauucucuagcaggucauuccag\n", + "aagcuccauuaccuacucccaccuccccacaugaugaaacapaaacagugcugcaggcauacagugacaacaggacaucaggaaaugcccaagaag\n", + "uuuguuaggugcugugucaugaaucaagucuucauuuuaauguguucuaauuguuguaaaacaagapaaugguauuuggaauuuagcuauauuuaucuucucaaucaaauucuacuucagag\n", + "ggcugccggcggcgucgcggagcugguagcagagucccagcgcgccgcucacuacugaaupuccuggugcgguucucg\n", + "cgcguucguucacauagcucccaguuuuaacauuucgccaccuacugaagacaucauuupaccaagcugaugagcccuugaagcacagcag\n", + "auaagaguguugcuguugaucaucuuugccupaaguugaaugauaaagccagaagaaagcaugcuuucugaucauu\n", + "ugcagcugucugcuucagaaagugapcuccaggaaugaggagaaucuucaagaacuuccucgcacugugacaugucugaucccuugcucccaucccugcagcaugaacaag\n", + "cugucugcuucagaaagugapcuccaggaaugaggagaaucuucaagaacuuccucgcacugugacaugucugaucccuugcucccaucccugcagcaugaacaag\n", + "auucacagugcagcugucugcuucagaaagugapcuccaggaaugaggagaaucuucaagaacuuccucgcacugugacaugucugaucccuugcucccaucccugcagcaugaacaag\n", + "guaaaagaagaaaaacgcaaguggaagagacuucucagaucagcaggaacuggaauguguucaagucuuggcagagccag\n", + "aguccgcucpcggccgcccaggcgaggugcggccuccgcacaggcppcguaggcgcgcpcccgccauggcugcgucggagcucuacacaaag\n", + "cuaguccgcucpcggccgcccaggcgaggugcggccuccgcacaggcppcguaggcgcgcpcccgcc\n", + "aguccgcucpcggccgcccaggcgaggugcggccuccgcacaggcppcguaggcgcgcpcccgcc\n", + "cucaucauuuaucauuaguguauuuuauguguggccaaagaaaauucuucuuccaguguggcccapaagccaaaagauuggacacccuccguucuau\n", + "ccaccggagcaggaapacaggucggugcggucuaagcuacuccguaaaagcagccguugugugucuccguguguguguuapaacaaguggaga\n", + "uuuccuugaucuugcpuggapuaaguguguuacuaaguauguuccuggacaaggagucccucugaagauagaagugaugagaagauagaagaaaag\n", + "aacugugcgaaccagacccggcagccuugcucaguucagcauagcggagcggauccgaucggaucggagcggaucggagcacaccggagcaggcucaucgagaaggcgucugcgagacc\n", + "cgacccagcuucccuuguccapagcaacucagacacagucucgcuucauuuuuauucupuuguacaaucuaag\n", + "gapcaccaggcccgcaggacccuupapcaggugcugugacccpaaccuggcacacupcccagapagcuggcggapagcgagcgcccap\n", + "gguuggaagcccagcgaggcuagaggccagucccaaaguuuccaggcaucapcugcagcccaggagccucaaggcggcccggcpcgacuggacggccggacag\n", + "gcucuccucagugcccgguggcccaggapccupagcccgaagccguccccgagucgcuccuaggucacuggcgcgaugcpccguccucucggcug\n", + "ugaugguucggaaguccuccugcccucugagagcuugcaguuucuugugaaaaagagaaacuaagcagcaauagaacagacccggugucugcuugcgugguuaagacg\n", + "gcuuuugguuacuccccuucccaccccaucccuuaauuuuauucuuuugaagagugcauuucaagcugccaagguggagagapauuacagaaaggagaacaccuuauuucag\n", + "augcacuucccgcuacgccucggugcagcccccggcgaagcccagcgcagcucagcuaaacucagcggagccagcgcggcgcg\n", + "aggcaaccgucgugccgcgucuuccugagguagcuccugucagcccacugaucccaccacccgcucccuacugccccgcggucuucgcgugagcucggagacugapacaacaaaa\n", + "gccgcgucuuccugagguagcuccugucagcccacugaucccaccacccgcucccuacugccccgcggucuucgcgugagcucggagacugapacaacaaaa\n", + "ugaacaaggagapugguggcaupaccugccuuccuggaguuaaucaucuagaugaaagcugcuauuccaggauucacaccuucaacuggugacaucguuccuguggcuaaau\n", + "agaggcupcupccapcapcagccgauggagagcagaucugagcacccagccaccuucacgccaccgcccagcugcccaggagcccagccag\n", + "cuugcuccucaggcagaggcugaguccgcacaucaccuccaggcccucagaacaccugccccagccccacc\n", + "agapcugagaccaaaccagaaaccuccaauucucauguggaagcccaugcccucacccuccaac\n", + "agcagapcugagaccaaaccagaaaccuccaauucucauguggaagcccaugcccucacccuccaac\n", + "ggaaccggagcuccpcggcgucggcagcggcgcgagaggcgacgaggcccpcggcaggagccggcgcggcgaccgcggcgapcggcpacggagcagagcacgacgaagacgcacag\n", + "ggagagcggccggcpcagcpcpaggccpcpccgcpcagccaccgagccgcgaagcgacauggugcugcucaaggagua\n", + "pacupacagguggagauguuuggugugcuaaaucuuucaaguacaagaugagccaucguugaagcucapuuccaa\n", + "ccpcggcgucggcagcggcgcgagaggcgacgaggcccpcggcaggagccggcgcggcgaccgcggcgapcggcpacggagcagagcacgacgaagacgcacag\n", + "caaaguacccacguuuguucgaaugcuggccccagapagcccugaauauacacgagaaagccuggaaugcuuaccccuacugcagaaccg\n", + "gcugaggcacauccacaaccaagagccuuuccucccugaggaucaacaccucccccugccauccuaagucaaggucuugaccuaaggacuuguaacaaccaagccaaagcccagagg\n", + "gaapcagacagaguguccaaaagcgugagagcacgaagugaggagaagguggagaagagagaagaggaagaggaagaggaagagaggaagcggapaacugcggccagg\n", + "aaacagccagugcagaggagaggaacguguguccagugucccgaucccugcggagcuaguagcugagagcucugugcccupcaccuugcagcccugcaccugccugccacuuccccaccgaggcc\n", + "guugcgcaggcgcauccgaucgacucgguaggupaucucuuggagacggcgacccaggcaucupagccacagaagucguacucccuuaaacc\n", + "agcaupacggcgcgccugaaggagcaggaapaaggaggccupaccccgaaaagagaapagagcgapacgagagcggaggaggaag\n", + "auugucuacugaaagcugccgcugaagcugccgccguugccuccgccgccaagagugagcgagcggacccgcg\n", + "auauugucuacugaaagcugccgcugaagcugccgccguugccuccgccgccaagagugagcgagcggacccgcg\n", + "acuucccggcgcupaacgcggagcggacgcagucuggccgccauugcgcugcpaaagcggccucuugugugapccugup\n", + "gccauucgcucuucagacgccggagacguaggagupucuucagacuccaaapuuggacua\n", + "acccggagcucuggcggcgugcgcgcgcguuguauugcgcgcggccaugaggccacggagcucugcpaaugcacgcagcagccuuacguuuaggcc\n", + "paggugccagaaguugagcccugaggcccugcuggccccupcgcaggcccagcucaggcccccap\n", + "guagaguuagaaaaacaugaaccauuaacagauguggccucccugcagaacuuuuacuuugaaaaagaaguacgucugaaccagauucacauguuugauauuuggaugcagagaaa\n", + "ugcgucucugcugaucugagucugccugcagcauggaccupucuucccugaagcaucuccapcuggagagacgacugccaug\n", + "guuggcgcgcacgcgccugagcgugcgcccggupccggccpacucgccgcucgcacgcccuupccgcggccpcgcccgcucuuccuuccgcuugcgcugugagcugaggcggugu\n", + "gcacggaupcagaagccuuugcagguaucagaaguucacauaucaaauauaucugcccgcaugc\n", + "gagagaagcgagauuuauuccuacguaccpccgugcugcuuauggcggcgcuggagapcgcugagcuguup\n", + "gcgcccggagcccgcaacucucgcgagagaagcgagauuuauuccuacguaccpccgugcugcuuauggcggcgcuggagapcgcugagcuguup\n", + "augauguugaauuugaaguaucaucggaccgacggacupaaacccauugcuguuaaacuggugaagauaaaacaagaaauccucccugaagaacga\n", + "ccccuccuucacuuucuuuacccuuaucuucaucuucuaccucaucupacuaaaaaacaaaagaggaccccaacuuaucagagaucu\n", + "auuuccccaggagagcuuuucugcaaugcaguuauuaagaaaaauaucuccacauuuugauacauguugcuaaauugcauuucuaaaag\n", + "caacuuucauccuuugaaacgugugcugaaaaagaagaaucagcaaauacuacugaaagugcaauauuugaguaucacugcgag\n", + "gcuguupugaguacgaccucapuccaacupuagcagaaacccapaapcugagaauaagaccaaggcuaacgagaagccuucugagucaag\n", + "gcgagagaagcgagauuuauuccuacguaccpccgugcugcuuauggcggcgcuggagapcgcugagcuguup\n", + "auuggaugaaucaucucuuugcucuuauuucaaccuuuuaauuacugauccacccucuuugauuaccugacacaacaggaauaucuuucguaacuugaaag\n", + "cacuggauuaggugcgaaaggaggcugugauaaagaaauuugaguuuaccucucagaaauuugaaauagaauuggaggaacaagauacauaaaaacaugaa\n", + "gcaacucucgcgagagaagcgagauuuauuccuacguaccpccgugcugcuuauggcggcgcuggagapcgcugagcuguup\n", + "uuauucuggacaguuacucuuaagaaaguugucagaagaaacgcaucugccuuuuuuuccaggugaacugccgugaguuguccagc\n", + "acuuaacaaccgaaguaacccgcaaugcggaapcgapauugcgagucaccgaguuucccgcgcggcuugag\n", + "aacguguuaggaacuaguacuuaaauaaucucaagucccugapccagagaucccaccaugcaaaauagcaaacagacccaagacuupagaggcg\n", + "agucuuucauugcgcgccuacaugugccuacgaccucacuucugcuucucuacgacucaccacccucacagcuggagcaaauucagaaacauccuugguaccu\n", + "gcucacgccuguaaucccagcacuuupaagcugaggupcaaaucacaaggucaggaguuugagaccagccugaccaacauggugaaaccccaucucuacuaaaaauacaaaaauuagccaggc\n", + "agaccppacgcggcgguagcggcggccguugcgauugauugcgcugguugccugcggcguccacuuccuuggccgcccuugcuacacuggcugauuguugugcagccggcgcc\n", + "guaagaccppacgcggcgguagcggcggccguugcgauugauugcgcugguugccugcggcguccacuuccuuggccgcccuugcuacacuggcugauuguugugcagccggcgcc\n", + "cguaagaccppacgcggcgguagcggcggccguugcgauugauugcgcugguugccugcggcguccacuuccuuggccgcccuugcuacacuggcugauuguugugcagccggcgcc\n", + "ggucuccgcucaacgauccuuccucaaagcaugguugcugaguacccagaguugcgaggaguuuuuuaacug\n", + "cauguaagucuucucaugaaugucuccucaugauggaaagaggcugccucaccuccaggccuuauguccaagccaggcaggcugaaggaagaaug\n", + "ccucuuccgaggaaaggcpccupcgcccgcpaaacccpcccguugcauccgcupuguagccgup\n", + "ggaaaggcpccupcgcccgcpaaacccpcccguugcauccgcupuguagccgup\n", + "gcacacagagccuguagaccugaguggauggacacugccucuuagaacuagaacuuagaacuuuaucuugaaaauguaccacuguugcagaagcuccucacagaguaugugucag\n", + "gcauuuuuaaccugcuaaaggcaagaagaaguguucaccacauaguugcaaaggucuucaacuugccacagccaacagaaaaaucaaa\n", + "gcacacagagccuguagaccugaguggauggacacugccucuuagaacuagaacuuagaacuuuaucuugaaaauguaccacuguugcagaagcuccucacaga\n", + "acacagagccuguagaccugaguggauggacacugccucuuagaacuagaacuuagaacuuuaucuugaaaauguaccacuguugcagaagcuccucacagaguaugugucag\n", + "aaugauuacggaccugaagccaaagaacaagaugcgcuaguggacagauugcugaccapcuugagagcupuucuauuuucccuccucaaacugacuuugcagccacggagag\n", + "cucacucugucaagcaggcuggaaugcaguggcacaaucucagcucaguacagccucaaacuccugg\n", + "ggaaucaggugguaugauuucpuacuuggagucacaagaaagauaaacaugacccaucuuccuagaacuucaguuauagucauagaggagguggugaguuaaguaauuuaacug\n", + "uuuuuuuuuuuuuuuuuuuuugagacaagaucucucacucugucaagcaggcuggaaugcaguggcacaaucucagcucaguacagccucaaacuccugg\n", + "aagacgaccuccgcagagcugauggcauugagauccauucccggapucagcuccugacpuuccugagccagucuuaaccupcaaaggagaugaggagccgagccugaugcauugug\n", + "ggacccpcggcuggcaaaggacgaggcggaggcugaggaaggcagcpagacccaggcugcagcaacaaapcagcgagcgauuggccpcugcaggcgag\n", + "auuugccugaagaccuggauaaucuccauuuuugucauggacuguuaaaacguuugaaguuccaauucug\n", + "auuugccugaagaccuggauaaucuccauuuuugucauggacuguuaaaacguuugaaguuccaauucugguacuuucccuuauuuuauuacauuuuuaag\n", + "cacacuccccgccccaaacggcccaggcguccccauccucccgcggacaccagcgucuccgcccucccccgapcggcgagaggagccccccpcggag\n", + "gcggcgcugcggacccpcggcuggcaaaggacgaggcggaggcugaggaaggcagcpagacccaggcugcagcaacaaapcagcgagcgauuggccpcugcaggcgag\n", + "guaacgcuuuugugaaccacaacuuuaaauaucagccagcugcuccuaucaacacgaguauccccuguuaauuuuuugcauuuuucaag\n", + "cagguaacgcuuuugugaaccacaacuuuaaauaucagccagcugcuccuaucaacacgaguauccccuguuaauuuuuugcauuuuucaag\n", + "aaaaaccagagcaggagccacagaacacacaguucupuuucugcacaaccucuacaagcagguagccgcuaaauauauucuccaaucucuuuuacugagcaca\n", + "agaauuucaagauuguggaguuggacugaaugcugcacaguucaaacagcugcuuauuucggcugugaaggaccuguuupag\n", + "gcuggagugcaauggcacgaucuuggcucaccgcacccuccgccucccagguucaagcgauucuccugccucagccucgcaa\n", + "cauuauuccauaugcagguugaugccgccuuaccuuuggacauccuaaccuaugaagagaagaccuugucagccaucuugagaauauguagcag\n", + "uggucuugucaaauuguggagcucuuugacccuguuaggauccuauaaaggcaaaaaaugugcuuuccpugauucag\n", + "guugaugccgccuuaccuuuggacauccuaaccuaugaagagaagaccuugucagccaucuugagaauauguagcag\n", + "gcuggagugcaauggcacgaucuuggcucaccgcacccuccgccucccagguucaagcgauucuccugccucagccucgcaaguagcupauuacag\n", + "ucucpcccagcuguggcugcugccpagccccaagccuuggcpuccuugcggcgaauaggagucuggucaggcgucaggcuaguccgacgaagagugg\n", + "ucccgcaccaggacucugcgcccgccagcuccgcapcuccaccucccucgccpacuggugacccugcgaccccgcgaccccugcgcguccagacuacugcagcugcg\n", + "ggcccpugcgccgcggcgcupcggcagguugcggcggcgccggagcpucuccaggcuggcgagcgcccag\n", + "agaaggacgcaggcagcaaagaguagucagucccuucuuggcucugcugacacucgagcccacauuccaucaccugcucccaauc\n", + "aaaauguagacagugaugaucugguaacuggcacacuucccaagcucaagagcucaaaagaaugguuggagcccaagccccuuuguuuu\n", + "cauaaggacugcgcupagcaagcugcagagaaagcugcuccccucuggcucugaaaguuucapccugaggccagaacccaaaagcgacccacag\n", + "aguuccccaaagauaacacagcuuugcacaguggauguuuacuugcugguggucuuaucuaagaucaacauuggcagcugugcccggagaggccuccapuccag\n", + "aacacagcuuugcacaguggauguuuacuugcugguggucuuaucuaagaucaacauuggcagcugugcccggagaggccuccapuccag\n", + "guggauguuuacuugcugguggucuuaucuaagaucaacauuggcagcugugcccggagaggccuccapuccag\n", + "aagauaacacagcuuugcacaguggauguuuacuugcugguggucuuaucuaagaucaacauuggcagcugugcccggagaggccuccapuccag\n", + "cauccuagcagugaauggaaacacacauaupagaaacuaaggcucccuacuaaaaacgugcaacaugugacupacaucuu\n", + "guugagcucaagcapapagcugaagguaggaaauuccaacauucugaagucuucagcaaaucuuagcagaucaucuccuccucacaguccugucuuuagagaacapucgauauuucgg\n", + "gaauccuauagaaagacuccaagccucagaaugaguuuggaccagauaaaauaaucuagaguuaaagauggcccacauapagugccagauucacucacaaggaaaugcagaupaucaaagg\n", + "cucuaauaacguuaggcuugguauagaagaugcagagacaugcuaaaauuucucccccaauuauugccaagcagaaacuuggacgaucgac\n", + "gaagacuaccacaggcuccucaccaaguacgcugaggccgagaacaccauugaccagcuacgccucpccaag\n", + "agaacggccuggaggupccapcgcaauggagacapcucccupuuuggaacaaagaauucacaggcagguccccugaaacupucggcaggacggugguggagcccgagagag\n", + "ggcacaggcaggauggccgaugcugacaggaaccagcggugacucupccccuggcagcagcucugucuccugaagaugaaguggcccaggugaagcccaggccagcccca\n", + "gugaugaggaaauggaagccagagaguugaagugacuuapuaaguuacaaggupugcagagcugguau\n", + "aucuguacaapagaucuagaggucuggcccaaapaaacuuuugcugccaccacuuucaaagcuuucguuaaaaaaacaaaapapaagguggagaaacaaccaaaauucug\n", + "ucauuccaaauaaaucuaagugaacuauugauuuugauacaaagcaacagccucugccacacugaagaagugagcuuuaagcagagacuagaagg\n", + "cugcpccccagaucucgucuccuccgccgccuccucacggcagccccagcucgcggcugagaaccagacacaccggcg\n", + "gacggaagcuccuguuuucuugucagccgccagcugapccauucgcagcuucuccaggccaccugcauuccuugucucagagccucccuccugcauccuccaagccagcaguugup\n", + "ugacuggucauagcgugccpcauagcgcuggcapccgccpagccagcccucacucagccaag\n", + "ccaggccaccugcauuccuugucucagagccucccuccugcauccuccaagccagcaguugup\n", + "cgcuucucugaaguagcuuuggaaaguagagaagaaaauccaguuugcuucuuggagaacacuggacagcugaauaa\n", + "uuaucuaaaacaguucaugcugcugaaaaccuccuuccuggcagaugucccucaacccuacuggugccuggcuucugagacaca\n", + "caccagaauuauggaacauuuaucaacagccuaaaauaaagacaacacgaggagaauuugguugcuuauauagauucaagguacaauccugcuggauucugg\n", + "gauuacaggacuguagacaaaagagaaaucaucauggacuguucacuggacaaaauuucauggagaggagaagaccuuuggcgguucauggauguucuauaauaaguuag\n", + "gagauagaauaaaaacagaaaaauggcgacggucacguuguggcgagccuugcugcgucauuagauaauccucaugcaaauagcpaagaacaaaggaapagcccpacccccpcgcag\n", + "gugcagugguuugcagauugucaucaaucuucaccuucacuuaaaagucacguugacucucuacagcaccaagcugccauaagcauucuuuuucuacaggcag\n", + "gauagaauaaaaacagaaaaauggcgacggucacguuguggcgagccuugcugcgucauuagauaauccucaugcaaauagcpaagaacaaaggaapagcccpacccccpcgcag\n", + "cccpccuccucccgcuuucucucuccgcuuccccuggagccuccgaggaguccgcagccgcupcgcccpaag\n", + "cucugcccgccucgcccucgcccpccuccucccgcuuucucucuccgcuuccccuggagccuccgaggaguccgcagccgcupcgcccpaag\n", + "uuacguaaggcgcgagucccgcgcggccggccpcuccgcgacupcpcggaggcggcgccgcccugcaggauccpcuggaagccucucggagugcugccuccagccaag\n", + "guguuuauuugauugcuuuugguggcgaggcgcpcucpcucgucgcgcgccccauggccpagcgcauccgccaaccccpcggag\n", + "gguauaucupaggccggaggacgugucugguuauuacacagaugcacagcuggacgupauccacacagcucagaacaguuggaucuugcucagucucugucagaggaagaucccuug\n", + "aaaagacuacugagagccaguaagacugaaagaauggacaucuucauauccuguuaguuugagugugaauuuguacaguuuucauacagaguggcucuag\n", + "gguuaaggaaaaccuuccagucuggacagugacuggagagcuccaaggaaagccccucgguaacccagccgcuggcacc\n", + "auuacacagaugcacagcuggacgupauccacacagcucagaacaguuggaucuugcucagucucugucagaggaagaucccuug\n", + "paaaacagcuuagaupuucacaaagcuccccpcucagcucugguucugacacccucagacacggccagcugaccccagaagaaag\n", + "gaguuucacucuggcugccuucuccugagagucggagccacagccagagcccugcccaggccgagccggagcugcagcccgagcgcgguggugcccucagccccguccucuuguccuccucagccucg\n", + "aucugccggaggcgcupcaaugaccccpacuccaggccagapucugaagcuguuupaaagcagcpacuccuupaag\n", + "cucuggcugccuucuccugagagucggagccacagccagagcccugcccaggccgagccggagcugcagcccgagcgcgguggugcccucagccccguccucuuguccuccucagccucg\n", + "aaacuuccaauugaagacacugagcugaaccauuccgcccgcccgcccgcccgapcacuccag\n", + "uggcugccuucuccugagagucggagccacagccagagcccugcccaggccgagccggagcugcagcccgagcgcgguggugcccucagccccguccucuuguccuccucagccucg\n", + "acucuggcugccuucuccugagagucggagccacagccagagcccugcccaggccgagccggagcugcagcccgagcgcgguggugcccucagccccguccucuuguccuccucagccucg\n", + "ugauacaaucuggugauucccgagcauacacaucauauuuuauccccauuuugccaaugaggaaacugagacccag\n", + "gaucugguacuguucuggaguggccuguagcagacacugaaccaccagccagcugcauuuguuguccuggaagucauugccaacucugccagucacacupuccccagagaagucaag\n", + "cuggcuguagcuggccaaggaguucucgauuaaagaggaapcagugcucacauuucupcag\n", + "cucacucauuuuucaaaugcgauucccuauggcucuguuucucugucucucucgucucuggucugaguggagaauguggacucugacccuggauc\n", + "gcgguggaugaggapcugcucgcuggcugcggcugaggcucggucaccguguagagaggcccapagagcugcuucacucaaguccugucaagucaaggcagccpauuuguccacauc\n", + "uuucuccacucagcgagccugagagugcggaagucuccggcuggupcauggcccaggagcacu\n", + "gaggcacagaugaguaacgugaauuuguccgucuccgacuucuggagguaaggcggucgucagccuaucucuucugcuggcupcucaaugccgcgg\n", + "gcggcuucccggcgcucguggaaucuucuggagcccuuuucuccacucagcgagccugagagugcggaagucuccggcuggupcauggcccaggagcacu\n", + "gugaauuuguccgucuccgacuucuggagguaaggcggucgucagccuaucucuucugcuggcupcucaaugccgcgg\n", + "auuuauuuuuuuuagaugagguguugcuguguugcccaagcuggacuugaaccccuaggcucaagcaauccuuccaccucagucucccaaguagcapacuacag\n", + "gacgucaucccgcagcgccggaagcggugaggcacagaugaguaacgugaauuuguccgucuccgacuucuggag\n", + "cccccccccucuuacpcgccucuucucuuuuupaacguggcgagcaaaaaaugcuugagccag\n", + "puguuggugcuagcgcggcuucccggcgcucguggaaucuucuggagcccuuuucuccacucagcgagccugagagugcggaagucuccggcug\n", + "guaggagucaaucccaccagcauugacucagucguaauupaaggaccaagaggugaagcugcagccuggccagguucuccac\n", + "gugacgcgaggucacgugacpuupcagccugugccgccgccgccgcuuuguaagaggcacauuggcag\n", + "ggucuugcucuguugcccaggccagaguacaguggcggcucacugcaaccucugccuccuagguucaagugauucucgugccccagccucuggacuagcugagauuacag\n", + "ggcacauuggcagguaacgagcggcggcggcggcagcpucuupuccuccgagagcagcagcg\n", + "pcggccpccugcgcupacggcucupacugcggccggcgccpaccuggapacgcupccgaagcagcaugugacaccgaccag\n", + "aggaacggaagcggaaguggcggcggcgccggccuggccuggccuggcugapaggcggcpcpcgcg\n", + "guagcugagagacgaccuggaaguucugaggcagccuuugucuggcuggaacacgcauuggcagcpagcugucgguaggaccupacaccgcggaagucpaa\n", + "aaagugcucagcccccpcacagcaggacguuupccuucuuucagcapacagcccgauup\n", + "uguguapcugguugcgucacugcgupcaccggaggcccagaggaggaguauuggaugccugacgguguuuacaccccacguccugcuccaaccagcaguuupagag\n", + "uuccguccauucuuccgguggagauggcugcggccguggcpaugcugcgapucuccugccccaggcgg\n", + "ccuggapaucccucucugaagacuuuauaggauacugguupcucugguuupaucccguuggacuccugguguugcuuccpaggcguacaacaggag\n", + "acaccgguccpugccaccucucccugcuupcgccgccgcgcgagcgcuucccuucccccugcaagcgcccggauaaugucugaga\n", + "agucacucaccugagcgcgcacgguccgcgcguccuccgcucgugcguccuccgcccgcccgccugccugccugcccgcccgcucgcucgcccggcccgcgacuc\n", + "gacuuuuugcuccaagugccagaauugauugugguuaggacaucuuacgcugagaaauaaauaaa\n", + "capacagugaauagauaaggaucugaagauucugcuuugguacuuguuggupuuugccuucuguaguuauccucacugauaauuggagauacuuaucaagugauaacucaaugcucag\n", + "gagccupcaguacaggcggcggugcgcacucugcggcggccucugcgccucpcpcpagagagaggccgcggccgccagcgup\n", + "gagugaggcgucguccguacuggaggcuagcucuugucgcggccgcggcgaguuaacaucguuuuuccaaucuguccgcggcugccgccacccaagacagagccaga\n", + "guuuuuccaaucuguccgcggcugccgccacccaagacagagccagaauguucaggaugcugaacagcaguuuugaggaugaccccuucuucuc\n", + "acauacagguggucuuacucugcagcagcugaaacugaagcacaagaagcccuuggaacuaucaucaggacau\n", + "ggaggcuagcucuugucgcggccgcggcgaguuaacaucguuuuuccaaucuguccgcggcugccgccacccaagacagagccaga\n", + "ggccccgcggcgapcaucggcucucgccggcggaugacgagcuguaucagcggacgcgcaucucucugcugcaacgcgaggccgcucaggca\n", + "cuccccapuuccagagauggccaccagccucggcucucccacgucuacacccaucaccuccagccugapcgcaacugagaggaacugagacccaagcagcucaguaaa\n", + "agagcupcagcacagaccupagccagcaaguccacacagucuggcauuuacaagugaaacag\n", + "auuccauuuccccucccacgcugcucacucaaacacacgcuagccucugcugcuugaauucuacauaguuucagucugcugcugacaagaccuccaag\n", + "cucagaggcugagaaugguguggaggagaaaaagaaagccugcaggucgccaacagcccaauccccuaccccaucuguggaggcggacuccccagaccagaagaaaaucauuagccuaug\n", + "gucaaaauccaguuuugauggugccucuuuagcaagugauaagaacgacuguaaaacagaaagcaaaaaugacccuaagacugaaagaaaaaagucuucaucuuccagccag\n", + "cucagaggcugagaaugguguggaggagaaaaagaaagccugcaggucgccaacagcccaauccccuaccccaucuguggaggcggacuccccagaccagaagaaaaucauuagccu\n", + "gcagucucaggacpcgcuuuggagccggccccaggcagcgugugucggucgccuagucuggagaacuaguccucgacucacg\n", + "ucucaggacpcgcuuuggagccggccccaggcagcgugugucggucgccuagucuggagaacuaguccucgacucacg\n", + "agaugaaguuuuaccauguuggccaggcuggucucgaauuccugaccucaagugaucugcccaccuugaccucccaaagugcupauuacag\n", + "acpcgcuuuggagccggccccaggcagcgugugucggucgccuagucuggagaacuaguccucgacucacg\n", + "gucucaggacpcgcuuuggagccggccccaggcagcgugugucggucgccuagucuggagaacuaguccucgacucacg\n", + "gguguuuaagaagaccagcuccaaupaaggugagagaaccuggcccagcupcaaaugagapcaaaapauag\n", + "aagaggcupaggcaggcauagcaaccagagcuggagacugaugugaacuucaucucucuccccag\n", + "gguuggaagccccgcccuuccgaggaguuucccaaaacccugcgcggccggcuuugaccgcgcuaag\n", + "gccccgcucccaagugcgcgcggaccccuagcucccucugaguugcgcupcuuggcugcugcacc\n", + "auauuugauccugaugaccuuuauucapucaauuucuccaagguacugaguacucuuuuagcugucaacaaagcaacagaag\n", + "aucagcuaucagaaagaccauguggacguuccucuucucuuagugcugcuaauacuucucagacaaacccacapagcaguuucuagcacaguuucapcugcaaaggcagucaaagacagug\n", + "ggcagcaacapuugcagguguaaaauaacpaaggcpaugcguggcuaaauugcucugcgugcacaaagaguaggag\n", + "agcccagaguuccagaaugccccuaauuccgaacaccacapugagucuggagcaagucaccupapcuuacaggugccaua\n", + "uuuagcguuaccauggauccuggaggugcccgcgaacacugcuugucgccupcaaccggagaggacgaagcaggaccuagguggcggcggugguaccggcugca\n", + "acugcuugucgccupcaaccggagaggacgaagcaggaccuagguggcggcggugguaccggcugca\n", + "guacugaaauuugaugccuauuuccaagaagauguuccuaugucaacugaggaacaguauaggauccgucag\n", + "ggauccuggaggugcccgcgaacacugcuugucgccupcaaccggagaggacgaagcaggaccuagguggcggcggugguaccggcugca\n", + "uuuuuguagagacagcaucuuguugcccaggcuggucucgaacucupcugaagugauucucccucuucagccucccagaguucupauuauaggcacgagccaccaugcccagccuua\n", + "gcccgccgcggucacagccacccgcpaagcucguggccpaccccgaggcpagcgcpcupccpcupcuacgcgcacpcucggccgccgccccugccg\n", + "gcucccccgagccgagcccgccgcggucacagccacccgcpaagcucguggccpaccccgaggcpagcgcpcupccpcupcuacgcgcacpcucggccgccgccccugccg\n", + "paguuccggauguuuagcguuaccauggauccuggaggugcccgcgaacacugcuugucgccupcaaccggagaggacgaagcaggaccuagguggcggcggugguaccggcugca\n", + "uuuuuguagagacagcaucuuguugcccaggcuggucucgaacucupcugaagugauucucccucuucagccucccagaguucupauuauaggcacgagccacc\n", + "accauggauccuggaggugcccgcgaacacugcuugucgccupcaaccggagaggacgaagcaggaccuagguggcggcggugguaccggcugca\n", + "augacugguguccauauaagaagaggagaagacacagaggaaagacagccaugugaagacacauagacacacacapacagcaucaugugacaauguaggcagag\n", + "gupaguuccggauguuuagcguuaccauggauccuggaggugcccgcgaacacugcuugucgccupcaaccggagaggacgaagcaggaccuagguggcggcggugguaccggcugca\n", + "ccuguuguggcuuuugccaugaggaagagguugacuacuaacacugcauguuugauuuagcaggugaaguuuuuaguauuuaau\n", + "aaguuuuuagaaguaagauaauacacaagaaccucaacccugugupaagaaaaagcuuguauucugguugaucaucuuapagccauuguauauaaag\n", + "acacacucugcuacauugaaacugcucccugaaucuuuuccuccgguaaauugugcuuccupaaacuaap\n", + "uuucagacccaaaguuuacgccuaucagaccuacacagaaaaucgcaucuuuggagaggaauagucagcaucaccuugauugaapagagaccucaaggcc\n", + "aguccpagagccagcgagcgcgcpcggcguagccggccugucupccgccucgupapapcgcccggccgcccggcggcgaccccpccuggccgccacc\n", + "gucaacggcagagacuuauccagagcaacucaugaccaggcuguggaagcuuucaagacagccaaggagcccauaguggugcagguguugagaagaacaccaaggaccaaa\n", + "gaaaucguaggacuuccgaaagcagcggcgguguuugcuucacugcuuggaagugugagugcgcgaag\n", + "guacucugauuggugacpugaggcggcccgaaaucguaggacuuccgaaagcagcggcgguguuugcuucacugcuuggaagugugagugcgcgaag\n", + "gaggcggcccgaaaucguaggacuuccgaaagcagcggcgguguuugcuucacugcuuggaagugugagugcgcgaag\n", + "agugcagapagupacccacagcugcuagccucccuccaaacccuccugccuccaccagacaccag\n", + "aguucapapcgaggccgugccccacauccaggcagcgcaggccgcpccgcuccccuagccaggaagagccgccguccgcaccpaccggagaggaagcggaggucugaapacag\n", + "cugcugcugccucccapcgcugguucacagcacggucccagcapagaggcugagccgguuggacuagaccacccaaggucucagguugcagcucccug\n", + "ggcagaggcpcagaggcggcgagaggcggcgagaggcpcugaggcggcccagcggcggcag\n", + "agucaguuagguaacaggccacpccccpcucaggccacugcacggacccapaacpcugacaguccagcagaggccucagcgaggcggcggcgcugcgcacaaaccugaggaccuaggcgg\n", + "gguaauuccucuccugcaauuacuuuuggauggaaguaugccccuuucucaguagaagaugguaaucuuggaga\n", + "cccgccgcgcccgccgcgcccgccgcgcccgccgcucccgccgcgccugccgcggccgcgaccgcggcagcucagccucccgcc\n", + "gaauccagcugcuaugucacgagaacucaagccacccuguggagaauuccacacggagugcagcugaggccucccaacaacaaccagcagcaauuugcaaaccau\n", + "accaugcggccgaugcccupapagaccacuugcuuaaguccuccaggapcgauggaggagccggcauuccaaccaggcucacggaugccaag\n", + "aggcaaauucaagaucagaagauupaggaggugcuaagagaggucuggagagaugcupacccagaacupccucagugagaucagcaggcugcagcuaaacugugguauccag\n", + "gucccuugagcccaggccacacagcugcacccagcccugcccggcuccucccaggccugcaggaccccupcccuguccuuauuccccagcaccpacagccaaagcucuggucaca\n", + "aaauucaaaagaggcgaacggcccccggcgcggcggcgcggcuccgguggagaggucaaggcap\n", + "ggcugapuccgcgccgccgcccgcccgcuccuucccgcucggccgcggccucapacggauacuccagcgcgcgguuccaaccgaggcccgug\n", + "uugcuauggcaacccaauuuauuagugacugcaaaacuaacuuagcuggcauuguggcaaaucuccauauuuugcug\n", + "auagcuuuccaaugauuagacgaauugauucuuucugugacucaucaguucauuuccuguaaaauucaugucuugcuguugauuugugaauaag\n", + "aaccagagcuuguagaaaccacuuuaaucauauccaggaguuugcaagaaacaggugcuuaacacuaauucaccuccugaacaagaaaa\n", + "aggacugcaguguaggacuuuccugcagaauaccauuugauccuauuaagaauuguccaaauguuggagcauuugauugaaaaauccuucuuagccauuuuaaag\n", + "auuugauccuauuaagaauuguccaaauguuggagcauuugauugaaaaauccuucuuagccauuuuaaag\n", + "gacugcaguguaggacuuuccugcagaauaccauuugauccuauuaagaauuguccaaauguuggagcauuugauugaaaaauccuucuuagccauuuuaaag\n", + "acucauuagugaaccagaacaauaaaccaaacagagaaccaucagauaaupuuagccupaagaauauuaauuacaacuggag\n", + "acapucuugcucuguugcccaggcuggagugcaguggcgccaucacagcugcugcaaccucaaccucccaagcucaagugaaucucccaccucagccucccaaguagcupacuacag\n", + "caagguuuccaagaauuacguugguaggcauucaacuggcauccucuggagguaaccagaugcccagcugcuccuggapacauauggaagugg\n", + "gcucauaggcggaapacuugccuugucucauaugaaacuuuggacuguggacuuuugaguuaacgcugaaaugag\n", + "auuccuggcauggucacagugacuacugugacuuguuugagaggugacuuugaacauuuauuuuacuuucag\n", + "caaguuguccucgaagaagguacaauugcuuuuaaaaauupuuaaaacaggcacagaaguuuacagacaguuuuggaucuuugaugugcaaaauccacaggaagug\n", + "ggcaaacacaaccagagucuucgguguuaauucccuggucuucccaacuagcauucugaaagugcauuaacauuuguggccuugugcucuuucaucggacuucuaaug\n", + "agcaagagcagaggcuuaaggagcuacacupaaggacapcaagcaggccaaggccuggccpcucppapaau\n", + "agacgccuupacagcaagagcagaggcuuaaggagcuacacupaaggacapcaagcaggccaaggccuggccpcucppapaau\n", + "auucacupaacuaacacccggcgccgcucagacaucucuauucccgccucuccgacccggucucacuucgcuccupcagcugcgcggagaacup\n", + "gcucaccgucauggaugcucuaucagaagcaaauggcacauuugcauuaaaccuuuugaaaaagcuapaaaacaacucaaacaacuuauuuuuuucccc\n", + "ccacauucucuggcacagaacuuuggaaacuuupaucacuuacuuaucuuggagauagaauguuuucuaag\n", + "cucgucccuccgaggacccuggaggcpaccucgcgugaggaccagaccucccuccgcgccccgcacugcgcgcgcccucccaggcucpuccccgcgucccaggcccap\n", + "gugacuccgcggccpccpacgcgacpacgcgcupaccggcgucpucgcpacc\n", + "ggccpccpacgcgacpacgcgcupaccggcgucpucgcpaccaugcagcggag\n", + "ccucccugcccuucgcuauccugacgcuggugaacgccccguacaagcgaggauuuuacugcpaugacuccauccgguaccccuaccguccagauaccaucacccacpcuc\n", + "uccgcggccpccpacgcgacpacgcgcupaccggcgucpucgcpaccaugcagcggaggupucuucgugcugcucgacgugcugugcuuacug\n", + "auaucaaagguuuauaaagccaauaucupaaagagaaaaccgugagacuuccagaucuucucuggugaaguguguuuccugcaacgaucacgaac\n", + "gaaccuucauuccagaaguacccucaaagacagagacaccaagaagaaucggaacauacaggcuuug\n", + "aggcuacaucpacucugaagagcagcacucupupcacaggccccacagcapucagccuguggcccugccucuccaucagcucag\n", + "agcggaaggugccccpccgaggcccgugacpcpcpagccccggcaguccpucgccggcgapcc\n", + "uugccuagaccuggagcaguguucucuuaagguacuggagccugaaggaagccccagccugugucugcugaaguua\n", + "guucuuccgccccugccuccgcggcucggaggcgagcggaaggugccccpccgaggcccgugacpcpcpagccccggcaguccpucgccggcgapcc\n", + "guggcupcgugcggcugcuacaugccccacggaccagaaccucccgacgcggccaggccccggcacacccag\n", + "agaugaagcuucacucgcuugccugcugcucacuugcugcuaupcgugauuccuaacaggccacagaccagcagcgguccguggc\n", + "gccaccggucagcccgcgcgapucggcguucauuccugccgcugccgccgccgccgccgaggucccgcaccagcc\n", + "accggucagcccgcgcgapucggcguucauuccugccgcugccgccgccgccgccgaggucccgcaccagcc\n", + "acagaugaagcuucacucgcuugccugcugcucacuugcugcuaupcgugauuccuaacaggccacagaccagcagcgguccguggc\n", + "aaagcucuccccuggupacauucupcacaaccaacaggccpaaaugagaggugauccauacuaaapucaaaguccccgcaccaggcagaggccccaaaacaccgcagcguac\n", + "gacuacpaacucuuccgcagcagacpuccccgcggcccgcucccccapcaagcaagcgaccacapaccggucccpcugg\n", + "gucgucucugccgcggcuuccucggcugccagcucuccggcgagccggaguccuagugccguaccgucaguccccggccgcgcggagccpaugcacuguuccugcugupuccucauc\n", + "guacuacuaguucapuaccuagcaaaaucaggcupauuuccaaaaggaaaaguaaauaaagaagaagcuccucaugauugugcugcuagagag\n", + "ccugagaagccagccaggcugcggcuguuuguggcaggaggcccccacccacagcacuggaccaag\n", + "ucuccaccucccacuagccccucuccgugucuccgcggagacguuaccgugguccagcuggagaccaaaaggugaaa\n", + "agcccuugcgcgccaccgucccuucucucuuccucggcgcugccuacggagguggcagccaucuccuucucg\n", + "cuggcgauuggaagacacucugcgacaguguucagucccupcaggaaagccuccuuccaggauucuuccucaccupccgcuucuuccccaaaaggcauc\n", + "apuuacgacccaucagcccuugcgcgccaccgucccuucucucuuccucggcgcugccuacggagguggcagccaucuccuucucg\n", + "cuugcuccguagcuggcgauuggaagacacucugcgacaguguucagucccupcaggaaagccuccuuccaggauucuuccucaccupccgcuucuuccccaaaaggcauc\n", + "agacccccccggccgcccuccuccuuucuuuguuccuguggcuppuauccccucccuccacaac\n", + "gaauaaaugcuucggccgaaccaaguccugagcucccagcggaggapaccugaucuuuuaag\n", + "pagucggcgcaagauggcggcpapcccagguugcugcucuggccgccgagugapcppcccpcgcgcggcccg\n", + "ucccpcuacgaggcggaagcgaaggcagacgcagucuccgucguugacguuagucgcagucuucgcugcuaacg\n", + "ucaccagcuaaaccgugaggacaaaaaguaaggaaaaauagacacacuccaccaugaccucauggaacuaacaagacugguggaggaggaagacauuaauaagagcaaucacugcaauaaau\n", + "gugcugcaaaguuggugguagcuguggcaguguuuuuacugacauuuuauguuauuucucaaguauuugaaauaaaa\n", + "gucgcggccpaagcgupaggaggcccagcggcgagcuggcuuucuccuggccacuugccp\n", + "auuuucaaacugcucuagcgccggagcccgugccuggacggaaggagcuagupacucgaggccugapcaaugcggcuggaggcggaggcaacggcggcuggagcugccg\n", + "auuugacucacugacccugaupaagauaguguuauucccacagugugguaguacacacupcuuauapacugagccuacucaagg\n", + "gcauucacguaauggaaacuuacaaaguugcucaauaccucucuucauguccccaaagagagcaagcaaguguccccauuauacuucuuacagugaggagccagagcuuccag\n", + "ucucucucuguugcccaagcuggagugcaguggcacagucuuggcucacugcaaccuccaccuccupugcaagcgauucucgugucucagccucucaaguagcupauuacag\n", + "pccppcggagccuugcpcuggagcgaaagaaugcpcugagcgcagaagcggcucgaggcuggaagaggaucuupcgccgccag\n", + "acagucucucucuguugcccaagcuggagugcaguggcacagucuuggcucacugcaaccuccaccuccupugcaagcgauucucgugucucagccucucaaguagcupauuacag\n", + "aucuccgcgaccaggaaacpaaagauggcgacggcuccgcgacguugaggccgcguupcgguucagacucapug\n", + "uagagaupuuucaccguguuggccaggauggucucaaucuccugaccucaugaucugcccgcuuuggccuccaaaagugcuaggauuacacg\n", + "agaupuuucaccguguuggccaggauggucucaaucuccugaccucaugaucugcccgcuuuggccuccaaaagugcuaggauuacacg\n", + "guppuguucaucuccgcgaccaggaaacpaaagauggcgacggcuccgcgacguugaggccgcguupcgguucagacucapug\n", + "aguuccgcuuccgguuccgagauccuguuuguuuucugaaagcuuugugguuucggugagcucucagagccgauuucuagcguccgugccpacagguguccagaggucgacugcugcagac\n", + "agaggccagucaccaagacaggcaucucaaaucggcugauucugcaucuggaaacugccuucaucuugaaagaaaag\n", + "auggaguuuuugcucuguugcccaagcuagagugcaauggugugaucuuggcuuacugcaaccucugccuccc\n", + "agagapaagccccggcggugagagucggcccaaaaagcggcggccguuggagguggcugcggcagcug\n", + "gucagagapaagccccggcggugagagucggcccaaaaagcggcggccguuggagguggcugcggcagcug\n", + "gaggucagagapaagccccggcggugagagucggcccaaaaagcggcggccguuggagguggcugcggcagcug\n", + "gguaccauacucgcuugaaucgucuaccuggagcugcagcucgaugccucagaaapcgaagaaggcugguupaag\n", + "gagaccagcauaaacacuuupacugagaggauaagccauaucauuagugacccucggcagaaaga\n", + "uuuugaacuuugcaguaagaaagcagaaugaaucugauuugcauaugguuuaguucaacaucagaauccugcguugagaaguacuauguugaagccuaaacguauggagcagaag\n", + "aagguuaaaaggcccauuuaccauacaguuuaaauugauguguccaagucaagaaaauaaauauuuag\n", + "aagcaaggcgagcuupuggccccagucgagaugcccuucaccccuugaagaucaccccucuuuuggugguggugguacug\n", + "gauugagapcugapaauuguccucuguggaapacuuucuuuuggcccuaggccccuuccugccccugucgucagcag\n", + "cuucauuuuugugaagguaccguggaaaauauuucauuuuucuucucaccggagcaauuguaaaugcuaugcgguaagaggaguuaccuguggaaaggugguuaagagauuag\n", + "caacgaaguaaacgaggagguugguccaaaggaagaaagaggaagaaaccucuucgagacagcaaugcacccaaauccccccuuacaggauauguucgguuc\n", + "gagugcgugaagugaaggcgauugagapcugapaauuguccucuguggaapacuuucuuuuggcccuaggccccuuccugccccugucgucagcag\n", + "agucucuacaaggaagauaacggacuguaaaauucuauaaagcaaagcuacacaucacuugacaccauacaccaucuugguuacauaaugaag\n", + "agcugugagacgacgagugcgugaagugaaggcgauugagapcugapaauuguccucuguggaapacuuucuuuuggcccuaggccccuuccugccccugucgucagcag\n", + "aaaaaauaacaagcuuuucugaagugagaagcuguucucagccacgaguccugugcaagaucacuaaugauuaccuggcauuucugcgacacaggcagguccucag\n", + "ggcgguagugcgucggcugcugccccpucuggcagaacucpuguuuupcugagacaguggcagcugcggccccgaccccaagugcpaccuccggcgaauaaaggucggccugcgg\n", + "accgcpcaagauggcgguagugcgucggcugcugccccpucuggcagaacucpuguuuupcugagacaguggcagcugcggccccgaccccaagugcpaccuccggcgaauaaag\n", + "cgguagugcgucggcugcugccccpucuggcagaacucpuguuuupcugagacaguggcagcugcggccccgaccccaagugcpaccuccggcgaauaaag\n", + "gcagucagcgagcccacgugcuuguguugacuggacaacuuccugguggaaaaccgcgacucuugcaagupcaaacuugacguuuucgcu\n", + "ucuuugagcggucaapaaagacaagccgacucuucagaucccuguggacacacugccugcucuuccau\n", + "gccupcuguagagacapaaguaccaggaapuggaugacccugacccagcuaaauggaaggcccagcugcgcugugcucucaauaagagcagagaauucaaccug\n", + "acaauucagaggcugcugccugcuuaggagguuguagaaagcucuguagguucucucuguguguccuacaggagucuucaggccagcucccugucgg\n", + "gagaugaaacagaaggaaaggcagaggaggapagagagagagaagagaagaaaaagaaaaaagaacaucaauaaaaagaagucagauuuguucgaaaucuugag\n", + "gagagaugaaacagaaggaaaggcagaggaggapagagagagagaagagaagaaaaagaaaaaagaacaucaauaaaaagaagucagauuuguucgaaaucuugag\n", + "ggagagccaggaagapcgapcagagcauccuupcggagaugccuuuaaaaaaucauccaccgcagcgguagaaacaguuuuguuuggcuuuauuuauacggaaugguuuuucagugaa\n", + "ggcgapcagagcauccuupcggagaugccuuuaaaaaaucauccaccgcagcgguagaaacaguuuuguuuggcuuuauuuauacggaaugguuuuucagugaa\n", + "acucccgcgcagugagguuggcacagccaccgcucuguggcucgcuugguucccuuagucccgagcgcucgcccacugcagauuccuuucccgugcagac\n", + "gcagugagguuggcacagccaccgcucuguggcucgcuugguucccuuagucccgagcgcucgcccacugcagauuccuuucccgugcagac\n", + "gagguuggcacagccaccgcucuguggcucgcuugguucccuuagucccgagcgcucgcccacugcagauuccuuucccgugcagac\n", + "cacgupagaacugcuuacuugcucuuuuguaugcuuccggcuucuuuuuccuccaaacguaggccuucuccgcgcugaaguuuuccccagcagcguaauacu\n", + "gugaggauaupcuggaugguuucuuagccuccucaugaccuguggugcuucagagguccacggaaugaaggauaagauggagaagccaggcuaaggaaggauupauuuccuaaaaca\n", + "auuggaauaauugguggaacaggccuggaugauccagaaauuuuagaaggaagaacugaaaaauauguggauacuccauuuggcaag\n", + "cuccgcacugcucacucccgcgcagugagguuggcacagccaccgcucuguggcucgcuugguucccuuagucccgagcgcucgcccacugcagauuccuuucccgugcagac\n", + "ggcgcaguccgcgcpuucucgcgcggagaapugcgagcggcggcggcggcggaggcugcc\n", + "acccaaagucuucaagccuggaguuccugcuugguucuuccugaggacugagcaccuucuagacuacauccagaucug\n", + "cuucucaaagauggccgaccucacuucccuuacgcaacauggacguuuucagucacuuccugugauuuugagguuauucugauccaggacuacuugcaugaccaaagccaagauggcag\n", + "uuccgccauggagucauaguugcagcugacuccapcuacagcpugcuuacauugccucccagacggugaagaaggugauagagaucaacccauaccugcuaggcacc\n", + "uuucagguuuagcugugccucccagugacuauaaugacaaggaagcuguaaauguauuugaguuaagcuuuugcgagaa\n", + "acccuacagcuupccupcuccucugaccauccucauugagaaaggaaagugaguccagagaaguugaugcuuccuaccuguuggagcggcccagcagu\n", + "uuuuaauuugguuuaaccuuuaguuucagguuuagcugugccucccagugacuauaaugacaaggaagcuguaaauguauuugaguuaagcuuuugcgagaa\n", + "aaugucuuacuacccuaucaguuaauccuauacauugcucaaggcucaacuggaagcuuuucuucu\n", + "agacupucuugcuaugcugccgagguuggucucaaacuccupcucaagcgauccuccuccucccaaagugcupauuacaggcaugagccaccaugcccagccaug\n", + "cuuuuugcacacacacgaauacaaagagccauacgaccuucpuauccuuuuuccauuuuuuuuccuccuuaaucuuguguguguuuucaaauuuuuuaaaaauagagaucuguagcaguguup\n", + "guuuagcugugccucccagugacuauaaugacaaggaagcuguaaauguauuugaguuaagcuuuugcgagaa\n", + "acaccgcpaccaggaggcacgcugguuuuccpccgcuccaucgcgccuuccuccugcgccucgcuucuccgguccagccgccaucuuccuuuccgcacapccgccgagcpcc\n", + "ucauuuauuugcagaagauauuacagauuuccagcggaaagagaaagugcugaaaupuguguucucaaguagccauuuggaggaugaaagaaca\n", + "ugaucauaugacggugguagccauggcgucacagagaacapaccuuccaaguuugaaguuuuacaaggcaggugugauaagug\n", + "uccuuguccugagaaggcaggcuucauugaucaauuugaccccauuucaugauuuauuuuaauaguguaagaggaaaagaagugug\n", + "aagccgguccggaguucuggccgacagcaggcgaggagupuagcagcgccuaugugaaguuag\n", + "gcaacacgupcggugccggucggapcuccuagugcgccagguugupaagugaggcuggcgguggcgacaaccgaggaggapcpacgccguggagcacggcgaccggcugagcguc\n", + "aaaaguaacuuucgaaaaacagugguucuaccuggauaacgucauuggccauaguuauggaacugcauuugaagugaccaguggaggaagucuacagcccaagaagaagapaagagccuacugcag\n", + "gaaauaguucagcaguuaauugaaaauaguacaacauuccgagacaagacagaauuugcccaagauaaauauauuaaaaagaagaaaaaaaa\n", + "auccgaucacauaggacaguaugcaccuuaagauccugaagaaacggcacaaaauguucaagugauguuuagaaauaacuugugag\n", + "aagcauuccuuggaggccaccucaucuggccugcgugcucuagugaggucccgcgcacauguuuucuggaccugaaguugugacuugccuacag\n", + "aucccaaagaagcggugaguagcgguauguggaaggaguuagcgucgapaccaggccpccugugcugcaggapcacaggcgag\n", + "cupccugcaguugccagcuacagaauccagccuaaapaagauaaaugauagaggaagaaggaaccacaguauauaucuaauaaggu\n", + "aaagaagcggugaguagcgguauguggaaggaguuagcgucgapaccaggccpccugugcugcaggapcacaggcgag\n", + "agcagagccupcaggugacpcpcgcpcgucgcagcugapaguaaggaggcucccaggaaccggagcuggaaacccggccgagguccagccagagcccaa\n", + "gcgucccauaucuggacccagaapacuucccugcucggcuggcucucgguuucucugcuuuccuccggagaaauaacagcgucuuccgcgccgcgc\n", + "uaucuggacccagaapacuucccugcucggcuggcucucgguuucucugcuuuccuccggagaaauaacagcgucuuccgcgccgcgc\n", + "gcggccgccgcauucgacccgcgccauggcagaggagagcpugccpapaagccpaaccgucuccauucugaaacuapcpaag\n", + "auccpuccupcgagcpcgccgugcgcgugucccgcggccgagcugcuaauaaaguugcagcgaggagaagcgcagcgacggcgucpagagcgcgccuagccggcucgcga\n", + "aaaggaagcuguugaaguuauugaaguaccuguugcuauauucuaagaaauuaaaauguccagaaaucugccucu\n", + "ugauaggacugcggugcucggccpcagccupcugcugcacugcgaagcuguccaauggcuugaugaauccgugccgccgucgcuuuguguuucaaagauaaggauccgcgcuuaucg\n", + "ccpuccupcgagcpcgccgugcgcgugucccgcggccgagcugcuaauaaaguugcagcgaggagaagcgcagcgacggcgucpagagcgcgccuagccggcucgcga\n", + "aaaupaucucacuauguugcucagacuggacgugauugaacuccupcucaagugagucucccgaauaacupauuacag\n", + "gaccaggcagagccauccccagaugaapcugaacgcugcaggucaccapcacccagcgaucuggcagcuuguguuuuccau\n", + "gcggaggaggaggcggcggcggccgccpcgcugcagupacgcgcgcggcugugagccugcpacaugccccccgcgccggcuccuugcuggcggcc\n", + "auaacauagaucaucaguagaaaacuucuugaaguuguucaagaaaaauuugaaaguagcaaaauagaaaauaaagaauuaacagcagauacagaggacagcauggaa\n", + "guguugucuuaggaaacagaacacagcagugaaaaaacagacaaaauccgcucagauacaacugcagcugaua\n", + "ggaguuccaguggaauuuuugguauuacaugauguugauuuaauaauaucucauguggaaaauaau\n", + "cugcugugcapcapaagcuccaggcaaacagcccagcaaacagcagcacucagcuaaaaggaagacucacagaacacaguugaagaaggaaaguggcg\n", + "gcugugcapcapaagcuccaggcaaacagcccagcaaacagcagcacucagcuaaaaggaagacucacagaacacaguugaagaaggaaaguggcg\n", + "gugcapcapaagcuccaggcaaacagcccagcaaacagcagcacucagcuaaaaggaagacucacagaacacaguugaagaaggaaaguggcg\n", + "agugugcugagcucuccgcgucgccucugucgcccgcgccuggccuaccgcggcacucccggcugcacgcucugcuuggccucgcc\n", + "acuuagaaucggcaaaucauagagagaagcuaaaugcucucagcugcacuauaccaaaucaaagcugagaugaaua\n", + "cacuuagaaucggcaaaucauagagagaagcuaaaugcucucagcugcacuauaccaaaucaaagcugagaugaaua\n", + "agcaguugaacaucagauacccagagugacaucagguuaaaaaaaagccugcaauuuggaucuuuuccugacucggaagcaaggaaaauggacaauugauaaucaaag\n", + "gcuaaaucucuucupauccacugaaugccacuagapucugcucgagagaauuccugauugaaugacaacggcgcuaagaaca\n", + "aucccugcccaagacpucuggagccugacuuccpuguccaugacccuggcggcugcuuccgguccgcc\n", + "gguagaaguggagagagagagacagapagcgagagagagagcaagacagaccgagaaggaaagcacucccagagaugaaauuuuaggaaagcaaa\n", + "cagagcaguugaacaucagauacccagagugacaucagguuaaaaaaaagccugcaauuuggaucuuuuccugacucggaagcaaggaaaauggacaauugauaaucaaag\n", + "gcagugauucuucauugccugcccuccuguccacacuccugccuacugccacccacaapucauc\n", + "ugugacgaccuuaucugaggaaggugcacccuagucaucagaggaacgagucgcugcaggcacugucaggugucgag\n", + "gguggcaggaaaggcuuggaacagcugccggaggugacggagcggcggccccgcccggugcgcuggaggucgaagcuuccag\n", + "gacgaagcagucggcpagcccacggucgcupcggugucuuuaapapcggagccacguguaagcuucaaup\n", + "ggagagcugapagcgucgucapuggacaccaugcgacacccauuucuccuuugcauccugugucuup\n", + "aaggcuuggaacagcugccggaggugacggagcggcggccccgcccggugcgcuggaggucgaagcuuccag\n", + "aggcuuggaacagcugccggaggugacggagcggcggccccgcccggugcgcuggaggucgaagcuuccagguagcggcccgcagagccugacccagg\n", + "agcggcggccccgcccggugcgcuggaggucgaagcuuccagguagcggcccgcagagccugacccagg\n", + "acuccaacgcupugacauugagcucaccagcgccaccguccccggcgaaguucugcgcuggucggcggaguagcaaguggcc\n", + "cuucccacuccaacgcupugacauugagcucaccagcgccaccguccccggcgaaguucugcgcuggucggcggaguagcaaguggccaupagccucagcggucugcgccuggcagcag\n", + "acuccaacgcupugacauugagcucaccagcgccaccguccccggcgaaguucugcgcuggucggcggaguagcaaguggccaupagccucagcggucugcgccuggcagcag\n", + "cuguuuuagguuaugugaaagagauguuuccucaucucuaaggcuuaccagaagcucugauuugaagagaauaaauggauuuugcacaaaaccacaggaaagucccggagcuccauccc\n", + "gcacuuacaacagagugccuuuacacaaaccuacggauuggcagaaaaagauccucauauggucaggucgcuucaaaaaggaagaugaaaucccagagacugucuc\n", + "ggcgccgccugcguccuucccacuccaacgcupugacauugagcucaccagcgccaccguccccggcgaaguucugcgcuggucggcggaguagcaaguggcc\n", + "acauugagcucaccagcgccaccguccccggcgaaguucugcgcuggucggcggaguagcaaguggcc\n", + "gaaguucugcgcuggucggcggaguagcaaguggccaupagccucagcggucugcgccuggcagcaggugagacgccggucpauaupag\n", + "aucacucgagcccaggucccagccaccaccacucacagcgcucggcguucaggaagaggagcagcagcggaggcggcugcuucagcggcpcpcgccagaaag\n", + "gccccgaucgaaaagccupapccgccgaacuacccccggapaggagccaguccgaacccaaggcgccaccgccgcagaagcggagcgaggcagcauucgccucc\n", + "acucgagcccaggucccagccaccaccacucacagcgcucggcguucaggaagaggagcagcagcggaggcggcugcuucagcggcpcpcgccagaaag\n", + "auuacgcgcucuuaagguuucuccgugguguuuuggaaggucccggcacggcuaccgucgccccacgcuaggaaauuuuuuuuuuauuuucaaccuuuguuacauagcacugaggcuacaagauc\n", + "ccagaguuuugugcgaaggaaaccgaupaucggaaccguagcgguugagcugcugcugcuacggauaucugacagaagccuucggugguugucggccua\n", + "gugcgaaggaaaccgaupaucggaaccguagcgguugagcugcugcugcuacggauaucugacagaagccuucggugguugucggccua\n", + "cgaupaucggaaccguagcgguugagcugcugcugcuacggauaucugacagaagccuucggugguugucggccua\n", + "agaguuuugugcgaaggaaaccgaupaucggaaccguagcgguugagcugcugcugcuacggauaucugacagaagccuucggugguugucggccua\n", + "gaupaucggaaccguagcgguugagcugcugcugcuacggauaucugacagaagccuucggugguugucggccua\n", + "caucaggaagugcacaggcguccggcgugcuccucccucccugcagccccpcagcaucucccagaggcuccgcggcccaggcuccuggugugucugcagugcagguggcuccuggaagacccucag\n", + "cccggccucuuuugucccuucccuccucugcgucaggcuucucuggcccggccucccccucccgcucccuccuccuccccpcugg\n", + "accagaguccccaccuuucuggaagcugcapcucuccauccaggauccagaagcauugaap\n", + "gguaacgacuaacaguuuaaaugugagccuuauccgaaggaaugupagugaggaaaagguuggagaccugaaaaaaag\n", + "auuucagcuugucagucuacaapuguggcuuuccucuggaagaaguccaaagcucucaggcugcaaagcucagacuug\n", + "agacuugguauagupagagccugacugagguggcucuagccagucuaauugccguuccuuuagcuaguggcaucuugauuccugcugugucuuaacugaccauugucuuaaauucuagaguggauc\n", + "acagcaccggaagagucgcuagguggcugaagaggapcupcaggaggucaaagaacaga\n", + "aguucacagcugcccuguugcapaggcgguggcccuucuguugcuagaccgagccugupauauaccaaggcagaggagcccauagcc\n", + "acaagccacaggccccuuccccagccucaguucacagcugcccuguugcapaggcgguggcccuucuguugcuagaccgagccugupauauaccaaggcagaggagcccauagcc\n", + "cgcgaucgagcaagcaagcpcgagaggacgcccuccccuggccuccagugcgccgcuucccucgccgccgccccgccagc\n", + "aagcaagcpcgagaggacgcccuccccuggccuccagugcgccgcuucccucgccgccgccccgccagc\n", + "aaagaaacccagguagacagaagcacapaucccuaacgccgaagcgccuccacaaggcagugagugc\n", + "agaggcugcggugaguccgccagccccagcugcuccuccucaagcccccaaggcccuucggcpccccugcugaaagaccggc\n", + "gugaggugccggcggcuggcggccgcggagucuucggcgagaccuaccpcccugucugugccggccgugagcugcggcaggacggcuggag\n", + "uaaaucuuggugccaauaauggaacgaacacuggacacaggacupaagacuggauuucagcuuaggagaag\n", + "aauacuaagaaguuucagcaguggaaugccuacucuucuuauaaccggaguggaaacggaagcauuuugugagapcuggapaag\n", + "acacgcucggcgcucgcggcpcggaagugaggugccggcggcuggcggccgcggagucuucggcgagaccuaccpcccugucugugccggccgugagcugcggcaggacggcuggag\n", + "gagacaaagcuuuuguugauuuccugagugaugaaauuaaggaggaaagaaaaauucagaagcauaaaacccucccuaag\n", + "apccugcaaccgaccucugaggucupacauuuuuccauugauuggcaaccagcpcuaaacccac\n", + "gcuuccggcggcgccucaggucgcpcgccuaggccupuuguccuuugcaucugcacguguucgcagucguuuccgcg\n", + "gcugapacaucugcuuaaagguaucgucugguccuaguguucugupugacaaagcugucacuuuguucaag\n", + "apugugagauggcagacagguuugcaggaaacccucagaaapcuggaggauuuagccacucuguccuccccuuccggcaguccapccuccucccgagcacagcggcgcu\n", + "ucauguggcacaugugauaccaugugagguaucugguguuacuaagucgucacguauuucgaugaag\n", + "gguccacaggcucagaaaagauggaacgagugacuguggagaapuagaacaupccugcccagagcgcgaaggcagauacagaagagcugcccgugaagg\n", + "aguuucagacaagccugcuugccggagcucagcagacaccaggccuuccpcaggccuggcccaccgupccucagagcugcugcupcauucag\n", + "aaccggcucuccauuggcauupaccagagaccccgcaaguggccuguuugccuggacauccaccuguacguccccag\n", + "ggcugcggcgcggcuuccauccucccgcccuccugacgcggccggagcgcagcccugaggcccagg\n", + "cucccgccpccccggaugcacugagcggcugcggcgcggcuuccauccucccgcccuccugacgcggccggagcgcagcccugaggcccagg\n", + "cacugagcggcugcggcgcggcuuccauccucccgcccuccugacgcggccggagcgcagcccugaggcccagg\n", + "aguuguggacgcucguaaguuuucggcaguuuccpagacucpacuccgcgucucgcucucuguguuccaaucgcccggugcgguggugcapucucpcuaguc\n", + "agccgacucacuugcaacuccaccucagcaguggucucucaguccucucaaagcaaggaaagaguacugugugcugagagacc\n", + "auguccccaggccccccagcccaggcccagcauaaaggccguguuppccccccugacccaappcuuc\n", + "acuuugucuccuccuuccuccuuupccgccaccgccaaucagagccagcggauccugguuggagugcgaccgcccgg\n", + "upcucgapcgagcgguggcgguggcpuacggcaggcucgcpcgccpcuucguuacauaaucucggaccggaggagcggcggcac\n", + "ggaugagauuuacugccagaucugcaagcagcucucggagaacuucaaaacaagcagccuggcccpcuggauccugcucagccucugccucggcugcuucccacccucagagagguuc\n", + "gguccuccgccggcuacggcgcugcgucacugguuugcaggcgcuuuccucuuggaaguggcgacugcugcpccugagcgcuggucucacgcgccucpagccagguuggcggcgcg\n", + "acagugguccuccgccggcuacggcgcugcgucacugguuugcaggcgcuuuccucuuggaaguggcgacugcugcpccugagcgcuggucucacgcgccucpagccagguuggcggcgcg\n", + "uauacuuuauaugcugcggcggaggucguaccuccuuggccuggaggaacccagupacugacgcagcuccpugagcuuuggcggcugcgucgagugacaag\n", + "aguggcacacccgguggcauccucccacccpcucuuaucggcggucccagacccugcuugagcgccuccpugucaapccccugaggacacuaaagcucucgaaccccg\n", + "aaaggaaugugaauucuccuccagaacaugcagagacccauggaugaacuguguuucuagauuuuuccuccagcuuuccugaga\n", + "ggcgacaggacagguucpacguccaucuguccauccguccggagagaaauuacagauccgcagccccp\n", + "cucggcacucacugcccpccgcccggacapagcuucgcuggcgcgcuuggccggcgacaggacagguucpacguccaucuguccauccguccggagagaaauuacagauccgcagccccp\n", + "cucgucacugcgcagccaaucggcaggcpaagcacuccggcccgaacgugcpcpcapuggcggccccgcacg\n", + "gcccagaccuucucuuucccuuuccagcagccggagaagugcgacaacaaccaguacuuugauaucuccgcccucucguguguuccuuguggagcuaaccagaggcaagaugcccgag\n", + "gaacuucauguguaugucuaccaggauuucagaugaucucuaauaauggaggaccugcuauuauuuguaaaaagugcccagaaaacaug\n", + "guguuacagaagauggcuggaacugcauuucuugcccuagugacuuaacugccgaaggaaaaugucacugucccauuggccauauuuuag\n", + "uggaaagagacauuaauggaacauuguugucucaagcaacuugugagcucugugauggaaaugaaaacucuuuu\n", + "acaguugugaaauucuugguguacuaugcuggugaucuggccaauguuuucuuuaucaucacagupaacaggucuuuacuggcuuauuuucuucaaa\n", + "aaagguguuacagaagauggcuggaacugcauuucuugcccuagugacuuaacugccgaaggaaaaugucacugucccauuggccauauuuuag\n", + "aaucagcucagcgaagccgccgcagaggcugauppcuggaggcugugaggcuuccagcgucg\n", + "gaacuucauguguaugucuaccaggauuucagaugaucucuaauaauggaggaccugcuauuauuuguaaaaagugcccagaaaac\n", + "gcccugcccucaccuggcuaucccacacaggugagaauaaccagaacucaccuccgguaccaguguucacuuggaaac\n", + "ccugcccucaccuggcuaucccacacaggugagaauaaccagaacucaccuccgguaccaguguucacuuggaaac\n", + "ggcugacuggcupcagaupupugaguucccucuccccagagccaucggccagguaccaaagcucagcuguauggauucccaacaggaggaccugcgcuucccupa\n", + "agaupcugacuggcupcagaupupugaguucccucuccccagagccaucggccagguaccaaagcucagcugu\n", + "upupugaguucccucuccccagagccaucggccagguaccaaagcucagcuguauggauucccaacaggaggaccugcgcuucccupa\n", + "gaauuacaapugaccuuuauuccgcugucuccuuuuugauucccauaacuucuggaccuaucaag\n", + "ugcuaugcaucauuacucaaaugugaauucucauuucaagcuguaaaaaagucaaaaggaugaucugaauuugug\n", + "gacugcuugcauuaaaggacuuccucauccuuuuuuucaugaaacugagcuugcuuaaucagagauggagcaaacugacugcaaacccuaccagccucuaccaaaagucaagcaugaa\n", + "uuccgcgcagaccgagcagacugccgcagcgacucauccuaucgauaagguucaguuagccaagguggaggaupaaaaga\n", + "gcgcagaccgagcagacugccgcagcgacucauccuaucgauaagguucaguuagccaagguggaggaupaaaaga\n", + "uuuucuuucagauauuguuuuguauuuacccaugaagacauuguuuuuuggacucugcaaauaggacauuucaaag\n", + "gucacaccgaccugcaccaucucucgccugccugupuuucugucaacuagucguggapaaggagacucuuuaaagaauaacaucuuauuguggcc\n", + "uugucacaccgaccugcaccaucucucgccugccugupuuucugucaacuagucguggapaaggagacucuuuaaagaauaacaucuuauuguggcc\n", + "gccugccugupuuucugucaacuagucguggapaaggagacucuuuaaagaauaacaucuuauuguggcc\n", + "acuggacccuugucgaaacuccuccupaggaacaagccaagcagaaugccaacucccagcuguccaucuuguucauugaaaaaccucaaggaggaacagugaaaguug\n", + "gugaagauaucaccuucauagccaaagucaaggcugaagaucuucugagaaaacccacuaucaaaugguucaaaggaaaaugg\n", + "ccugccugupuuucugucaacuagucguggapaaggagacucuuuaaagaauaacaucuuauuguggccaugccagaacccacuaagaaagagg\n", + "caauuucaaaguauccccgaaucaaacaugaauguugaagucaacuacccagacugaaguugcuuuuaaaaaaugcuuggacacaaaaacaaauaa\n", + "gcaccaucucucgccugccugupuuucugucaacuagucguggapaaggagacucuuuaaagaauaacaucuuauuguggcc\n", + "aaccuccaaagauucgcauuccaagacaccugaagcaaaccuauauccgcagaguuggagaagcugucaaucugguuauaccuuuccag\n", + "ccgcgcgcacagccagcggccgcgccggcgaugcpccaccccgcgcccgccccagucccggccccggcccccgcpaapcugagcugcccgccgccgcccgg\n", + "guauuaugagacaggaagcaucaagccupuaauuggaggauccaaaccaaaggucgccacacccaaagugguggaaaaaaucgcugaauauaaacgccaaaaucccacc\n", + "ggucauuuapcgapcaaggccggccuggcugccuggcccgcapauccugccaauucacccauuaccacagccuccugugagaugagcgcuccucucacg\n", + "gaaguucccugupaggcuguuuucugapagcugaguguuuacagccacucagcccugcucugcucagcugaagcagaaaacagagaccuuuugcauuacuuugguucaagagcaag\n", + "accuccugcucacauccguaaagcccacugauucuuuuacuacacuuuuuaugagaacaagacauuuucuaggaag\n", + "uuccucuggacuagcaagaauauuuuuuuugucuaacacauuuaaaauuuuuacuuuuaacagaaauuagcagaguacggaaagac\n", + "aaaaauuagccpcaugguagagugugccuacagugccagcuacuupaggcugaagcagaagaaucgcuugaaccug\n", + "ugcuaggcucugucccacaaugcacccgagagcaggagcugaaagccucuaacacccacagaucccucuaugacugcaaugugag\n", + "ugucaagguagauuccapuguggaaguggcuuuguggugccaccucuaaccgcucggaggucaacccccauucuacaccgaaaacuaggccuuggcugcu\n", + "uuucccccuuucuapugaggaugguucuacacagccacccggaguuccuuaguugaaaggugcgcccugcugugacag\n", + "cggagguaaauacuapcggupugupagccpccggcccpacgcpcupagccpcgapcgacgccccgccgcccgag\n", + "cauggacaccacguugcugaaaacaugcuuupacugccacugaauuuaucuuuugcgguuuuaugacaaaguuauuaguaguuucccuuuuuugaauuaguauuuugaaguuaauaucaca\n", + "gucggagguaaauacuapcggupugupagccpccggcccpacgcpcupagccpcgapcgacgccccgccgcccgag\n", + "gugcgguucggaggcpcaggupcpcccagguagcagguuuggcugcgcpccgcgcgucggag\n", + "agcucupagaggagccccagccuupauucccaaguguuuucauucagugaucaggacugaacacagaggacucacc\n", + "agcucupaguggagccccagccuupauucccaaguguuuguauucagugaucaggacugaacacacaggacucacc\n", + "cucccucugcugauaaaaaccagccgagcccagacccugcagcucupagaagagccccagccccagaauucccaggaguuuccauucggugaucagcacugaacacagaggacucacc\n", + "agcucugagagaggagccuuagcccuggauuccaaggccuauccacuuggugaucagcacugagcaccgaggauucacc\n", + "agcccupagagaagccccagcccupauucucagguguuucuauupucaacagcaauaaacaaauuacc\n", + "agcucugagagaggagcccagcccupauuuucagguguuuucauuuggugaucaggacugaacagagagaacucacc\n", + "accupugcgcuccgcugcccgccagcccgccugccgccgcgagccccgcccgccuguccucucgcguccucuucgcgupuccugccuccgcggcpagaagaaaauggagcpp\n", + "acuggccuuaupuuucuagaaggaaaaucacagagguaaagcaucauuucaucacauccugucaagg\n", + "cggcgaccaccccggacggccccuguccccgcuggcpcuucccugucgccguucgcugcgcugccgg\n", + "gcaaucaaaaupacuuccuugapcaggccugucuugcaucuguuucuccaccaccuagccuggaauaua\n", + "cpuccauauggaauauuugcugguapaugccuccagaggacuggccacauuuugccuagauaaagaugcacuuagagaugaauaugaugaucucucagauuugaaugcaguacaa\n", + "agacguauaagcaacaccucggacucucuuuaaaccaguuuuaguucggaguugcuuuccaugauuaacaagguaugupaugagaacagaccaga\n", + "auaaauuuaacacauaugugacccugaaaguacagaaugugaagagcacaacuguagcaguucguggugaucagccuuccupaacaggauuucauguu\n", + "ugagauuagucgccuggaccupucuaaguguggagguauggaacaaaggacugaucupacaccauggupacuguguggauugcgcugaagacuauucgucagucggaugag\n", + "gaapccupaaugguccacauuagaggcagagacguuaaugaaagacgaugagaucuguggaacuagaaacccaacuccucauaaaauuuugcuugauacaagauuugaguugccuuuug\n", + "auaucccagaggaggaagccagauauuggaccuacaaaupagcaaaucaaugccuupagcugacaaugag\n", + "uuuuccugaggagaaugcaucuucaccauuuacccaagccagagcacauuggauccgagcaguuaccaagguucgacuccagcugcaggag\n", + "aupcaupugaaaaucuuuacaagugcugcagacuuuggcaaagccuauaaauucagagcagcccggagaggagaaaggaaaguggaugupuucaggccgcaugaa\n", + "cauuugagacggaguuggcuuaucucucaggaaauagacuuacaguggaugaacaggagaaaucaaucauuuguaguguaucuccaaagcaagagcuuugugccupaugugcaagag\n", + "uucuuucuccuccacugcaaaguuaaaugcgagaagguagaaacccagaggccaugcuggcgcugagagaugagccccacucaccagauucaagaucccaag\n", + "ugcugcagacuuuggcaaagccuauaaauucagagcagcccggagaggagaaaggaaaguggaugupuucaggccgcaugaa\n", + "gcgcauucuaauccguuucacacacggugcugcuaccucguuugcuucgugcgugcgugcgcgcgcag\n", + "ggugcgcauucuaauccguuucacacacggugcugcuaccucguuugcuucgugcgugcgugcgcgcgcag\n", + "gcauucuaauccguuucacacacggugcugcuaccucguuugcuucgugcgugcgugcgcgcgcag\n", + "cggugcgcauucuaauccguuucacacacggugcugcuaccucguuugcuucgugcgugcgugcgcgcgcag\n", + "aagcuaggagccgcgcgagucguagugucgcuguuugcpucuccgcgcpaccpcgcagcpucgcugaggcgapuguc\n", + "gcgcgagucguagugucgcuguuugcpucuccgcgcpaccpcgcagcpucgcugaggcgapuguc\n", + "auaagcuaggagccgcgcgagucguagugucgcuguuugcpucuccgcgcpaccpcgcagcpucgcugaggcgapuguc\n", + "aagcuaggagccgcgcgagucguagugucgcuguuugcpucuccgcgcpaccpcgcagcpucgcugaggcgapugucaugucagacaacgaggacaa\n", + "uuuugauggcgacgacuuugaugauguggaggaggaugaapcuagaugacuuggagaaugccgaagag\n", + "gupcguuggacucuuugcgaggaccccggcggcuggcccpaggcggccgaggcggcggcggcggcggccpcgac\n", + "ppugaapucacugcugaccggaggcagcucugccaggcagugucaucagupcuucacguuugacugacag\n", + "cccaccagcgucaccucccagccccgagcuggaccgcacaccuupacacgguuuuccacuuccuaaggacgagccccagacuggaggagagguccgaggag\n", + "acucggagcccagagccgccgcccaggaapaugcggaaaccccuggcucgguggagcggagaggcaggcp\n", + "gaugcggaaaccccuggcucgguggagcggagaggcaggcpugapcguugccaggcaaapcgagcgccguggcup\n", + "cccagucagcgcgguguugcccgccccgcacucggagcccagagccgccgcccaggaapaugcggaaaccccuggcucgguggagcggagaggcaggcp\n", + "uuaauaugauccucuguugaagcaagaagacaaacuguaugguggagaaagaagupaaggaucugcgcgg\n", + "gagugcgcaagcgcagcgcaccgaguggacauuuuggucuuuguccgcpucaguacggccccupuccacguggcgcgaaaguaggag\n", + "gaagacauaggccaaggagccagacuuccuguguuaacuccuuccucugccacuuuuuaccuupaccucag\n", + "cagugcugccagguugccagauuucuaagaaggaguuugaagaggagaaaaggauuuuugcauguuuagaaaucaagguucag\n", + "uucuggcuuuucuggauucugugcuucaccaauagaggaaucccauggagcauuaauuaguucuugcaauuccagaacc\n", + "cucupuccaaacuaaccacaggucucupuccuuuuccgguguccuuaagguucuuggacucugcaug\n", + "ugcugccagguugccagauuucuaagaaggaguuugaagaggagaaaaggauuuuugcauguuuagaaaucaagguucag\n", + "agaagcuccucucccagccugcgagcauuuccaggcucuuguuucccaucagccucupuccaaacuaaccacaggucucupuccuuuuccgguguccuuaagguucuuggacucugcaug\n", + "puccaaacuaaccacaggucucupuccuuuuccgguguccuuaagguucuuggacucugcaug\n", + "aguaggaagcgccagcccagagccupaaguggccgcagaggcugcucggccccgcugcccgccaggucgupcucccgcuccpcccpccaccggcugu\n", + "cagaaguggaagaaguuuapaaguaaguucagcuuuuaagaggucgcggcgauuccaaggagagucag\n", + "gcgucagccucgaguuugaccagcagcapucggugugucccucugaaucugagaccuaugaggcaggagcuapacagg\n", + "ugguucuggccaapaguucauacccacucaaagauuauauuacgaauuucagaupagcuucucucaaccugcagccaccacaugaguuagcuggccgacuucugugagguucccagugag\n", + "gaaaccucuucuggcauccuuaguaaauggcaguagagucaucupagguaaaagaagauuguaccaugugag\n", + "ggcaucpuuucuggcucgugauuugccggagcuccugcgcuccccuucuccacccccuccggcugugugagaggucagcagapcggucugcpacaaca\n", + "agcaacgucapccapccgcgagguaguuggcagaggccucpuccuccuggaapccuc\n", + "uuauggaggcuagaauucugacagcapugugcagapccaugcucuuuccuaagacucuaag\n", + "gugauggauguggacacacuguacuaggcccugagaguggaacccuuacauccauaaacuacccacagaccuaucccaacagcacuguuugugaaupagauccguguaaag\n", + "gacgcuguggcccggaaguggagcggcugucgcagugcggcuccggcaguggcagcggaggccuguguuugcggccuucggcaagcgacugag\n", + "cuugacgcuguggcccggaaguggagcggcugucgcagugcggcuccggcaguggcagcggaggccuguguuugcggccuucggcaagcgacugag\n", + "ugacgcuguggcccggaaguggagcggcugucgcagugcggcuccggcaguggcagcggaggccuguguuugcggccuucggcaagcgacugag\n", + "gcuguggcccggaaguggagcggcugucgcagugcggcuccggcaguggcagcggaggccuguguuugcggccuucggcaagcgacugag\n", + "aacacgaagaggagcuggaccaggaauuugagcuggagacugacacuuuauuuggaggauuaaagaag\n", + "agagacagapugcagagaaccccagcggcapacugaapaggugauggcupagacpaaag\n", + "gaugcgaccgacuuugaguggagcuucuggauggaaupaagcaguggcugguguggcuucuccuuggccacaugguagugucucaaauggccacacugcuggcaagaaag\n", + "acggcggcapcgugcucggaggacgcgcgcugcgcugcuccuccaaapcagcuccpaaagapuggcgucccpaagcccgcagccgccgccg\n", + "gaggacuggcguuagcccaggugcucuuuuucuacgugaaguacuuggugcucuuuggcgugccugcucugcuc\n", + "gcgccacacuguccugacggugcacacacugcuguguggaggaacagaggaguccagcuggccuucac\n", + "gucccuggauggccgguugcaggugucccaucggaapcucccucaugucaucuacugccgccuguggcgauggccagaccugcacagccaccacgagcuacpcc\n", + "aaaacaagcuucpaguupagagaacuguccacaggacacuupaggcuugcuuugguuguggaggccuccacagcccccggaag\n", + "ggagcggugcgugcggccggagccggagcggauccuggagccggagcggagcggagcggagcggagccpcggagcpccgagcpccgagccagcagccgagcupcgcpcpcggc\n", + "ggagccpcggagcpccgagcpccgagccagcagccgagcupcgcpcpcggc\n", + "aggcagccacuguggccucugcggcuaggccggcucgagacucccpcgcccaggcgcugccgcccgccucgccgccccacgccgaaggaccacgcgcccgccgccgccagccucucagcgcuccc\n", + "gguccgagcpugcaccgcggcggaggaggcagcaucccgcggcgcugacgguccupagagc\n", + "aauuucgguuggccggccacaguccaccgcgcggagauucucagcuuccccaggagcaagaccucugagcccgccaagcgcggccgcacggcccucggcagcg\n", + "aaaagguuaagaaguucuuacaagaguucuaccaggaugaugaacucpaagaagcaguucaaguaupaaccaguug\n", + "gcuuucaccaguucucaggaugcccauapaupugaagccugccuggccuguggugcuucccaguggccgucaucucauuapccccacaguggcauuagg\n", + "gcgcgcgcgcuupcuggagcggacuccgacacccgccupacuugaaguggaggugucgaacccucggcccccuggapacgacgcggugcupccccp\n", + "cuccuggcuucucuucuuuccuccuagagaucagaugucggaacuccagcugapcaugucuuacupcacgcagguguccucucuugagaagaacuguccauaccaugguggugguaag\n", + "cuccuggcuucucuucuuuccuccuagagaucagaugucggaacuccagcugapcaugucuuacupcacgcagguguccucucuugagaagaacuguccauaccaugguggug\n", + "cuaaaaauacuggacauuauauauaaaacauuggaagacugaaagguggagaaaagagugaaccagcupauccuggaacucacagaacaacauaaug\n", + "aagcuggcgcupcggcggcpupaaagcggcgccgccgupccuccuggacgcgucggcggagguggcuucgucccgcggaguccaggcuucag\n", + "auccuuuucuucuaugaaaagauccagaaaagaggcaaagcaagcgagaagucgcpcccagcccacagcagg\n", + "gagucugugaccuucgaggauguggcugugacauuuacccaggaggagupcaguuggacgugacccagapccuuguacguggaggug\n", + "aauuugapucacauacguccaauuaccugccuuacaucacuguagcucuuaaguuucuuaagucagaaacuaacaacug\n", + "acauugugucuauuguaucccuuggcugguguauuuguacaucucucpacgugaaauugacagugaaaagu\n", + "gcugucggagcucagaccagcaggccuacgaccuagaaagugcucaaaaccccacuuccuaaggccuagaaggagcgacgugaag\n", + "gcacaggcucauagccccaagcccggaggagguggcuacauugugucuauuguaucccuuggcugguguauuuguacaucucucpacgugaaauugacagugaaaagu\n", + "cuuuucaguccuugcgcaccpaacaaggucgugaaaaaaaaggucuuggugaggugccgccauuucaucuguccucauucucugcgccuuucgcagagcuuccagcagcggu\n", + "gcaccpaacaaggucgugaaaaaaaaggucuuggugaggugccgccauuucaucuguccucauucucugcgccuuucgcagagcuuccagcagcggu\n", + "cgugaaaaaaaaggucuuggugaggugccgccauuucaucuguccucauucucugcgccuuucgcagagcuuccagcagcggu\n", + "gcacugugcgcpcaccacggcgguuuuucgacgcuggcgguggacgcaggcagcauggaccacgguugcupcggaupagcgucuauggucag\n", + "gcggcggcggcggcggcpcagcggcaaccccggcgccgcggcaaggacucggapcugagacgcggcggcggcggcgcpagcgcpcgcggcggccggagccccpcccgcc\n", + "ggcggcpcagcggcaaccccggcgccgcggcaaggacucggapcugagacgcggcggcggcggcgcpagcgcpcgcggcggccggagccccpcccgcc\n", + "cggcggcggcpcagcggcaaccccggcgccgcggcaaggacucggapcugagacgcggcggcggcggcgcpagcgcpcgcggcggccggagccccpcccgcc\n", + "ggcggcggcggcpcagcggcaaccccggcgccgcggcaaggacucggapcugagacgcggcggcggcggcgcpagcgcpcgcggcggccggagccccpcccgcc\n", + "capaccuggugugacccuccugugagagugagcuucagcaaugcuguaaaaauacuuuauguugccacagacaucugaauugguaaa\n", + "cgagcugauaaaggcgccauuuuggapccgcpagacguggugccgcugcpcucgcucugccgugcgcuaggcuuggupaaggccuguucucgaguccgcgcuuuucgucaccgcc\n", + "gccgcpagacguggugccgcugcpcucgcucugccgugcgcuaggcuuggupaaggccuguucucgaguccgcgcuuuucgucaccgcc\n", + "uugaagcccuuucuaauccugucccagaaauaauaaaacugaggauuaaagaagcaaagcaaucugccucag\n", + "guuccgauuucupucuuuugcauaaguaacugaggauuuuauguaaaauggcuaaauccaggagaaucaggagcguuggaaaacgcugaccacaucuguggaugugaaaauuga\n", + "gcucagauuauugcuacucuguauucagaucuucaugugucucuucuaagcugaauaaagcuguuuuggaacugucagguaccucaaagc\n", + "gcacuuccupacgcugagapagacgcuccaagaggcuccucagugupcgaguaaaaugcccugcgugugagaagcag\n", + "gcucagauuauugcuacucuguauucagaucuucaugugucucuucuaagcugaauaaagcuguuuuggaacugucagguaccucaaagcguaa\n", + "caauggugguuucauucagagucuaguagagaaccucaugcacaaaugaggaaaaguapuguaug\n", + "aacaacccugcaagguuggcacuguuauuuuuuccauuucacagaugaagaaaacgaggcacapaaguucugaaucuggcccaaggucagugagcua\n", + "paacgcacuuccupacgcugagapagacgcuccaagaggcuccucagugupcgaguaaaaugcccugcgugugagaagcag\n", + "gguguaccucgcupaacgcacuuccupacgcugagapagacgcuccaagaggcuccucagugupcgaguaaaaugcccugcgugugagaagcag\n", + "gcgaugguaguucuggaggccucgcuccpccgacccgaggccacagugccuccgcgguagaccggacuupugacpcuccpcucccgag\n", + "cggcggcuaccpaagucgcugaagacagagcgaugguaguucuggaggccucgcuccpccgacccgaggccacagugccuccgcgguagaccggacuupugacpcuccpcucccgag\n", + "aagcccguuacuucucuaugcguuucugagauguuapacagccaagcaggaagaaacgcaggacuaugaagcagccacaccaggacuag\n", + "aaauguagucacugucccggaaccupcagcggagucccgugcgcccuguggugacagcucaggag\n", + "ucupaapcguugguccgucgcucgcgcagccuccupaguuguagucgcgauccugagguaacgg\n", + "puccagauuuuauggaaaugagcucaagaaagaaaagcaagucaaccaacgaauugaaaauaugaugcaacaaaaagcucaaaucaccagccaacagcuaagaaaagcacaauuacag\n", + "auuaacaucaaauuuuaacauuauaaaagcaauucuacagaggaacauuuacauuaugcuacaguaucuucaguuguaccuuccuguucagcauaaacaucauaugccaaagag\n", + "ugucuucauuggcugcucuggcauggagcugauaucacacacguaacaacgagagguuggacagcaucucacauagcugcaaucapucaggaugcuuguguacag\n", + "uuuccuguggupuucacacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "gaggaagugcucucgguguauuuccuguggupuucacacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "ugugaaggugaaggaggaagcagaugccuguucauauggaaacaaagaccuggcugugaagapaggcggacaccaaaguccugacacuupcpacagaauugaucu\n", + "acacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "guggupuucacacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "guauuuccuguggupuucacacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "guucacacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "gcucucgguguauuuccuguggupuucacacgcagcuagacacagcuaacuugagucuuggagcuccuagapaagcuucuggaaaggaaggcucuucaggaccucuuaggagccag\n", + "ggaugugagugucucucagaupaguaucuuucuaagaaapuacagagcauggaauucuuaggcuacaggcaggcagcgucucagg\n", + "aauugugcgcucacagcgcuggcgcgagcccacgaagagguacgauuccggagaaucgcgaggcagagcpagcgcgcagccag\n", + "guggaaacuaauucuaagccagacugcuggagaucacccuguucuaguguguggaggcuuccaccaggag\n", + "acapucucucucugucacccagacuggagugcaauggcpaucucagcucacugcaaccuccaccucucpuucaagcgauucuccugccucagccucccuaguagcuaugauuacag\n", + "ggauuuagupuggccgugucccagagcapcaggcggugcccauggaagguggcapcgcuuugugu\n", + "gugcuggagaggccgcugcgagcggaaggccuccuccauaaccgaguccgaaapcagaaucuaup\n", + "ucuggagugcaauggcacgaucucggcucacugcaaccuccaccucccagguucaagcgauucuccugccucagccucccaaguagcupauuacag\n", + "agaugucagcauguuuuuguucagagaaggaaagcguguuugccugcacguugagcuguagagacagcucaggagapcuucaccauuucugcgugaggccgugg\n", + "gagagauggacagauuauuacugcugccuuaaacucupuggaaaacagagcgaapaguguccgguugaucccaguuugucaggcaggccacu\n", + "acagguucucacuauguugcccacgcuggucucaaauuccuuggcucaagugauccucccaucuuggccuccaaaagugccpauuacaagcaugagcaacugugccuggcccugaaaag\n", + "gcgcucacagcgcuggcgcgagcccacgaagagguacgauuccggagaaucgcgaggcagagcpagcgcgcagccag\n", + "auaguuuaaacuaauugugcgcucacagcgcuggcgcgagcccacgaagagguacgauuccggagaaucgcgaggcagagcpagcgcgcagccag\n", + "gugcggccupcaccccugcpugcucaggccuaaaapugcuggagaggccgcugcgagcggaaggccuccuccauaaccgaguccgaaapcagaaucuaup\n", + "aaacagccauaucucuaaaggauaaaguacucccaggaaggcuuugagccuuggcagaaaaggcupauugaagcuucapagagccagag\n", + "auaucucuaaaggauaaaguacucccaggaaggcuuugagccuuggcagaaaaggcupauugaagcuucapagagccagaggugaggcuggagupagaucaccugaggcag\n", + "gcgucggcccugccgagccggccggccggccuggcuccccuccccggccccgacpcpcggacugcccugaggaggcpapapcupccggccggcpcpcgacg\n", + "acugccgucgaccccagcguuggaccgagaupagccggccccgagccgupcpcpcguccpaccucggagcacgugcgcug\n", + "augccagaagupuggagaacuguaggagagcagacuuagaagauaaaacaccugaucagcuaaauaaacauuaucgauuaugugccaaacauuuugagaccucu\n", + "gcgcgucggcccugccgagccggccggccggccuggcuccccuccccggccccgacpcpcggacugcccugaggaggcpapapcupccggccggcpcpcgacg\n", + "aaaggcpccapccagacuggucupccccagucgapcugcaggugguaggcugcgaccccuuccucccacagccccuucccgccccucgccpcauccgccgacag\n", + "acuccagccupacagagcgagacuccaucucaaaaaaaaaaaaaagaauugacugaguuagaauuuagagaguaaguuaaucauugugaaagaugcgcaccaccaaa\n", + "agucgapcugcaggugguaggcugcgaccccuuccucccacagccccuucccgccccucgccpcauccgccgacag\n", + "gapcugcaggugguaggcugcgaccccuuccucccacagccccuucccgccccucgccpcauccgccgacag\n", + "gcuggagugcaauggcaugaucucagcucaccggaaccuccgccucccagauucaagcgauucuccugccucagcccccugaguagcupauuacag\n", + "guuuaugagaaacaguguguuucagagaggcuguaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "guacuucggccuucaapcuccuuuauugagaaucaaugucuucuccuagguaauugaucacccuagacccapacacccaauucaucguaaucauc\n", + "aauuccuacuuccugaaacugaagccguuuaugagaaacaguguguuucagagaggcuguaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "guaauugaucacccuagacccapacacccaauucaucguaaucaucaugaauaaucaaaaagugguagcugugcuacugcaagagugcaagcaagugcuggaucagcucuuguuggaagcgccag\n", + "uuuaugagaaacaguguguuucagagaggcuguaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "aggcuguaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "uaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "acaguguguuucagagaggcuguaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "aguguguuucagagaggcuguaccagaauuaacucugcucagaguuagauuugcuggucuuaaaguacuuuuccucuuuaagauaaaa\n", + "aacacagcccacuuggaucaguuugaacgaaucaagacccucggcacpcuccuucpcpug\n", + "gcgugagucacugccpcucggcgugagucgcugcpcugacpuggcagugcggcpuuacggccuggucag\n", + "gagucacugccpcucggcgugagucgcugcpcugacpuggcagugcggcpuuacggccuggucag\n", + "gaccguauccuugaugagcuugacaaagacgauaguacccaugagucucugucucaagaaucagagucggaagaagaupauucauguagauucacaaaaggcucuuguuuuaaaagaaaag\n", + "gcccauuuugcuggccugaggcugaagagapuugauaggaugaauggcaggauaaaaucuuccuuccuugaaaccacauagcuucugacaagcaaag\n", + "caggaagucauuaugcaacuuacacauauucaucagauuuccucugacuuacccggacauguacaupa\n", + "agcugacacaaccaagacgagucucagugucuapaagcuupuucugcuccuuuuacuucaggcgaaccugaacu\n", + "uuaaugcaauuuugaagcaugcccugaauagauucagucauuaucaagucaaacuaaaaacggugaaagguugcgacuauuaccaaauag\n", + "aaccaauugcaccacgaccggauggaagagcccagcugacacaaccaagacgagucucagugucuapaagcuupuucugcuccuuuuacuucaggcgaaccugaacu\n", + "caguuaaugcaauuuugaagcaugcccugaauagauucagucauuaucaagucaaacuaaaaacggugaaagguugcgacuauuaccaaauag\n", + "gaaaaaucugaagacauaagaacuacacaugaggaauaugucauuuagcacuuucacuuuuugaucuccacagaagaca\n", + "cugucucuaacacaccaagaugagacugguccuaauuuuuccucugcgaauaugguuuucugauuaacuacuaguuaugucuaugccaaaaaaagaaac\n", + "aacacaccaagaugagacugguccuaauuuuuccucugcgaauaugguuuucugauuaacuacuaguuaugucuaugccaaaaaaagaaac\n", + "gagacugguccuaauuuuuccucugcgaauaugguuuucugauuaacuacuaguuaugucuaugccaaaaaaagaaac\n", + "auagcauuauuuugugaccugucucuaacacaccaagaugagacugguccuaauuuuuccucugcgaauaugguuuucugauuaacuacuaguuaugucuaugccaaaaaaagaaac\n", + "ugagacugguccuaauuuuuccucugcgaauaugguuuucugauuaacuacuaguuaugucuaugccaaaaaaagaaac\n", + "aggugagcggcpcpauggcggagcaaupagcuggacgaggaaggcauucgccgccupcgcugacgcuggagcagccgg\n", + "ggaucuuaugcuggcaaaauccauuccauuggugaugccuucagaaauuuuaaaaaucuccgauccuuagauuuaucaaggaauuugaucacuagccuuaag\n", + "augaccgaacuguacgugaaggugagagaaaagcugccaagcugcauuuuagucaguupcaacagugaaaauuuucuuuuagagguggaaaaaag\n", + "agaagcuguggaaagaaaacugaaguggaaggcpaaccugagauagaggcgapaaccacagagaagcg\n", + "aacugguggagucucuuucauugcapaucuuaugcuggcaaaauccauuccauuggugaugccuucagaaauuuuaaaaaucuccgauccuuagauuuaucaaggaauuugaucacuagccuuaag\n", + "agcacagcagcapaagaggacagugaggcupaugcagccuccaugcagccugucgcuuucuccacaggagcucuggccupccagacugccgagucacccugauucaggaguagg\n", + "cgucucccuucucuccuggacagaaggccguguccupacuucucugauggcgagaggcugcggcuguaccag\n", + "gugagucccgcggagccgcgcgcgcccccggcupccgagccgcuggccgacgagcggagccucaggagccggcpacgccaugcgagccag\n", + "cgcaguuggcugguguuuguuugcacaaggauucuuugguaacaaucugcagucgguuucuggcggaaugugaggugaagucacgacugacuuucpauggag\n", + "gguaucucccagagccccagcugguguggccaggccccaggaguaggaupcucccccuacgapccgguggcagccagaacugauacagccccccuggucupccaggacgccag\n", + "gagcuagguuucguuuccucggcggccucggagcgcpugcagcaguugugucccgaccccupagcgcc\n", + "cuucapacugcuccucucgagcuagguuucguuuccucggcggccucggagcgcpugcagcaguugugucccgaccccupagcgcc\n", + "gcugaugcugccgugcgguacuugucauggagcuggcacugcggcgcucucccgucccgcggugguugcugcugcugccgcugcugcupccugaacgcag\n", + "ggcgguccaggcgguucuagcacuggauuuggaaacuuugaggaaauupccccuugacagugaucucaaaccacggaaaaccaccugg\n", + "cuccaggcugccagucuccuauuuguggauaaucccgupcacupuucaguuaugugaaugguaguggugccuaugccaaggaccuggcu\n", + "cucaguugcuaaaccugagguucuagccaaagaggagcuuccuccucuucucugaacuugacuccuguagcuugcaacaaguagcu\n", + "uccggaaggugcugcacagcuguggcggcpuacugcguuagugauuagaguuucuucccugccggaggupauacacgguagcauc\n", + "ggaaggugcugcacagcuguggcggcpuacugcguuagugauuagaguuucuucccugccggaggupauacacgguagcauc\n", + "aaggugcugcacagcuguggcggcpuacugcguuagugauuagaguuucuucccugccggaggupauacacgguagcauc\n", + "aauuccggaaggugcugcacagcuguggcggcpuacugcguuagugauuagaguuucuucccugccggaggupauacacgguagcauc\n", + "ggaugguuucuuggagcuuccacaaacuuaaaaccaugaaacaucuauuauugcuacuauuguguguuuuucuaguuaagucccaaggugucaacgacaaugaggag\n", + "gagacgagaaccapacgaccagcaaguaccaaggucugcggcaggaggagaccggcucacaggagcagcagcauuggaagaggcacccagcagccucccag\n", + "pauuucagucuccacauaguuuuggagccggacuuuugaagaaugauucgugaauccggaaupugacagcgucaucacggcauuuuauug\n", + "agucucggaggcggcgccgcapauugapuugacugagcguugcgagccuuagcuuucucccgaacgccagcgcugaggacacg\n", + "ggauugapuugacugagcguugcgagccuuagcuuucucccgaacgccagcgcugaggacacg\n", + "gcggcgccgcapauugapuugacugagcguugcgagccuuagcuuucucccgaacgccagcgcugaggacacg\n", + "cucccuggcuuccuucauucaguuauauguucaugaaugaaugaaugaauguauauucugaguaaccaagagugccaguuuuacugcucuauucauguauucgcacuaaacugcacgauuuucaaag\n", + "agcugcpcggcuccagcugcccccagaugupcupcggcucgcpaacuuucgcgccggcugcgagugcpccccggcugcaguccggcugcc\n", + "agaucupaggugagauauuuugguccccaggagaacuggcucaggucugcaaguucccauccp\n", + "gaaaccucucugaggucuggucagauuccaacccuggacagcagugaacacaaccuuuccccugagccacuggaauuggacaga\n", + "aacaacccuugaugcuguugcagaaaucauagguugugacacccacagcauucucucaaccaucuacacauuccuccaaga\n", + "ggccppccupcupcccgcgccgccccccgcgcuccgcccccgcugagccugagcccgacccpcgccucccgccaggcacc\n", + "guuccuccugguuuucuccugccucgugcugucuguguuuuccaccaucaaggaguaugagaagagcucggapcccucuacauccug\n", + "gaaaucgugacuaucgugguguuuggcguggaguacuucgugcggaucupccgcaggcugcugcugccgguaccguggcuggapcggcucaaguuugcccggaaaccguucugugugauug\n", + "guucaagcgcugauucupacacuccaaaguucaaaagucuguucuguagcacugagacacaugcagcaagagaaguagaagcaaaccagacag\n", + "caaagugcagauguaggagcugcugaggagcaguucuuaguuuuggugccaucaaccaggccaguacuuccuaaa\n", + "acugcgcgugcgccucaccgcgcuggcaccccggccuggcagccuuupaccugaaccagcugcgccugcgcag\n", + "cucgacuuucucaggauacugucccucucccacagaggagcugaaggaguaggacagaagaacugucaaauucuggaauccuuaaagcc\n", + "apcugcggcgccuuugugagcgcggccgccggccaggaucgagcccuggcccpcccuggcccagccccggccuccaaggaccgcgccgaaggaggugcccacuggapaggaggcg\n", + "gugagcgcggccgccggccaggaucgagcccuggcccpcccuggcccagccccggccuccaaggaccgcgccgaaggag\n", + "capcuaugugaccuuugaggauguggcugucuacuucucccaggaggaauggagauugcuugaugacgcucagaggcuccucuaccgcaaugug\n", + "cucuccugccacagcuccucacccccugaaaauguucgccugcuccaaguuugucuccacucccuccuug\n", + "uuucccucuuguugcccaggcuggaguacaauggcgcaaucuuggcucaccguagccucugccuccuggauucaagcaauucuccugccucagccuccugaguagcupauuacag\n", + "gcucucccaccuccaagcaccaugaacugagucccucucugcccaccuccaaguuguuccucucucugcacccag\n", + "aguccaguaagaagccagcapcuggugcupcuucuucuccugaapcugcaagapaaggcuuagcc\n", + "agacaaaacgaucgcgguuaaagcuugcggcucagagcccaccuggccgcgcugcupaaacggacggagcggcgcuucaaucagag\n", + "acaggagcagcacugccggcpcpugccapacuuggagguggapacgcggcgguacucuggcgu\n", + "ggcgcgguacaggagcagcacugccggcpcpugccapacuuggagguggapacgcggcgguacucuggcgu\n", + "gcgguacaggagcagcacugccggcpcpugccapacuuggagguggapacgcggcgguacucuggcgu\n", + "aggaucccaaggcccaacuccccgaaccacucapuccuguggacagcucaccuagcggcaauggcugcag\n", + "capagagagaacuggccapuauaaaaapcccacaagagaccggcucuaggaucccaaggcccaacuccccgaaccacucapuccuguggacagcucaccuagcggca\n", + "ucccpucacgugacacggapccgaauucugcuggaggcagcgccauauccuggaggugaag\n", + "accuagagagcggcgcgugcgcagcpagucgaagcggagaucccpucgcgcgagagccgcaagcggaguuggupcgcu\n", + "gcagcaagaaccccacggaapcgugagcccugcagacagcugugcggcaccucpcupcuccuguuaggaggaagugccugcacccaggcagcg\n", + "gcucagaggcagcugcuccaugcagaacugaagcugguucugcagcagaaapagaggacacaggagccupugcaggugccucccagcaacgcc\n", + "uuuggagacccugacacacccaccuucucaccupcucugcguaucccccagccuugapaag\n", + "gccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "gcagucuagccguagugcgccugcgcgcggcuaggapccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "agccguagugcgccugcgcgcggcuaggapccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "cugcacuccagucuuggugacagagugagacaccaucucaaaaaacaaacaaauuuccaacugacaaaccaaugcugugcaaccuaagcag\n", + "aggapccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "agacupccuugcuauguugccaaggcuagucuggaacuccupcucaagcaguccucucaccucagccucccaaagugcugagauuacag\n", + "gucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "ggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "cggcuaggapccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "aacaccccacacagugcccacuuuuguucugccaguuuggagacccugacacacccaccuucucaccupcucugcguaucccccagccuugapaag\n", + "cugcgcgcggcuaggapccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "agacagaagcupcccaccggagguagcugcagacgccugagagcgaggccgaggccccucap\n", + "pccgucaggcpauacagccuggaaggugcgugupcupucucggagupagacguggagugcag\n", + "cacauauguauccacagcgccuagaacacugccuguaacguggaagguguucgaucuauagaguuuugucgaaugaaugaaugaagccgacuagugcacapagugcagcggcgcg\n", + "cgccuagaacacugccuguaacguggaagguguucgaucuauagaguuuugucgaaugaaugaaugaagccgacuagugcacapagugcagcggcgcg\n", + "auccgcgccugcgcucaaccccgccuacaccugcuccguggccuccccggaggcgaugagccaaccccgguagcuccagaggcgugguccccucgccuucgccggucaacaugacucagcauccucg\n", + "gcuugcugcgcgcugccggcgcuccuuccuccucggcucgcgucucacucaguguaccuucuagucccgcc\n", + "aaagaaggaggagucagapagucagugguuacuauupcuagagucaucugaggaaucacagg\n", + "agucccucugccuucacucccauggccaccugugcuccapccugccugaccccuguccagcggcccugaaguaag\n", + "acugugcccuguccacggugccuccugcauguccugcugcccugagcugucccgagcuaggugacagcguaccacgcugccacc\n", + "cugugcugacuccuuaguugcugagaugagcuuguaaaaagcagcucuguugaucccagcagcggccapccuccgcugcuucucggcupagacccgag\n", + "aguccgaaauugaaguucagaggaagaauugccuuccaccgcaucuuaucagacccuaupugccagg\n", + "aaugugcgcaggcgcccugcugugagcccgccuccuucucugcccugcucuugcgcucucgcucucucagaguucgucucuggcucuuu\n", + "gcaaguuugcpacpagcgcaggccgcagcgugcgcpccpcuggaccuuucpcgcggcpcagaucgagccuggc\n", + "uggucucagaaggacguccaccuupcuguugugaggauuaaaugaauuaauccacgagaagcuccuagaauggugccugguacugu\n", + "aaacacaaggaaapaaccagcgcagcguggcgaupcpuagagccccgccggagaggcupcggcugccggugacag\n", + "acugugcccuguccacggugccuccugcauguccugcugcccugagcugucccgagcuaggugacagcguaccacgcugccaccaugaaugag\n", + "gcugcaaguuugcpacpagcgcaggccgcagcgugcgcpccpcuggaccuuucpcgcggcpcagaucgagccuggc\n", + "uuuuccacaguaguugaaccauuuugcaccucccaccaauaaugaguaapuucugguuccucuacauccgagccagcaguuggccuugucaguuuuuaaaauucgagccaucccag\n", + "acuucucupcgccaccguagcucccgaccugcuguccgcaaauaaccccaggcupaaaggcaaaggcgccuuggucucuguggacccuggccaggccccaggcuccag\n", + "agcucuggcuucupcuccgaggapupacggupacggupacaucaggcugccccgcaguaccapagcgacugaagugcccaugccgcuugcuccggagaag\n", + "agacgcugcgcpcpugcggagugugcugcacccggapagugcgugcgcgcagcucugcpucccpcuguccccgcgcuguccccgcguggagcgugupuuugg\n", + "gacugcgagaacuacaucacucuccuggagaggcggagugapcugcuggccuguggcaccaacgcccggcaccccagcugcuggaaccug\n", + "auaguucacucacuuucaaagccagcugaaggaaagaggaagugcuagagagagcccccuucagugugcuucugacuuuuacggacuuggcuuguuagaaggcugaaag\n", + "gugacggagcggcggugcgcgcggcapcccggaguaucccgcuuucuuuggaggaaaccaccgcaucagaucugcgcugcggcagaggcag\n", + "ccgcpacpugapcgcupcccupcagcgcpcucgaugugugucagccaaguagcuggucccacuggagcg\n", + "aggucucuuuggaagcaauaaugaugacuauaacaagaacuuaucuugcuuugcaagauucuuccgccgucagaguuucugauuuauuuucupuuccauguaugccag\n", + "guuccuuccgcpacpugapcgcupcccupcagcgcpcucgaugugugucagccaaguagcuggucccacuggagcg\n", + "ggaugaagaaacugaggccuagagagcuguccaucacaguaugaguagagagagaaccccagauucuaguucuggccuccugaug\n", + "gcggcagugcggccpuuccuuccgcpacpugapcgcupcccupcagcgcpcucgaugugugucagccaaguagcuggucccacuggagcg\n", + "agagugaguguuuacaccggcggcagugcggccpuuccuuccgcpacpugapcgcupcccupcagcgcpcucgaugugugucagccaaguagcuggucccacuggagcg\n", + "uccgguuuccggcgagapccagagugaguguuuacaccggcggcagugcggccpuuccuuccgcpacgg\n", + "uuucuucaaggaaaguccaugaagugccugccauucacagacuucuugagcagguggccuccugguuggagauuuaggaggcuucccuagapc\n", + "gagcgcaccpccugccgaggagcgcgcgcccggccpcucggcgccgguuucccgaaccupcggccgucpcagcccccucguccgaccauggcgacugaca\n", + "gaggagcgcgcgcccggccpcucggcgccgguuucccgaaccupcggccgucpcagcccccucguccgacc\n", + "ggugaaguacggaaugccggaapccpcucaaagcuccgccucuggcgcgaccgacgacuggagcgcapcapuagaggcucguagauggaacugguagucagcuggagagcagc\n", + "ggcgacggcggcugagugagaaccuuggcggcuguggaggcugccgcggcugcgaaggaggcggcggcgguggcggaggaagaggaguggcggcagcggcggcpacccgugcp\n", + "acggcgacggcggcugagugagaaccuuggcggcuguggaggcugccgcggcugcgaaggaggcggcggcgguggcggaggaagaggaguggcggcagcggcggcpacccgugcp\n", + "guugguugcggcpcaccggccgacauggcggcagcgguggcggcugcgcuggcgcggcuuuuggcggccuuucugcuccucgcggcccag\n", + "uagagacgagguuucaccauguuggucaggcuggucucgaacuucagaccucaggugauccaccugcuucggccacccaaagugcupaugacaggcgugagccaccgugcccggccccgag\n", + "ggaagaagugaaugaaaaacuucgagauacagcagacpaccuuuuugguacgagaugcgucuacuaaa\n", + "guuucagugcagccccuuauagguuuuaaaaugaauuccaagacaccauuacaaagaaagccggacucuuuucuuauaacugagcucagccaaggaaacucuugcacaa\n", + "acuugaauggauaugaauugaacuccaguuuuucacuggugucuuuuguuaaucgagauccuucccugg\n", + "cacugccuccuaaaccaccaaaaccuacuacuguagccaacaacgguaugaauaacaauauguccuuacaag\n", + "augaauuccaagacaccauuacaaagaaagccggacucuuuucuuauaacugagcucagccaaggaaacucuugcacaa\n", + "cuuugacucucccggaucuugcagagcaguuugccccuccugacauugccccgccucuucuuaucaagcucguggaagccauugaaaagaaag\n", + "gucuggaauguucaacucuauacagaacacagagcuccagcaaccuggcagaauuacgacagcuucuugauugug\n", + "gugaaguggcacugccuaagaacagagugugaaggcacucuaucuauuaagcacaacucuaagaauucuugccuuaaacacaauaagaaaacaaugccauuuu\n", + "agugcupagccguggcagaggcaagagcaguggaacugacccaggccaguggagccapccuccpugugccggacccgaagcagg\n", + "gcagaggccugcpaagccaagauggcgcauapuucuccaggcugcaguuggcgccuuaucaguaucuaagcggaguguuuuggaaggaguuaapcuguggcaaacgcccucuccgccguc\n", + "gcaguggcgcaaucucggcucacugcaaccuccgccuccupuucaagcuguucuccggccucagucucccgaauaucupauuacag\n", + "caagauggcgcauapuucuccaggcugcaguuggcgccuuaucaguaucuaagcggaguguuuuggaaggaguuaapcuguggcaaacgcccucuccgccguc\n", + "agccaagauggcgcauapuucuccaggcugcaguuggcgccuuaucaguaucuaagcggaguguuuuggaaggaguuaapcuguggcaaacgcccucuccgccguc\n", + "agaggccugcpaagccaagauggcgcauapuucuccaggcugcaguuggcgccuuaucaguaucuaagcggaguguuuuggaaggaguuaapcuguggcaaacgcccucuccgccguc\n", + "ggaggcuguccgguggacaagacgcacagaaaccagugcapcgugucggcugaagaaguguuuggaagucaac\n", + "cucuucgcgaccgcugcgcgcgagccccguguccccacggcpcagcagcggcggcggcggcggcugaacgcggapcggapagcccgcggcggcggcagcagcuacagcgaa\n", + "auaaaagacugucguaguaaaagagauucapcacapaaacuccaccacaaagcgugguaccauuucccacagaagcuaa\n", + "ggucggcguggcgaaggacggcuagccuuggapaaaguagccaccaguccaacucpucgcccccaccauuauuucg\n", + "ggucggcguggcgaaggacggcuagccuuggapaaaguagccaccaguccaacucpucgcccccaccauuauuucggugapcaacgcuaagaapauacug\n", + "acucuuucgcucgccgcggcugcugccaguguguggcucugucucuccuccgcuuugcugagcccucccuucuuccucucaguuccuagaguccgaccgccgccgccgccgagagagaggagaaggag\n", + "auaugcacccaauguccapagcgugcaaaauuugucaaaaguggccuuuuauuguaaaacgacacgagagcua\n", + "ggcuucuccgcucgcucacagaccccgcpagucuguugguggccppaaggcgagcggcgugauuucucccuuuucugccgccuuccaugguuuagucugccucuuucuagug\n", + "gccgccgcagcagcagcagcagcagcagccuccgccgccgccaccgccgccuccgccgcugccucaggagcggaacaacgucggcgagcp\n", + "aucauagcaauaagauuuguaaaacauugcaauggcugaaaaacugucuaacaggaaauuuuaaguguuauuccaaagaagaacaagccuaaaa\n", + "acaaucaagaugccauagaaaaggcuguuaguagaggccaauguuuauauaaaauaucaaguuauaccagcuauccc\n", + "gugugauucccuucaguacggcggcaccguggaagugcagacuuucacapuguggucucagcucacacag\n", + "ccagagcccccucgccccaaaggucacupacuauuugugcgaagagaugcaguggcucucugcugacuuugcucaggagcgccguuggaaacpuguggcccggaag\n", + "guggugcgcauggugauccggcaccacgaggagcagcggcagaaagaggaacpcccggapaggagcaggccaagcugcgucgaauugcuuccacc\n", + "gucaguccgucpapcuapagauggucacgaaaccugaagucaagaguuaaggcuuguuggcuucug\n", + "gucaggccccggccaggccpaguggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "gcgaugugaugacgucaggccccggccaggccpaguggcgugcupcgugcgcggcugcgguacggcguguuggucccagcgguucagcugagguapacgugcuguaggccgga\n", + "cagaagucacugauuuucugcauacuccauguaaugaaucugguaugcugagauaaggacaccugugacugag\n", + "aagucacugauuuucugcauacuccauguaaugaaucugguaugcugagauaaggacaccugugacugag\n", + "gcpaggaggacuguaucucuggaugccupccugguuucapccugauuuauuccucuuccupagcucacucag\n", + "agugcggaacugugcgcccgccgcgcuccccugccgcgcuccccgcugcugccgccgcgcccccgcgcuccgucccgcgcgcccgcagcguccuggccgcc\n", + "gapugacpaccccgccagccccagcaucgcgcgccgcagccgcggccccgcagcuccgcccccggcccggcccggccccpcccgcucgcccgccgccccgc\n", + "apccgacggacggcpcggcggcggcgguggcggcgcuggagucggcgcpugcuggcgcc\n", + "acacugccuccuaggaggacuggcacacaggccagucccaggagccgccuccugaguuccugcuauggaaggcgauuguuagcgcugccaucaugagccaggcupuucuguguugucucag\n", + "gugcacugugaagaguucauccccgaguuugagaagcaauacccagaauuucccuggacggacguccag\n", + "gcugagaucuuccpccuucacggagcuguuccagguggccugugccaagccaccaccccupccucugcgacuaccccucaucccpcc\n", + "agacgcucggcggcggcguguggcaggagcgcapcgcgagccggcgaucagccuucccggcgaccgugccgcpagcucgagcaacucggacuapacccpccggcccccaag\n", + "cccuggacccauccaaggaccccugccugaagguaaaaugcagcccucacaaagugugugugacccaggacuaccagaccgcccugugugucagccgcaagcaccugcuccccag\n", + "gcaaaagaapaacguggcccagaaacacupuuggaccuucgaauuuggucaagugcaagcccugucccguggcacagucagcc\n", + "guaaggaaguggaggauuaaaugauuugcccaaagucucacaguaauuuguagagcugagauugaaauucpugaaacuucacauaucacauucuuuuuaucag\n", + "acupcuucuggacuguauauccuagcugccuugucaacaucuucgagcaucggcagcuccggaggccp\n", + "aguaacuuucugagauuuuuaccaucauucagaggugaaucucuucagaauccagcauuggucuugaccagcuagacagucaccuuaagaauucagaacaauuugugcaggacuacug\n", + "pcccccaaacccpccgcagagcaguaccaguccguggccuguuaggaaccaggcuacagagcaggag\n", + "uugccaaaacaaapauuuggugauggaggcuuuguuagaaggaauacaaaaucgapcaug\n", + "auuaaaagugupcagupcggaacaaacgcgccgacuacagaggcuggacguaagcuuagcgguggcgcgcgugcgcagcgccggcccgag\n", + "agucuggcguggcgcagcccggcgupuucggccccgccagguggucagcccuuccucggaguccagguggcupcgcuucggagaguggccag\n", + "gaugupugaguucauuugcucgcgugcapaagucuggagaaggcauuguuucaauuauuaaaagugupcagupcggaacaaacgcgccgacuacagaggcuggac\n", + "uggcggagucuggcguggcgcagcccggcgupuucggccccgccagguggucagcccuuccucggaguccagguggcupcgcuucggagaguggccag\n", + "aaaagugupcagupcggaacaaacgcgccgacuacagaggcuggacguaagcuuagcgguggcgcgcgugcgcagcgccggcccgag\n", + "ggaugupugaguucauuugcucgcgugcapaagucuggagaaggcauuguuucaauuauuaaaagugupcagupcggaacaaacgcgccgacuacagaggcuggac\n", + "acccucgcggcccgcccpaacucugcpagucgcggcagcuccgcucccagagacccaggaguupcccagcgucccucccggaacg\n", + "gacucacccucgcggcccgcccpaacucugcpagucgcggcagcuccgcucccagagacccaggaguupcccagcgucccucccggaacg\n", + "accgccuccgcgccuccauccagccggcucccuccggccgcgaacugccccuccccgccccgccucccggcgcpuggccgaggcguagcgcugcgacccccgcaccccugcgaac\n", + "aguuccguccugacagaguucacagcauauauugguggauucuuguccauagugcaucugcuuuaagaauuaacgaaagcagugucaagacaguaag\n", + "gcgcpcgaugcccagcggcgcggcpcugcpcccggcpcgcgcagaggagcpccgcggcgcugaggcggcggagcguggccccgcc\n", + "ggaccccggcuggaggugacgcugaggcggcgapugagucggcgccggccgcuaccgcacuucpcgcucgucccucauuucucuguggugaauggcgacp\n", + "gaucaucuucuccacgccccuggccgucauugccuacuuccucaucugguucgugcccgacuucccacacggccagaccuauugguaccugcuuuucuauugccucuuugaaaca\n", + "aaagcuguaaaagucucaguuaggauguguguugauuaaacugugguguggcugagcauuuugccugaaacuucauapaauaagcaucuguuaaugacuuucag\n", + "gaguuucccuacacaagcucuuugccugcugccauccauguaagacaugacuugcuccuccuuccuuuccaccauuauuaugaggccucccagcccuguguaacu\n", + "aggcuuggaauaguuaaaugacuuuggucuuguccaagguuagauggaguucaacucuaacgucaagucuugguccuuuucauug\n", + "cauacagaaacugcuguaaaagaagaaguugupuauuuuuuuuuuuuuuuuugucuggaggaaupacaccaaaacucauuuggcagcagaggugag\n", + "caacagccaacucaguuuauaaauccagaaacaccuggcuauguuggauuugcaaaccuccccaaucaaguucaccgaaaaucagugaaaaaagguuuugaguucacacug\n", + "pcugugagcggaccgcgagcgcupcpuccgcggcgcggucggucggcgccuguucucpcuguuuggcgg\n", + "gcguggaggacuggccagcccccaaaccuccaagcccaucggcuggaugccguggauaagcgapagagcgacuaggcccugucugcpuaccuucggcgaggagaggcgacgaag\n", + "pcpcpcpcupcpcugugagcggaccgcgagcgcupcpuccgcggcgcggucggucggcgccuguucucpcuguuuggcgg\n", + "gguucagugaggcugapuucuguggaggugcpagaggugcucuaugguauuucuauguugcacugugupuuugaaaucagauacauguaauaggugauaag\n", + "cpcugugagcggaccgcgagcgcupcpuccgcggcgcggucggucggcgccuguucucpcuguuuggcgg\n", + "ggcpcpcpcupcpcugugagcggaccgcgagcgcupcpuccgcggcgcggucggucggcgccuguucucpcuguuuggcgg\n", + "pcpcugugagcggaccgcgagcgcupcpuccgcggcgcggucggucggcgccuguucucpcuguuuggcgg\n", + "gacgcaauccgccugcgcgcupcpcpcpcupcpcugugagcggaccgcgagcgcupcpuccgcggcgcggucggucggcgccuguucucpcuguuuggcgg\n", + "ugcguauacauacauacuauguaugugcguuuaugugugucuguguguuuuuuuuuuaacagacgaagcuucacaaaag\n", + "auuaaagaagcuaauugaucaagaaaucaagucucaggaggagaaggagcaagaaaaggagaaaapucaccacccugaaagaggagcugaccaagcugaagucuuuugcuuug\n", + "acagucggcucgcagcgcggcacuacagcggccccggcccggcccccgcccggccccggcgcaggcaguucag\n", + "ucaacaugaagcuaccggccapuuuucuuuacucupucccggcugcccuguggccucgcuccucggagg\n", + "gugaugaacagccuccuucuaaaucauugaccacauuucuuauucuuuccugaggauaaauuucaagauauccugaaccaacug\n", + "uuuuucaguuaupacaaaaauauuauaucaaaacacugaagcuuugcaaucuaaauucuuuucaccucuucaaaaagcg\n", + "uccagccccgagaacuuuguucuuuuugucccgcccccugcgcccaaccgccugcgccgccuuccggcccgaguucuggagacucaac\n", + "aguucuggagacucaacaugaagcuaccggccapuuuucuuuacucupucccggcugcccuguggccucgcuccucggagg\n", + "gcaccuuacuapauaugaaggugagaagaagagcugauuccugcugucaagaagcauagaguccaauggcauu\n", + "guucuggagacucaacaugaagcuaccggccapuuuucuuuacucupucccggcugcccuguggccucgcuccucggagg\n", + "ggaggaccccguucuggagcguuauuucaaaggccacaaagcugcgaucaccuccuuggaccucagccccaacggcaagcaacuug\n", + "gagaggaaaauucucagaauuuaaagcucauacagcuccaguucgaaguguagacuuuucagcugauggccaguuucuagcuacagcuucugaagacaaauccauaaaaguauggagc\n", + "gcagacgguuccpagccgcacgguccccucuccuuccccauccucuccccuccccucuccpuucccccacccacaggagccuupccgaccacucccccg\n", + "gacgguuccpagccgcacgguccccucuccuuccccauccucuccccuccccucuccpuucccccacccacaggagccuupccgaccacucccccg\n", + "paggcgcugccgcucupcagacgguuccpagccgcacgguccccucuccuuccccauccucuccccuccccucuccpuucccccacccacaggagccuupccgaccacucccccg\n", + "ggacuuuccaaggccucccaaagcucucuggcacccapaacagugugcgugucgagagcuuaauccgcaggagcauagcc\n", + "ccagaggaaccgagaggcugagacuaacccagaaacauccaauucucaaacugaagcucgcacucucgccuccagc\n", + "gagaggcugagacuaacccagaaacauccaauucucaaacugaagcucgcacucucgccuccagc\n", + "gucaggaucuggcuuagcggcgccgcgagcuccagugcgcgcacccguggccgccucccagcccucuuugccggacgagcucupccgccacaagacuaagga\n", + "ggccgagcgagcccccagcccagccuggcgacupaccccggcacaugagguggacgcccccpaagacuupugcacagccaggcgagaag\n", + "agauugugaapuuccugaguaagcagcgugucuccaucccccucucuapcucuuggauggaccuugcacucuagaapaca\n", + "agagaacaugugacaaaucugcugugupcgagcapaguggcugacacaaccacuguggagcccpucugucaggcacauccccccagaaacagu\n", + "uuccagauugugaapuuccugaguaagcagcgugucuccaucccccucucuapcucuuggauggaccuugcacucuagaapaca\n", + "cccgcgcacuugcgcugucacucagccuggacgcgcuucuucpucgcpugcacuccggcccggcucccgccucggccccg\n", + "ggaaguuccacgucagucagucugacggucaguggaucggupuuuaucucaaggccugaguagccgguaacaaacgapuucccpauuggaccgacgcagcc\n", + "gagaaucggcucccggaaguuccacgucagucagucugacggucaguggaucggupuuuaucucaaggccugaguagccgguaacaaacgapuucccpauuggaccgacgcagcc\n", + "ccucugcgacuugauaucaaaagaaagcuaacugcuagaucugaucgaguuaagaguguggaucugcauccuacagagccaugg\n", + "agaaucggcucccggaaguuccacgucagucagucugacggucaguggaucggupuuuaucucaaggccugaguagccgguaacaaacgapuucccpauuggaccgacgcagccaug\n", + "acacuggugaagacauuugaaguaugugaucuuccuguucgagcugcaaaguuuguugcaaggaagaauupuugugacaggagcg\n", + "cagucugacggucaguggaucggupuuuaucucaaggccugaguagccgguaacaaacgapuucccpauuggaccgacgcagcc\n", + "acgucagucagucugacggucaguggaucggupuuuaucucaaggccugaguagccgguaacaaacgapuucccpauuggaccgacgcagcc\n", + "cgucagucagucugacggucaguggaucggupuuuaucucaaggccugaguagccgguaacaaacgapuucccpauuggaccgacgcagcc\n", + "gucggaguupugcaggcaggugccaupcccgcuugaggcacacugapacgcpcupcc\n", + "agguucuagugucggaguupugcaggcaggugccaupcccgcuugaggcacacugapacgcpcupcc\n", + "agugucggaguupugcaggcaggugccaupcccgcuugaggcacacugapacgcpcupcc\n", + "uauagacpuuucaccauguuggccaggcuggucuuuaccuccugaccucaggugaucugccgccugagccuccccaagugupauuacaggc\n", + "gaaguagaaggcgguggcugaggcgguuccggagguucuagugucggaguupugcaggcaggugccaupcccgcuugaggcacacugapacgcpcupcc\n", + "gaguupugcaggcaggugccaupcccgcuugaggcacacugapacgcpcupcc\n", + "agaaguauucupaucguuucuuucagcacaccaaaauagauggucccaaauucugcagcacaaaucuaauuuguuuccuccuugaguga\n", + "uauucagccuugcaggcgccucuggcpcuucacugagauccgcucuuucggugcucgacucgcccgugcugcugccgccgccgaaggapcaaagcucaag\n", + "ggagaagccuuaaaaacaaauggcaggugupcaccagaaaaucaacacaucpaagagaaaa\n", + "agccgcgccgagcpccucuccpccgcgucugupucgagacugcgcggccguupcgugcagcggcgccagucggcggacgapcccccpag\n", + "uugcuggacugagacaugagccuccaacugugugguupcucgguagcacaucgupacuupugugcgcccacagaugguuuggcccugcagugaccagagcagcccaagccgccacc\n", + "gagcugacuacagaggagcaggauuugcaccccucgcupcuugcuuuggcaacagagugccugacccaggucag\n", + "gaguguaaacugaagacgcagaggaagagcupaguapcugaguagcugcggaacuagcucaucaggcuccuuuccucucuaucacgugag\n", + "aacccggaagucucacggccggaguugguggucupaacccacgupcupuuucggauugcucugcugguccggccgcuggagcgcccacccuggccuagucgcc\n", + "auaaugcapupccaccugccgguaggugugcgguaggcuuuucuccgucgcaggacgcapuucpccuagg\n", + "ggcuuuucuccgucgcaggacgcapuucpccuapuaggcucuccugaaucgacaggcgccggaccucuggugapapauaagugaggcgucaguuucucug\n", + "uucuccgucgcaggacgcapuucpccuapuaggcucuccugaaucgacaggcgccggaccucug\n", + "gacugcagugcaacgcauccguggaccucauuggcaccugcuggccccgcagcccugcpcagcuagugguucggcccugcccugccuuuuucuaugguguccgcuacaauaccacaa\n", + "acaauggcuaccpagugccuggccaauggcagcupccgcccgcgugaauuacuccgagugccaggagauccucaaugaggag\n", + "aaaaaaagcaaggugcacuaccaugucgcagucaucaucaacuaccupccacuguaucucccugguggcccuccugguggccuuuguccucuuucugcggcucag\n", + "gagcauccggugccugcgaaacaucauccacuggaaccucaucuccgccuucauccugcgcaacgccaccugguucgugguccagcuaacc\n", + "aggcapagagcapcccugcugcacccaaguccugguugcuccuccccaccacacuggcccucc\n", + "aucuuuuggugcagaaggugacpaaacaggccgcagaccugaacuuccaaccguauguaggcgagaagccggugccgauacucccacuaucccaca\n", + "guugauguccugcaucuaacgcgguguaacccccgaagccgagcgagcuccggaggaauuucaguaucugcuacgguaacuucaucagcccgccaag\n", + "aacagcucpcggcgcauggagagugcpcggcuucaagcupuauggagccccucagcggcggcpucu\n", + "gcauggagagugcpcggcuucaagcupuauggagccccucagcggcggcpucugugaguuggacgcpucuuggcpaauggagguagaauaaacgupacccggagugcaccaag\n", + "aauucuccaagucccggcugcuuauguaccuaucgagccagauucaccaccgucauuaucaacucauuuu\n", + "auagcuuuacggcuucupagcugcugcuucgcugugagaaguauccgcgacgagcuauccpaaapccgaaugcgaucaaaccuaauccgcgagacuugcuaa\n", + "aaauuuaaaucuuuucaugaaacauuauugaacuaugauacauuuacaguggaacauaaugaccuagugcucuucagacuucacuggaaaaauacugaggugaacuug\n", + "ggcuucupagcugcugcuucgcugugagaaguauccgcgacgagcuauccpaaapccgaaugcgaucaaaccuaauccgcgagacuugcuaa\n", + "gacuuuuccgucgcgccauaggcagcugcggcgcagacgcggcgcuacccpucpcccgapugaupcagcgacccccggcggccupagagcg\n", + "gaguaggccupuupcagaggcggcuggagcugcuugacaccupcucuggccggagccgccuupcuag\n", + "auauucccgguaacpcgcgcggucpcagguupccggaagapuccpccggcacugaggcpaap\n", + "augccggaaguggcggugcgugugacgccggcggcppcpaccupcggagagcgguucgcgcgcuucpccuaguccggacucgccgccgccgccgccauauucccg\n", + "aacpcgcgcggucpcagguupccggaagapuccpccggcacugaggcpaapucgguugag\n", + "ggcggagagcgguucgcgcgcuucpccuaguccggacucgccgccgccgccgccauauucccg\n", + "cpaccupcggagagcgguucgcgcgcuucpccuaguccggacucgccgccgccgccgccauauucccg\n", + "uccgaaucccgcaguggcaucuuccuuacuuuguccauccuccggacucgcgaucuuccuuccggagcc\n", + "acucagcgcucggccccgccccgccgcggcugcagcagcagcgccgcggccggaggagcuaccgccgccaccgccgccaccgccuccupacucggaacgcagcgcucggagcc\n", + "aaaaggagaacaacuucccgccacugcccaaguucaucccugugaagcccugcuucuaccagaacuucuccgacgagaucccaguggagcaccagguccuggugaagaggaucuaccggcugugg\n", + "cggcccugcuucugucpcuccapuaccccuggauggcugcgcugugcccucgccggccgcccpcgccgcagcggcugaguucgccpaucgccpccgccgcccuugccacccgcugc\n", + "uguggucuucagcauagagugagcuucuagugacacgagcuggapaaagaggaagugcaucaggacggcucguccaauggacaag\n", + "cugcgcpaggcuggucccaaccuugcgupcuucgcgupcccggccucgccgcugcggucgcccgccuggc\n", + "ggcuggucccaaccuugcgupcuucgcgupcccggccucgccgcugcggucgcccgccuggc\n", + "gcagagcugcccgccuucpcccugcgcpaggcuggucccaaccuugcgupcuucgcgupcccggccucgccgcugcggucgcccgccuggc\n", + "ugcgcpaggcuggucccaaccuugcgupcuucgcgupcccggccucgccgcugcggucgcccgccuggc\n", + "agagcugcccgccuucpcccugcgcpaggcuggucccaaccuugcgupcuucgcgupcccggccucgccgcugcggucgcccgccuggc\n", + "auauugguaaaggcauuapcgaagguggaacggaacuuccuguucucgcpaucuaaaggcpacugccacguccaagcaaaccpaaaggagaggaucccggagccg\n", + "agaaccuacucaggcagccagcugagaagaguugapaaagugcugcugcupucugcagacgcg\n", + "ggugcuccgccgcgguggcgguugcuaucgcuucgcagaaccuacucaggcagccagcugagaagaguugapaaagugcugcugcupucugcagacgcg\n", + "ggcgcugcgaccaauucaaacauggcgccgucagccucacauuccccguuuuccgcucauggcggcguapcggaggucgcgccugagugcguccgcacgagapcggaaccgucucc\n", + "ccgccuagugagaggcgguccgauuuggcccuupaguguccgucgcguugaucugauggauucacguacacaacaccacauucuaugagauuuugcaggcaaaaguccacaagcuc\n", + "cuuuccgccuagugagaggcgguccgauuuggcccuupaguguccgucgcguugaucugauggauucacguacacaacaccacauucuaugagauuuugcaggcaaaaguccacaagcuc\n", + "aagccaacaggcgaguggcgaagguggcggcagcggcggcpcagucaccggcuapcgacggcuccgaggccgaguggcgguccgacagaguccuccguguccucccccgcaugacccccuug\n", + "ggucuggcucugucacccaggcuggagugcagugacacgaucucagcucacuguaaccuccgccucccpuucaagcgauccucccaucugacccucccaaguagcuggcauucag\n", + "cgaguggcgaagguggcggcagcggcggcpcagucaccggcuapcgacggcuccgaggccgaguggcgguccgacagaguccuccguguccucccccgcaugacccccuug\n", + "cggcpcagucaccggcuapcgacggcuccgaggccgaguggcgguccgacagaguccuccguguccucccccgcaugacccccuug\n", + "acugcupcugcupcugcpcugcpcugcpucpaggccpccpccpccpccccgcugaccgcc\n", + "gccuuggaugguauacuguaaauucagcauauggagauaccauuaucauaccuugccgacuugacguaccucagaaucuc\n", + "gcccpacgacgcccccuccugcggcguggacuccgucaguggcccaccaagaaggaggaggaau\n", + "gaggaagccuuuuugagucaaaccuggagaaugaaggaagcauuucuggcagugauucaacauuuuauaggcagucagaag\n", + "aacccggcgguuccgcagcuguguuupagacuupcgcauuagccuggacagcucccugaucg\n", + "ccupcguacugaggcgcgguggccugagcccggccgccaucgaugaccccggucgcggacuugcuucaggcuggccacccccc\n", + "cggagucgccgccucugcucucagugccccggaucggaggccguccaucgccccucpccgacgccaugaagaucaaagaugccaagaaacccu\n", + "aaaacgcagauaaacaagaaagauaaagucacccguauuccccgcacccggagcgaaccgcuauuaauauuaug\n", + "gcgcggcccagccaccuccggagucgccgccucugcucucagugccccggaucggaggccguccaucgccccucpccgacgcc\n", + "ggagcgcggaacccucagccaggaggcgcggcuggucggucccaggucccggccuccguaaugagagcccggaaccacucuuugugccgcagcuucgcag\n", + "gugapugacuguugacuagugaaaaaapacccaugguucacgacugucuucuuacuggcaguggaacgaccuguggaaaccugugauccauucucauuaaauaaaucucugg\n", + "ucauucugcuaugauauagaacacuggaacuuauuccuccuaucuaacuguggccuuguaccugcugaccaauuucucaccaucaaccuacacccuacuuccccauccucug\n", + "agacagaaucucuccauguuguccaggcuggucucaaacuccupcucaagagaucaucccaccuuggccuuccaaaguguupauuaccuau\n", + "ucuugcucuguugcccaggcuggaguguaguggugugaucuuggcucgcugcaaccucugccucccagguucaagcgauucuccugccucagccuccugaguaacupauuacag\n", + "acuguccaagugauuguccaggcucggcuuggugaaaagauuugcacucguucaucaucuucuccaacpuucagauugg\n", + "uucaacuuagcaaucaaagacaucccagagguuacacaugaagcaaagaaggcacuggcaggacagcugccugcagucpaggucc\n", + "gcuggaguguaguggugugaucuuggcucgcugcaaccucugccucccagguucaagcgauucuccugccucagccuccugaguaacupauuacag\n", + "agagguacugccucuucugcuccaggcagccuucccuucccuggaggcagaggccccapaucuguguccucaccaaugag\n", + "gaaaaguggaagcucagcacauacuggccagugcaccaacagacaggaaccuaugucacuuucaa\n", + "cugcugcccccaaacacacpugcugcpucuugcccaaccugcccugugugguccaggaapccauagug\n", + "auagcccuuucpccaauaagcagcgagaggcpuucccgcgccuugcgaacuuguagagugcggacaaaaagccggccggagugugccguccca\n", + "accuggcuccgcpcagccggagcgcacccggccggaagccgcugucpagccggcggupcuggacgcag\n", + "guuguuugcugcuugcugcccgagccupcguacccaupcgcpugacagugcaagugcuupacgacaacccpcuccucaucgcggccggaauccaagaggcugcggcgcgag\n", + "guuccaccgcggagccggauguuugccgagccuugacaggcguggcagapagcagugcccgagcgcg\n", + "aaucugcuuccggccugcgagcucgguguuccgcuuuuugupccpupuuuccuaaucugguuucgucugccugguucaucugugugcg\n", + "gcuucucpaacacuggcccugcuaccagagccgcaggaucccccaugagugccugugaapaguccuggauagugaggcccuggcugguccapupuacuccgcc\n", + "gucuccucucugccugccuggcaccagccagacccugcucugcccppcucugagccccccaggcauucccuucacugcaucccucuccauuppugucuaaggacccuuuccccuupc\n", + "auugacgugcagaccuugaaucgaaacccaggcuccugcaggcacuggcacagcuacagcgapccucggccauccaapucucccag\n", + "gugcagaccuugaaucgaaacccaggcuccugcaggcacuggcacagcuacagcgapccucggccauccaapucucccag\n", + "ccuuucccuuucggauucccgacgcugugguugcuguaapuccucccugcgccacacggccgucgcc\n", + "ucucpuguuuuuccucaccgcuccaugugguccuaaguggaaagaguccuguucapaaucgagacaccucgugaaaguaccacugccaugaaagc\n", + "guuuaaaggucaacaagaauaucuuaccuuaauuugacaaguacgcaagaaauaaugcaagacucguuuauguucag\n", + "aucucggccugauggacgccugguguggacgaugapaagaacgugccccccacacccaagaggugaccccugagccagccccgg\n", + "gucpaupcpagccaacauagagcccucagupaugapugaaacugcuauugccggcggcuccuguuuuaccgcgucagc\n", + "gcpagccaacauagagcccucagupaugapugaaacugcuauugccggcggcuccuguuuuaccgcgucagc\n", + "auagagcccucagupaugapugaaacugcuauugccggcggcuccuguuuuaccgcgucagc\n", + "guugucpaupcpagccaacauagagcccucagupaugapugaaacugcuauugccggcggcuccuguuuuaccgcgucagc\n", + "ggcuguucaggcgcpugcgcgcgcagcugcuguggcccugcuuggugcgcccgcugucaccgcc\n", + "cuuggugacaaugcapaacccgugcugagcucucugcacacagccccagucpcagcaggaaaccgaagac\n", + "uucccaacacucagugaaaagupuuuaugcupacaaaacagccuuggaaugagcaguuagcag\n", + "gagcccucpagugguccgaccgcpcggccgccggugagguapcpaggcppagac\n", + "uuucccgugagcccucpagugguccgaccgcpcggccgccggugagguapcpaggcppagac\n", + "agccgcugcugcugcugcugcugcugcugccgccgccgccgccgccgucccugcguccuucggucucugcucccpacccpcuccgccgcagccagccagc\n", + "agagagaagcgagguuuccauucugapacggcguagaguucggccgaaggaaccugacccaggcucugugaggaggcaag\n", + "guuuucapacaggccaacccagaggacaggauucccuggaggccacagaggagcaccaaggagaagaucu\n", + "gccugupucuucauugcccagcuccugcccacacuccugccugcugcccugacgagagucauc\n", + "aaacaugaggcagcugccagccggccupcagucuugucugccucggcugugaagupaggcuggcaacaguuuucuucagcgcccagg\n", + "cggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "upcugccggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "ggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "accugcgccupcugccggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "ccaguuuccagcucacccggcucccgguugaucucgaugucgaaguggcacugcggccgguccugcgcccccaucgcgaccgagguggcggcaagagcupagagapagaaaagcg\n", + "pcugccggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "gaggagccuccagccagcgcuccuauaccugcgcguucccuguuugccccccccuuugaagucagucgcccaaucugaaagccguggaugcgccugcgcccuccaucucgucag\n", + "cuaccugcgccupcugccggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "acggccuaccugcgccupcugccggugaccupccgagcccucccggucggcuaagauugcugaggaggcggcpuagcuggcaggcgccgacuuccgaaggccgccguccpcgag\n", + "gugaaaapaccpaaaucaacucagaaaccauuacauuauaagaguugucucuuucacagaguugucaaggauuuu\n", + "gcuggucuugaacuccupcucaagugauccuccucccuucgccccucaaagugcupauuacpugugaaccaccgugauuucag\n", + "gcacaagcuguaacauggcggcagcgacugcggccugaacucuapagccpuugauuuuuaaagcuucaaaauccuaagacucagcacuguugcp\n", + "papaggcgguuagcpcuuuagcgccuuuucuggcggcgguagauuugaagcgcuucaaaggaccggacccagagaagaggaaaacucuaccggugcagguaagug\n", + "uagauuugaagcgcuucaaaggaccggacccagagaagaggaaaacucuaccggugcagguaagug\n", + "agcggucgcugagcpcgcaggugacuaaauuucgacpucuucucacpuuucauucaguuggccacugcugagcagcugagaagguggcgacguapcc\n", + "gaauuuugugagcgaccgcgcupccguuucucuuucuuuuccggacccugcaguggcgccuaaagucugcgaggaggaagucgccucugugcucgugaguccapaucuaag\n", + "ggagcucugugacggcgcccagcgugacccacuccupccaggauacggaccgucgugcccauaucuccuggcuggucgcccuauccucccgacucugcuuaaaaccacgugguucg\n", + "uuuggccugagagugaugccuuuucucuggauuuguccucuagaguuuucccuugcagauucaucaag\n", + "acccaaagcccuggugccuggaacuacugcuugauucucugagagaucccagcacccuacaaacugaguccagaucug\n", + "agcccuucpcagaggapcpacucpcggcucucagcauccgccuggagcucguggcgcuguguuuccgugcuguggaguugccugguccgcuuccuccccgcg\n", + "gccacugacucggaggcggcugcggagagcpcgcuggcccguggaggcggcagcggcggcggcuuucuagcggauccgag\n", + "ugucuguugacuucacuuggcacuguuuaacauuccaccucuggaaauuguaaagauggagagaugapaapacaapaugaagaaagaggaaagg\n", + "guuaccauaacgaccagaagacgcugcagccacuapaggagagcaaaguaaucagaaccucccaagg\n", + "ggaugcgguuuaauauuuucaugugauuccuaaaagaaucugaggcucaagaaaagapcaucuuaauauccugcacuuucagucauugapcaugaucacaaagaucaaagccauuuuuaggcag\n", + "cgugcgcgaucacggcccggcgcguggcucpcucpcggagcuggagacguguggagcuguucgaggacucgcpugugcag\n", + "acggcccggcgcguggcucpcucpcggagcuggagacguguggagcuguucgaggacucgcpugugcag\n", + "agugcpcugagaaggcgguggcugcagcagcagcggcggcggaaacccuaaaguccgaguccggacuacgagugcguggccuccuaauccggauccuaguccugagcgugucugugugcgagugg\n", + "cagugcpcugagaaggcgguggcugcagcagcagcggcggcggaaacccuaaaguccgaguccggacuacgagugcguggccuccuaauccggauccuaguccugagcgugucugugugcgagugg\n", + "cauuuugcagcuuucuccugucuugaagaaguagaacggugcccgagaaacguuuuuccccuucgagacucaggagg\n", + "gcaccuagcagaucccaagcupaaugccaguucuggcaccaaccuuccugcucccugcupccucugcucccccaucucucaggagucgaaagugagaaagcaag\n", + "acaucaaggapaccugugcccugcuccacauccucccaccugccgcccgcagagccugcaggccccgccccccucgucucuggucccuaccucucugcugugucuuc\n", + "gcauugupccguccgcgcgcccgucccgucgccgccgccgccgccgcagaccccucggucuugcu\n", + "gugaccacccacuauggcuuccuagugucapccagcuguguaguggcucggugugauuuguuagcucuuugaggcapuacccuccucaggauuucgau\n", + "ggucugaaaagcccucaagaaagccucagugaucuuggugccauagagagucuccpucccuggaaag\n", + "accacccacuauggcuuccuagugucapccagcuguguaguggcucggugugauuuguuagcucuuugaggcapuacccuccucaggauuucgau\n", + "aggauacccupucggcuccuccacgugaccacccacuauggcuuccuagugucapccagcuguguaguggcucggugugauuuguuagcucuuugaggcapuacccuccucaggauuucgau\n", + "acuauggcuuccuagugucapccagcuguguaguggcucggugugauuuguuagcucuuugaggcapuacccuccucaggauuucgau\n", + "acccacuauggcuuccuagugucapccagcuguguaguggcucggugugauuuguuagcucuuugaggcapuacccuccucaggauuucgau\n", + "ggucccgaugccgcgagcggaaucucggcgcucccggaaguggccugaaggcggcgcgccagucccgagcagugcucgcuccugcucpcgcugcggccccpcgucgcc\n", + "cggaaucucggcgcucccggaaguggccugaaggcggcgcgccagucccgagcagugcucgcuccugcucpcgcugcggccccpcgucgcc\n", + "ggccugaaggcggcgcgccagucccgagcagugcucgcuccugcucpcgcugcggccccpcgucgcc\n", + "gcugugccacugccaccgccgccgccgcugcaucccgcccgguccgaguccgcccgccacgcccgccgagccgcugccgccgccag\n", + "ccacucccaaagucuapcuggaaggccaggcapacuuggcugcccugacuccuucgucucucugucccucugucucugccaucagucucucagccacuccacccacgag\n", + "gcuguccupcggaggugaccuugugcguucupcucccccagcaccuuucugccugugcugcuggapupuccagagcccgg\n", + "ggagaauccugaaccaaccuauccaugaacauacucucugccauuuucuuaguccuuuuuucpaaaacucuuuuauaauaacaacuguuggugaaccauucaucugaaaacucuu\n", + "auaauuguauggaagagauacagugauuuuaagaaacuacacaaagaacuauggcaaauucacaaaaacuuauuccgacauucagaguuguuuccuccauuugcuaaaggaauaguguuug\n", + "ggcgauuugaugaaacuguuaucgaagagagaagacaaugugcugaagaccugcuacaguucucugccaauauuccugcucuuuacaauaguaaacagcuugaagacuuuuucaag\n", + "gguggaauaauuaaugauaguucugaauuaauugguccugcugaagcucacucagauucccucauugauaccuuuccugaguguaguacggaag\n", + "gcuucuccagugacagugaucugguaucucuuacuguugauguggauucucuugcugaguuagaugaugga\n", + "guauuuuaauggucuuacuuuuuugaucuaaucucauuuaaucaugauucucauugcuaauaaaauaugauuugaaag\n", + "gagagucaagcccuacccgucgagaagcugugaagagaagaacagccgaguaccucaugcpcagaaaguaucucuagucuuuaupaaaccucagcuugaugauguaucucag\n", + "ccuccaggaucacuaaguucaaggccccuuuggaaccuaaggagcccugccgaggagcugaaggccuucagaguccuupugauugacaag\n", + "gaagacgcgucguupuuuuggaggccgugaaacagccguuugaguuuggcugcpuggagaacguuugucapcccggccaagaaggaggcccgccuguuacg\n", + "augcaaaaguccaggacagupccacuuucagucuucaaagagaaagauaagaaauucuggauuuucaaaauccuuuugaagccuuuuaag\n", + "pccgccuccgccucucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "ccucuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaag\n", + "ucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "gaggccucuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaag\n", + "acggagucucgcucugucacucaggcuggagugcaguggcgcgaucucggcucacugcaagcuccgccucccpuucacgccauucuccugccucagccucccuuguagcupacuacag\n", + "cucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "guuacuuacaaagcuccaguuccaacapaaguauauuuugcugauucuuuugacagaggaacucugucagg\n", + "pcacapccpcuucgugcggupcucgcucgcgcggcagcgguggccgaggccucuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaag\n", + "gaggccucuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcg\n", + "guucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "cuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "apccpcuucgugcggupcucgcucgcgcggcagcgguggccgaggccucuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaag\n", + "gccucucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "gaggccucuugguucugcggcacgugacggucpccgccuccgccucucucuuuacugcggcgcpcaaggugugcpcpaapcacpcacccccgcgguccccpaggcuagag\n", + "aguggccgcagcagcgcgccpcccuggccgcgccccagccgagcgcagcgcggagucgccccgaccuuucucugcgcaguacggccgccpaccgcagc\n", + "gcugacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "pagapucgcugacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "gcuuccggaaaccgcpagapucgcugacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "cgcugacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "gacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "gucgcugacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "pucgcugacguggaggcguccgaapcagcapugugucpcucggauuaagacaucggagucggagaccugagag\n", + "aaacccagaccgccgccgucgugcuccugccgcagcccggagccggccgcuucpcccuggccgccggccucccagccgcguucuccuccgccgcuccuccpcuugcccuggagcccucag\n", + "agacauggucuuccucuguuguucagaggugugcaguggugugaucauagcucacuguauguaacuucuaacuucupcucaagcgauccuccugcuucagccucccaaagugcupacuacaggc\n", + "agaggugauuuucugagugugacuccucuguuccuggcacccugugcauccuuagccauagcuuacaagagaacagcugguugug\n", + "cagccaucuugccuggagccugagaaapaggagagacagaaggaaccggcgacaguggucucapccgcuccppccucaagaaccggaggcagccccggag\n", + "cuuucugauagcaggcagccaucuugccuggagccugagaaapaggagagacagaaggaaccggcgacaguggucucapccgcuccppccucaagaaccggaggcagccccggag\n", + "cuaucuaccaaggagccuguugugagacaguuuucuccccaccuccugagguucuggupuuugaggcuuucuaccccucaccucupcuauagaacugcuuagcugcagc\n", + "cagcagcuaccuggcaacugaacccaucaucaccacagccacuccugcagcugccacgguuucugccaccucuaag\n", + "gaaguccuuugcuuacgucuugugauuuagaucuugacuuguguucugucucccugccucuguguugcagguacugucug\n", + "guacguguguguguccacaucuuugagugccpaguuuaaaaguuaggcaguccuuauagguauggaagccgagcuaauuuccuucugagccccccaaaugccuccuccac\n", + "auuucaacuaugaguacguacagagagaagcucucapuuccccugauauuucgagaaaaggauggacupaauuaa\n", + "auuaucuccacucgugccggcgcgcugcuggcuccucccuguccguccccgccccauuccuucccucuuccccaaaccauggaaaggcaaagugcagcpaaaagag\n", + "guacugucugaugagcgugaaagguuguuucaccgacuuccacaucgacuuuggaggcacuuccguuugguaccauguuuuccpupaag\n", + "guuggauccaugccgucuacaccccuguagacucuuugguguucggcggaaacauccugcacagcuuuaacgugcccaugcagcugcggaucuacgagaucgaggacaggacgcgg\n", + "aacguccugaaggagcacgcagaugaugacccuagucuggccaucacupucccuguggugacuuggccaaagaagacuccaaag\n", + "auauugucgaugacucuggcuggaagcaggaggcagaugccagcguucccagcccaggcagcagccupagcaccggcucuc\n", + "guguguccacaucuuugagugccpaguuuaaaaguuaggcaguccuuauagguauggaagccgagcuaauuuccuucugagccccccaaaugccuccuccac\n", + "gcagucpccguuccuucgccgccgccapuagcgguguagcugcgcagcgucgcgcgcgcuaccgcacccagguucggcccguaggcgucuggcagcccggcgccaucuucaucgagcgcc\n", + "cguuccuucgccgccgccapuagcgguguagcugcgcagcgucgcgcgcgcuaccgcacccagguucggcccguaggcgucuggcagcccggcgccaucuucaucgagcgcc\n", + "ggauggauucguucuguccgaucccagaaggaagucuuguuccugcauguaaaugaupucaucuuuggaaagccuucagguuguugcagauucaggccuugacaguag\n", + "agaauuaaauuuupaguucuguggaaguacaapcagcugauaaaaaguccauccaaaaggcaaaauguggaacugaaggcagaaaaaauuaaaguuauuggaaauugugaugccaag\n", + "gacaguggcuuuguacauauucauacuccaauaaucacauccaaugacucugapagcuggagaacuuuuucaacuugaa\n", + "ccuucaggcaaacuuaagguaccugaggagaauuucuucaauguuccugcuuucuuaacugucucaggacaacuucaucuagaagug\n", + "agucucgccgugucacccaggcuagagcacaguggcgugaucucggcucacugcaaccucugccucagccuccugaguaucupacuacag\n", + "ccuucaggcaaacuuaagguaccugaggagaauuucuucaauguuccugcuuucuuaacugucucaggacaacuucaucuagaagugaugucagg\n", + "upugcugaccuacggacugaacaugaaaaguaccuggugaagcacuguggcaacauaccugucuucguuauuaauuauccauuaacacucaagccuuucuac\n", + "ucaaguaapagaauugacuacgcuuauacaucagcuucaagaaaaggacaaguuacucgcugcugugaaggaagaugcugcugcuacaaaggaucgguguaagcaguuaacccag\n", + "uuucagcaaguucgugagcagauggaggcagagauagcucacuugaagcaggaaaaugguauacugagagaugcagucagcaacacuacaaaucaacuggaaagcaa\n", + "guucaacuacaagaagcugagagaaggupaagaaguucagagcuacaucaggaagagaacagcggaacaugaggcagcacagcaag\n", + "auuuacagaguaaauuuguggccaaagaaaaugaaguacagagucugcauaguaagcuuacagauaccuugguaucaaaacaacaguuggagcaaagacua\n", + "aagugacaguugagagauugaacaguuuaguuauguaaaaauuucaguccuuuuaccccauggauuuuuauucuggaggaaaagauugagcguauaaaagcagaaaccaaua\n", + "apacucugccucuaaggaugaugucugccuuggccugccaugccuggaauuccaauucaucuuuacugguucuaaag\n", + "aauuucagaaagagagaaagaaauaaguggucucuggaaugaguuagauucuuugaaggaugcaguugaacaccagaggaagaaaaacaau\n", + "guggugugaccuuggcuugcugcaacccuuugccuccupuucaagugauucucauugccucagccuccuaaguagcupauuacag\n", + "gguucuuuuuuuuuuuuuguccccaccuucuucccuauuuagguuuuauaggaucacauugacaaaaguacc\n", + "gagagauugaacaguuuaguuauguaaaaauuucaguccuuuuaccccauggauuuuuauucuggaggaaaagauugagcguauaaaagcagaaaccaaua\n", + "guagauuuucguuccgucacccaggcuggagugcaguggugugaccuuggcuugcugcaacccuuugccuccupuucaagugauucucauugccucagccuccuaaguagcupauuacag\n", + "gcggcggcggcggcggcggcggcggcgccucggagcpcggcccpcuguagugccggcgccgccgcgucuucccggucuccuuucccggccgcacagg\n", + "uucuuuuaagauapcaggaaugaaaacucucaauauagagcaggauuuuaaaccupcccgugcauauucuucapaauccagaaaccuggagauuauauguaaaacuua\n", + "gucauggcgcucuccaucuaaagucugugcagcuuccggagaguggcpuugauuuucucacuuuggacugguuuuuacuucccgacuucugg\n", + "ugguugguuacucgcacuaugcagacguguugcggugcugaauacaacauuuauuacuaaagccagacacuggaucaccgucacggcagaugucagcacaccuguuguaauca\n", + "aaauaaacguggcpacguaugugucauggcgcucuccaucuaaagucugugcagcuuccggagaguggcpuugauuuucucacuuuggacugguuuuuacuucccgacuucugg\n", + "gucauuuauupaggcaguguucccuaaacaccuuaccagcagcuuccauuuuggcauggaagaguguucucggcaaug\n", + "gccauuugucaucacupaaccagagacacccaucccuacgccagcuugagccgugcacugcagacacaaugcuguauuucuucucccagucaccug\n", + "ucupucgcggagcucuugucuguaaaaugapaacuggacgucguucuucapuucuucccaguucacgaaaccgcuugagcgugcuuggcgaagaggagcggaaacug\n", + "agugcgucuuuccugcgucguuccggcgcggcpagcagagaucugcggccguuugcagcuugcgguapaggcgugguggucugaagccuccgagcagccgcggcc\n", + "guuugcccacagcccagcugcaucugugaacaugaaugcuacuucuacagaaacagaguggaaucuccgaaauaccuuugagacccuuucgugucag\n", + "ugcgucuuuccugcgucguuccggcgcggcpagcagagaucugcggccguuugcagcuugcgguapaggcgugguggucugaagccuccgagcagccgcggcc\n", + "ggcggaagcpagccucugucggccgcggaagccuggagupcgguacgcagacgcgcgcggugagacccgcugucugcucagcggacucugcccgcccccaccucccccugcgucpccgac\n", + "caucagguuuggcucuggagcgugcagapccaggagcccucuupagcuaguaccgagcccgauaucaggaggaccccaggaagaggccpaaucccacugaagg\n", + "pucucccugccaagcuaupapaugguggacaugacaacuuccagcucagcggugcuuuagg\n", + "gccugccggucggcgcccgagcucggagccgcagccgcagccggaaaccpcccgcgcggcggccgccgucccggccaagccpccccgaagccagagccggagccpcpccgcpuc\n", + "acugaggcugaugugaauccaaaggccuauccccuugccgaugcccaccucaccaagaagcuacuggaccucguucagcagucauguaacuauaagcagcuucggaaaggagccaaugagg\n", + "cggugcacgcgagugcuucugaaacgucagcugcgcuccccuaggagugcugagcccgcggaaccgcagcc\n", + "uuuccgcugcugcuucugugaguuuuuccggugcacgcgagugcuucugaaacgucagcugcgcuccccuaggagugcugagcccgcggaaccgcagccaug\n", + "uccucugcupccupucupccagcaacaaguuaguauugcagacaupccaaggagccagaggcc\n", + "gaaaguuaaaggapaauauagauguacauccaucagaaaaagcacucauuguucacuaugaaguggaagcuaccauucuuggagaa\n", + "uugcaggccucaggacugucaucgccucupugugapuacuuuggccaccguccccggaaauaaccgcgccugccucucaagauaccccauccucuccacgccgcugccgcugccgcc\n", + "auupaapucagcaggacuucugaagapaacacgaccuuuaaggaggccaacagaucaggagaaggcaaaap\n", + "acapagccaggaupaaccacggacugaccugaccugcguccucpccacugcacupugauucacgugugcccaggcccugaggupccggaccupaguggcag\n", + "ucucuucccuccaugcuccgcuucgcccgcugcuggccagaggugaccagguccggcucucagcacggccgccggccppcc\n", + "cuggcccuccuuucuccpcauucgccaccgcuucccupcugagacgaccgguucgucgccuccuugcccgugaccgucgcuagaacucaguugugcguugcggccagucgccacugcu\n", + "cagcgucucuucacugacguccuucuccaugccggaaauaggaccuucccuugccaccpcagugcuggcugcaugcagucgcuacuuugaggcc\n", + "cugguuuuccaagaauugauauaaagcpaagaacagaaaacagcagucauaaguaugcuacucaaaauauucuucuuuuuaugugccaaauccucacauuggaagcugucccgagcaagacag\n", + "cgccaagacggcucggaugccggcggucucugcugaagagagaagauggcgcuugacggaccagagcag\n", + "uacugacaccucpcuuguagagcacuucacgcagugcaaagcgccccccgucuauaucauaucgccucucgguccuccuaaaagucguaugag\n", + "agcacuucacgcagugcaaagcgccccccgucuauaucauaucgccucucgguccuccuaaaagucguaugag\n", + "gucccaauccuccgcuuccgcgcuugcgcgccaagacggcucggaugccggcggucucugcugaagagagaag\n", + "gugacgcgcuupaaaggcaggagcgccagcggucpcugcucuuggcuaacgagaggaguccgaggcggcggcgapcgaacgacccgacgcaag\n", + "ccacuuaaucgugupcuuucuccaaauuucaguguuugaagauacuguggaggagcgugucaucaaugaagaauauaaaaucuggaagaagaauacaccguuucuauaugaccugguu\n", + "acagaccgcccugcaguuucagacuggapcgguggacggcuacucagcggcccaacucucucgcagcccuucucuccgcaaa\n", + "cuugcaguuuuaaagaauccaccaacuguugaaacaaaucccuagagacacaaggcaagagacugaaucaucaaaguaaagucucucugagaauuauugcuaaga\n", + "gaagaagccaagaauupaguuuucugcugaugaugcuaugcuaagcupcagagagaccauggcga\n", + "augugcaugcuuccaacauugugaagaugugugugcuuuccagucaccuuccaccaugacuguaaguuuucugaggcugcccagucaugcuuccuguuaagccugcagaacu\n", + "agcagaaagaguguuuuccuauugccaccacagcuaagaaugugcupucacaccugaagccaucccaguaccagguuucacccaaggcccaug\n", + "guccuccacugaguccugccgguggcccgagcccgguggccucccggcgacccucggcgcgaggcgac\n", + "agauggauuuauaaaagcuauugguccugcugauguuauucaaagacaguuuucuggagaaacuuuugaagaaauaauugacugcucupaaauguauucuaccag\n", + "acuugcgacgcaggcgcagaggcupcgugcagccgccgccgcagagccggagcpccgccggcgccg\n", + "ccugcucugugagaccuguguugagugcucugcauccauuaucuccuaauuuuuuuuuacaacaguugcgcaag\n", + "ggugcaagguucccccucucacccgcagcuguggagaggaggaagcggaacuagagaugcccaucuggagugagugcaggaccag\n", + "ggaaguuuaaauuccgcucccuccacgaaagaguuguagugagugaaaauaaauauuaaaacacacggaa\n", + "ggcgaaggucagaaggccgaauuggcpagaauagguuuggugguccgagauccgaggcaacgguggcuccucgagguccacggucccgg\n", + "gcgaaggucagaaggccgaauuggcpagaauagguuuggugguccgagauccgaggcaacgguggcuccucgagguccacggucccgg\n", + "ggcuaagguggcccccacugaagacuccugcuaagcaacccacugaagaccccuccgaaucaucgacpcguccuupugcagcccaggaagcucaguucacag\n", + "gccaggaaagcagagacagacaaagcguuaggagaagaagagaggcapaagacaagccaggcacg\n", + "agccuuauaagcugapaguggagaggcccpccaggaaagcagagacagacaaagcguuaggagaagaagagaggcapaagacaagccaggcacg\n", + "paccccauuucugugcucaucugccuccuuggcaauauaaagagcaagcacugaggccccgccucagagcaccccaaacuugacgcc\n", + "guacagcaaaugguuucuucccauuugcuagacagapcuagauuuuccccgcccacucucgacucuucag\n", + "gaacaugaccaggacguuuagcapagugagccccccaccuggucccagagaagapagaucugagaagacacugag\n", + "gagccuucggcugugcuguggcuccucucucapacagcguaggcccupucaguuggagapcucugacuaccagcgacugcucupugucugcgaucaaggacgauccugg\n", + "pcacccugauggacuucucucagugccucccuguccugcguuuucuuugacucuuggcauauccccugc\n", + "gcuguggcuccucucucapacagcguaggcccupucaguuggagapcucugacuaccagcgacugcucupugucugcgaucaaggacgauccugg\n", + "gaggacaucauucugcugapaacugcacgucaaccacuaccgauucucccugucuuggccccggcuccugcccacaggcauccgag\n", + "ccgagcaggugaacaagaapaaucgaauucuacagugaucuuaucgaugcccuucugagcagcaacaucacucccaucgugaccuugcaccacupaucugccacag\n", + "agagccuucggcugugcuguggcuccucucucapacagcguaggcccupucaguuggagapcucugacuaccagcgacugcucupugucugcgaucaaggacgauccugg\n", + "aguaguguuagacugaagauaaaguaagugcuguuupcuaacaggaucuccucuugcagucugcagcccaggacgcugauuccagcagcgccuuaccgcgcagcccgaagauucacu\n", + "aucccgccuugcgcaugcggagaagguaaaccagcgccccgaguugaggcgcpuuugguggcgcguuucagcgaagucgcacgugaaggauagcaguggccugagaaag\n", + "cuguagaaapcggagagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "upacuguagaaapcggagagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "aaapcggagagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "cagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "gccupcaauauuuaapaaaguauaaggapacacaggagguccagcugucuggaagacucgccugcgcugugcacucaacaagaguucugaauuuaaggagguuccugagapccgc\n", + "gcggagagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "pcggagagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "gagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "ucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "ggagagaucagccgcccagccaggaguuaagcugaggucgucugagcccugcgacagccuggacagcaacucag\n", + "gguupaucugapuccucucugugcccaucacaguuugagcuucapaaaagaagaagaggucuuugcccuucguuuuuccacpaggagaau\n", + "acauagacucagcucaggagcucugcagcacacagcugaucgaacccacucauuucuagaggacacc\n", + "cugcacacgguuuucagccucaugccuccguggaaccugccugucaggcpcaccuggaaucucaagcaacuuucucaag\n", + "aapccaaggcguuaucgucggccacgcacaagauuucucuccaaacaacucacagcauugagagaauugcuugaaaagacc\n", + "gccauuugucuauggcaggcapuggcugccuuagcugccggagguuccgcacucucuaaggccccpugaagccccaccucugcugcgcgcagccugcggugcpuc\n", + "ccauuugucuauggcaggcapuggcugccuuagcugccggagguuccgcacucucuaaggccccpugaagccccaccucugcugcgcgcagccugcggugcpuc\n", + "cugugcapcuccaugguuccuagaggcaaggaagaagagccaccagucaaauagguuucagcaccuccaacuccaacaucuucaaag\n", + "pcuccaugguuccuagaggcaaggaagaagagccaccagucaaauagguuucagcaccuccaacuccaacaucuucaaag\n", + "ggaauaauuucaguaggauuggcaccagcucuucuuuauaugucugguagaauuuggcugugaauccaucugguccapccuuuucug\n", + "gaacuguupacacagugacuaaggcaaaauaugugucaaaagaaagcagucaaaggaaaaapaucaccuuuggugaa\n", + "acupcggcgcuggcuggcucccuggcugcggcuccucagucggcggcggcugcugcugccuguggcccpcggcupagaagcggaguguug\n", + "augugugcuguuucucuuugcuuuugccacuacuccacucugugcuugaaauucugugacucuucccu\n", + "cucacugucuccaagauggcggccgugucaguuupcaucuccgcgguccggcccpccccpaucucggcuguccuuccucccg\n", + "acugucuccaagauggcggccgugucaguuupcaucuccgcgguccggcccpccccpaucucggcuguccuuccucccg\n", + "ggagcucacugucuccaagauggcggccgugucaguuupcaucuccgcgguccggcccpccccpaucucggcuguccuuccucccg\n", + "gauucuuucuacuaauccagauacuuguugaagugcugacuaguuucuupaaagaugucaaggaagaguugaaauuccuagacug\n", + "agauguaacagaucucucuaugucuacaucccaacuccagaaaacgagaaaucgaguuccuccucucaccaucgaagcucugcagacaccucgcuggagacccc\n", + "cacuuccuccucaggcgcuucuucucugcacccuggcagcccgupaguucpaapcccuggaugccuuuucugcuuguuuuuga\n", + "agagccacugaggccugagcgagagccgacggcpcpcgcagcugcugccggagcgccggcgcgugcuggupccacacaccuuuccuccucuucacucgcgagcccucggac\n", + "cgagagccgacggcpcpcgcagcugcugccggagcgccggcgcgugcuggupccacacaccuuuccuccucuucacucgcgagcccucggac\n", + "cuacagcucuugccaggcaaggcagccgaccacaggugagucuuggcaucuaccguuuucaagug\n", + "gacucugauuuucccgccgaaagcguccccuuggauuggcuacuuuaaauucagaguacgcacacgccgauuugcccuuuugauucuuccacaaucagg\n", + "gucaucaaacccagaaauugaaggaucuupccugccuugauguucauuucucucaucuauaaaauugaaggcuggaggag\n", + "acuccuccguuuccgcggucgaagcugccuucggccccpuggucucccccgcccpacccccugugccuccccucccpcugcpagccccuccgagacc\n", + "acacucccacuccuccguuuccgcggucgaagcugccuucggccccpuggucucccccgcccpacccccugugccuccccucccpcugcpagccccuccgagacc\n", + "auuggugupaagagccugccugupagcggccacuccauacugcugaggccucaggacugcugcucagcuugcccguuaccugaagaggcggcggagccpccccugaccggucacc\n", + "uuucccugcugagugcccccucccaccccucccacuccacacacacccuguuugcccgugagccupaacuugcagcuuaaagccagccacccccacggcaac\n", + "augucauccauacuguapccaauagccapccauauuaaugguucccacaaggaagaccuugcaaauugcuauaaaucaucucugaagcucgugaaagaaaauaacauccgaucaguu\n", + "gcuuucccaacgagccugcugcagucauugcccucaacaccauuaaggaauggcuugccaagaaucaccaugag\n", + "ugugugugcaguaugaaaauugagacaggaaggcagagugucagcuuguuccaccucagcupa\n", + "ugaaaagacaugugugugcaguaugaaaauugagacaggaaggcagagugucagcuuguuccaccucagcupa\n", + "gugcugupagguggaguugccuuugaugcaaauccuuugagccagcagaacaucuguggaacauccccugauac\n", + "cucucuccccagccuucauguguuaaccupaugauguggaccupcacuguggaugcuccccucacucugcaaauucagccuggcag\n", + "cucugccagcuaagccugagaacauuuccugugucuacuacuauaggaaaaauuuaaccugcacuuggaguccaggaaaggaaaccaguuauacccaguacacaguuaagagaacuua\n", + "agagcuggcgcpaaapagauaggugucuccagcugcuguggcuguuupcpucggcuucauccgcgucucaggagcaaguagagaauuagcpcggcagcaaugcuccgcaag\n", + "gcpaaapagauaggugucuccagcugcuguggcuguuupcpucggcuucauccgcgucucaggagcaaguagagaauuagcpcggcagca\n", + "ugagaguaacacaugcgcacuguggauuccuuugugaauacauaaaaggaaaaguuaaaacucuuauaauucacacuauccagagaaaaacaauacuauuuug\n", + "agaugcagucagagcauccucaggcacauuaauaauggaggagucugacaagagcagcuuugccugucuuuguuuuccacuguaggugaapagac\n", + "ggcuaugcgaaaguucuguccaaaggcugcucacagccccugucugacugguugucaugaugaauugagcucucuguuaccugcgcaucacaaccg\n", + "aaauguaguucucpccapagccggcacggaagcggcugugcgcaugagcagaugaggccuagccgaggcggcpacccccaaguuuggaaagcucuuuuaacg\n", + "ccggcacggaagcggcugugcgcaugagcagaugaggccuagccgaggcggcpacccccaaguuuggaaagcucuuuuaacg\n", + "ggaaggcaaagguagagcaacuggaucucuggcucuccacauagcuucugaucucagaccuuacuaaaaugcuuucupcccaaggacaaagcucacaugaacaaaugauuuugaguc\n", + "ggaagcggcugugcgcaugagcagaugaggccuagccgaggcggcpacccccaaguuuggaaagcucuuuuaacg\n", + "gcuaugcgaaaguucuguccaaaggcugcucacagccccugucugacugguugucaugaugaauugagcucucuguuaccugcgcaucacaaccg\n", + "gccgagcguguuggcucaugccuguaaucccagcacuuuggaaggccgaggcaggcggaucacgag\n", + "acggaagcggcugugcgcaugagcagaugaggccuagccgaggcggcpacccccaaguuuggaaagcucuuuuaacg\n", + "gcggcugugcgcaugagcagaugaggccuagccgaggcggcpacccccaaguuuggaaagcucuuuuaacg\n", + "ggugcgaaguaccacauuacugucaucucccugugagupauuggcaccccggcugcagcuccaggagcaaguacuccaggaagcacagagcuguaccaguacacggcccacguugccag\n", + "cuapcuacauagagaacauccaaaggaacagcagcuuccauuaaagauuaguucaguugcuucaggugaacagugacugaaauuuacaggaccuuguaccgagagagacaag\n", + "agagcacuguccgguggugcccaggaggaguaggagcaggagcagaagcagaagcpuccggagcugcgcgccuacgcpaccuguguccgaa\n", + "acuguccgguggugcccaggaggaguaggagcaggagcagaagcagaagcpuccggagcugcgcgccuacgcpaccuguguccgaa\n", + "cacccucuccgccuuucccgacaccccaaaguagcgcugcgagcagcugcgucucccucccpcucgcgcgcccagaacccuccggucucaaggaagcag\n", + "aaagcguuuggcaucccugccauauggaugugucacugugugagaugacaacaggauuugcuggaaaugupccacuauuguauccgccuuacguaaccacauggagugauggaaaugg\n", + "aucugcugaaucaggaucacccaapauccguuugcacauuaacgucugagaaguacuggccuag\n", + "agucuugcuguguugcccaggcuggaaugcaguggugcaaucucagcuuacugcgaccucugccucccggauucaagcaauucuccugccucagccucccgaguagcupauuacag\n", + "gaggaagaagcggaggaggcggcucccgcgcucgcapccgugccaccugcccgcccgcccgcucgcucgcucgcccgccgcgccgcgcugccgaccgccagc\n", + "gacuguggcaggcuggagcuguuuucaaggccuccuucaccuaggcugugcauacaaaagguugaagaaaguauaaggagacuuaauggacgcuuguuggacagacaucacgaagcuuc\n", + "ucgcgaucguuucuggaccgcuuuccacucccaaaucuccuuuaucccagagcauuucuuggcuucucuuacaagccgucuuuucuuuacucagucgccaau\n", + "gcgguagcupaccgccguucagguaagaaupccuuggcuggauccgaapcuuguagcagguuggcugcp\n", + "gacacgcagcccacggucuguacugacgcgcccucgcuucuuccucuuucucgacuccaucuucgcgguagcupaccgccguucag\n", + "aggcaggugcaggcgccgcpccggauccuccgcgcggccgaguccaucuccupaaaupcggacaguguuuccuugacugacuauugugagcgcccucucucuccggcggagcggagacc\n", + "uccaggcaggugcaggcgccgcpccggauccuccgcgcggccgaguccaucuccupaaaupcggacaguguuuccuugacugacuauu\n", + "gcaggugcaggcgccgcpccggauccuccgcgcggccgaguccaucuccupaaaupcggacaguguuuccuugacugacuauugugagcgcccucucucuccggcggagcggagacc\n", + "ggcaggugcaggcgccgcpccggauccuccgcgcggccgaguccaucuccupaaaupcggacaguguuuccuugacugacuauugugagcgcccucucucuccggcggagcggagacc\n", + "uuccguguccaggcaggugcaggcgccgcpccggauccuccgcgcggccgaguccaucuccupaaaupcggacaguguuuccuugacugacuauu\n", + "ggaaaacccuuggaugcuucauaguccuacuucuaggcaguucugcaugaauuucugguaauccag\n", + "guauuugaccuguccaaagacgacuugauaccucuauaauguaacagaaaaggucagaaaauauuaagcaaguagaaguguggagcauauuaagcaag\n", + "aauuaacacagaagacuucugcagccaaauguguggagauuuuccccuaccaacaagcaaguaaugaauucugcagcagauaccag\n", + "aacugacaggaaaauuuuguuaugaagacagaaauugcaggacuuaaaaacccaucuuagaggugauagaagcuguuauugaap\n", + "guccuuugcugccagcaugaugucguauuuauaauauguggaggagagagagcucaccaugcucag\n", + "aaucugaugaccuccgapacccugcacucagccaucaaaguguuccugccccucuggacacucauaauuca\n", + "guccuuugcugccagcaugaugucguauuuauaauauguggaggagagagagcucaccaugcucagguaaapaugguaugugcaccacaaauaacaagcag\n", + "cagaaacaccagaagucacagaagaucgccagcccaauucucugaguuccgaggagccuccaaccag\n", + "ugaagaucaagucggucgagaggacagcgcacuugcccgcupccgcagacccggccaacacagccugg\n", + "gaacggcpacggcpaacagcpacggcpaacagcpacggcpaacagcapacugcpucgcguccuggccgccgag\n", + "gacgcpacgcpacggcpaacggcpacggcpaacagcpacggcpaacagcpacggcpaacagcapacugcpucgcguccuggccgccgag\n", + "gucacucgcaucuggcuaccagcuccccgcugcccugcgcucggcpcuggcaucpcccpaaagcggagcag\n", + "uucgguguagcacuguuugcggcgaggagaaaggaaggagaggagaaaacugcacuggaucaaggag\n", + "gucuucccauaggccugcaguapcuguuuaccauuggaagcaapaaagaggaggagaucaaucuagaagcauggag\n", + "aucugccugcaugucugcugcapcuuaagaucacuggaagcaaagaaacaaagaggagauugcuccugaucaguauagacug\n", + "acucgcaucuggcuaccagcuccccgcugcccugcgcucggcpcuggcaucpcccpaaagcggagcag\n", + "uaguucgguguagcacuguuugcggcgaggagaaaggaaggagaggagaaaacugcacuggaucaaggag\n", + "gucpaaauggcggccgcggccpcupcuucagcpaggcagcagapaaguggucagcguggcgaaugacggaag\n", + "aaacucgcauugucuacuggaucaaggacagacagcucaccaaccgugacagcaccauacuggaacuucaaaaaguucugaaaacauguug\n", + "ugcucagagcaugaaaauuuucugcugucuuuggaacuuugucuacaaacaguuagaagaugcagcccaapcucaccaupuggcgauguugaagaacaug\n", + "guccagagaucucaugaauuuauguaucuacuuuapuguacugccaagagaagcaagaggagaggapaacugccucggaucauuacag\n", + "acgcagccuucguugcagucgucacucgcaucuggcuaccagcuccccgcugcccugcgcucggcpcuggcaucpcccpaaagcggagcag\n", + "uaguucgguguagcacuguuugcggcgaggagaaaggaaggagaggagaaaacugcacuggaucaaggagguuagu\n", + "uccugcupccacaggcgagcgcuuuauuucuggagcugapcuaaaacuuuuuugacuuuucuucuccucaacaucugaauc\n", + "gccagaaagcagauuuucacuupaagagacgacccguaguaupaugugguaugauaccagcaacuggucuauuauaucauuuaaaccacauggcuaucuaaagag\n", + "guauuuggcuauuauaaauaaaauagugaugaacacguguacagguguuuguacggacauaaguugucauuucucuugaguaaauaccuaaaagupcuugcugg\n", + "guuccacuugaccgcucuaagccgccgcgcagccugcguuuucuccgguacagguugaggcuacuaag\n", + "ccauuauacuugcccacgaaucuuugagaacauuauaaugaccuuugugccucuucuugcaagguguuuucucagcuguuaucucaagac\n", + "uaucupcucuacaggacagacaugccuccauuuaugcaacaaauaagaacagcaucucaugacaguggagaaaacaupaugugcagguag\n", + "agcccacaggcgguuuugugagcugcuuccccaggagcagcggagcguggagucgucacuucpcacaagugcccuucgagcagauucucagccuuccagagcucaag\n", + "gaugacuucuucuucccucucugcccacacuuacguuguaugugaccugccuuupuuaaacacuugacucccaggaagccaucucagucccuuccccagcugg\n", + "acuuugaugaugacggaaccuugaacagagaagaccugagccggcuggugaacugccucacpagapcgaggacacacggcuuagugcgucugag\n", + "gacccagaugcccuguccaaacagupacaaugguuggaaagcauupcuaccucaguacgagaaccaccug\n", + "uauccauaguaaccgaggaugcgapcgcccagcagcagcgagugccupagccaggaggag\n", + "guuuuaaaaaucaauuugauuggccacaggaaacguauuuuggcaucucupagacaggcugcacgacgaucccccacagaagcccccucgguccaucacccucagg\n", + "gaacccagugguaaucacacuccuccucaguugucuccaucacuuagccaaagcacuuacaccacugguggcucccuagacguuccucacauuauc\n", + "uucagguuuuaaaaaucaauuugauuggccacaggaaacguauuuuggcaucucupagacaggcugcacgacgaucccccacagaagcccccucgguccaucacccucagg\n", + "agugcuaggcgcccugcagcccccgcgcgccgcgccupcccgcaucgcucucgcagugapuccgcccgagcg\n", + "cagucgucugucugugaaauauggacgaaucagaacgcaggauuuccuuucucagcgauccaucagguucauaau\n", + "guaacguauaaccaguaugaagauucaauucagauuuaagcacuuugguuugcuuuugaaucuugcuauuuucugcauuuguuuugacugcucucaucauucaagauugacgcuugg\n", + "ggcgaugcaaggaggagaagaaaugaaaacuacuuugaugauauuccccgaucaaaacuggagaggcag\n", + "cuuccaggagccgucguagcagccgauuaggacuggcugcugguguggugaugaccuagapcuucucccagguaag\n", + "uguggagcuggcuggaaucucucagccucaccugccagacaacacccccuccuuccucacccugucuccugcauucuccugaaaccuucauccacaca\n", + "acauccugucucuguguguggagcuggcuggaaucucucagccucaccugccagacaacacccccuccuuccucacccugucuccugcauucuccugaaaccuucauccacaca\n", + "cuggaaucucucagccucaccugccagacaacacccccuccuuccucacccugucuccugcauucuccugaaaccuucauccacaca\n", + "cucucucagcucuccgucucucuuucucucucagccucuuucuuucucccugucucccccacugucagcaccucuucuguguggugaguggaccgcuuaccccacuaggugaag\n", + "cuuucuuucucccugucucccccacugucagcaccucuucuguguggugaguggaccgcuuaccccacuaggugaag\n", + "ucagccucuuucuuucucccugucucccccacugucagcaccucuucuguguggugaguggaccgcuuaccccacuaggugaagaugucagcccaggagagcugccucagccucaucaa\n", + "guccucggcagccugaucuucugcuucggcaucuggauccucauugacaagaccagcuucguguccuuu\n", + "guccucggcagccugaucuucugcuucggcaucuggauccucauugacaagaccagcuucguguccuuugugg\n", + "augcccagaggupuuccaguagaucapucccuuuagaucccccagcgccugagacauggagaccupapacugccccaugaguccuuggugcccacaaauuccaaggccccucag\n", + "pacucccucugccacauuuuuuggagguupaaaguugcuagaggcuucagaacuccagccua\n", + "cpcgugccuggccugcpacgcgacugaucgcagupcgaagcpccggagccgcccgcggucag\n", + "gcagcpagcggcpcgugccuggccugcpacgcgacugaucgcagupcgaagcpccggagccgcccgcggucag\n", + "agacgcccggcgcagcpagcggcpcgugccuggccugcpacgcgacugaucgcagupcgaagcpccggagccgcccgcggucag\n", + "aggaupuggagcapaagagccaggaupagaaguuapuccugauggccauuaupaauagaggcupccaacugacuggcccpca\n", + "auagguucauccuauguuccccaaguuggucucaaacuccuaggcuccagcaauccuccugaagcccupauuacag\n", + "agagccugguugcagccacuugugcgaucccggaccuugccgcggccgccuggcuccuuuccgcgcc\n", + "cucccuccuagagccugguugcagccacuugugcgaucccggaccuugccgcggccgccuggcuccuuuccgcgcc\n", + "ucuuccuccguggagcggagagcgagacagagcuacagcgaacgagagagcggcgaaggcpuagapcgcpcgaggcggcgcagccauccccggaccapccgcgccgccacc\n", + "aguuuuugugcaapccacuagucpcucugcccgccccucaucuucucuucucucucccucccgcucuccccccaaaaccccgccaguggcucacgccuccugcauacpaugag\n", + "gugauggcaaccccaaggaaagcagucccuucaucaacagcaccgacacagagaapaaaggaguaugauggcaagaac\n", + "aaugaauuaggaggcggacgccggugcpcuccaggcuggcupuaccccucccccgcaccuucuacgaccucccpuuugcaccuguccpcaccaag\n", + "uaaaaauuugauccuaagauucuauaaaguagccauugaggcuuaccaaaguuacaauauuacagauggaucag\n", + "ccccacagugaagaacaucugagcucaaauccagauaagugacauaagugaccugcuuuguaaagccauagag\n", + "pcpcugcaggcuccgagcgauaaagcgcpcgcupaggcgcguggagccagcggagcugcgccuaaggagccpcc\n", + "cuuccugagcgucgupuaccugguacgucacagccaucguuaucaucaaguacaucuggccagauaaagag\n", + "guugagaagaguccuaagcuaacagccccaaacaggupuguugcucagcucccugaggcaugugguuguaaggcagaacccacagaccuugcaggaagaaggcucucpcc\n", + "aaauupuccagaaapaagugaggagaaucagaucccagaccuuupagaaggagcaaccgccucuggcacagcccaucapagaaagagcag\n", + "gcggagccgcagacuccccuggccccggcgcggccccggcagccgcpcuaaggagucgcgagguucccccagcugccacc\n", + "cggccucaggucccggcccugccuucuacacugccccaccgcccugcacccuccacccggccaggccccugcccacgcugucuaccgucccgc\n", + "pagaagaauagaacgauucuucagaaaugagagcacuuacaauuauaaacagcauucucuuucauuccug\n", + "gaaccauagcagcugaauguccugaaggaauauuauupcuuupauguuucaaaaacucucacagagaagaugguccaauugucaucagagcuagguuccagcuuaaauuuacucag\n", + "guacaggauuaucauggucauaaaauuugugacccuuacgccuggcuugaagaccccgacagugaacagacuaag\n", + "gccuuuguggaggcccagaauaagauuacugugccauuucuugagcagugucccaucagagguuuauacaaagagaga\n", + "ggaaguugaaagaauggagccucauacuguauggcacagcagagcacccguaccacaccuucagugcccaucagucccgcucgcgg\n", + "gagcggcuuuaaaaggcggcacuccaccccccggcgcacucgcagcucpcgccgcgcgagccugucgccgcu\n", + "acucgcacucacacccpcgcaggaggcpcggcccpccccaccggccccccauggacgcccccagcacpcgcugagacccccgcgucgcugcccagcccgguccggcgcgccacgccgag\n", + "acauuuggaguuaaggcupcaggagagapaupaaauaaacaugguggcuuagguuggcacugcuccaggucugcaauguagcaacug\n", + "gugcacgcauccaugugagaguguuuuugugcaugugupcupapcucugaauaucuccuggaacgguacccagagcccuguggcucugcgcaugcp\n", + "gagagaagaaccugcauuagccguuuaagugugcggugcuggcagaguaccucccugaagguguccupaaa\n", + "agcgcggcugcuggugccguugcpagaagaggaagcggcgcguccccugaggcgugcgccuggauggacugaaggacgguccgacgcgcgcggapagapccapcgag\n", + "uuccaaaacuguucucuggagcuauaaguggauugccagaaaugagagauuaggagcupagaagaggaagcgccuuguguugugucuccuggaggcugccgac\n", + "gagccccggcgcpcpuucupuguagacgcugcuggccagcccgccccagccgagguucucggcaccgccuugagagcuucagcugccccagg\n", + "auuagaaucccaagaaaaucaaauggcauccpauuucugcucaccuggagaapauggaaauacuucaacaag\n", + "agaguaugccacaacuucuaggaucaggaaagaccucuccuagcuuccuacuggauaucuuuauuagcauuuuuguagauucugugaaaaagaagaaauaaaacgaaaucacccacauuuucaaa\n", + "aaacaguauccacaguggacuccpcuccuacagacuuggcacagcuuccuacagucuugaaacagcccuguuguucuguc\n", + "guuugaugugugaauaauuacauugacugagaaagaaacccagaagaggaagaagaggaaggaaaaggagucagug\n", + "gagugugugacccagcccuucccccguggccaagcagagagaguggccuugaggaagccauagcagcaggaccagc\n", + "cacaaugccccaccguccccaacucucaaguggccgacagupcaguccagaagcupaccagacucaucugcccgapcacaguaggapacggapaucucccaagagcuccgapcgag\n", + "uuuggaagaacugaaguaauugauaauacuuuaaauccugauuuuguaagaaaguuuauucuggacuacuuuuuugaagaaagagagaaucuucguuuugacuu\n", + "gacuuucupacaaguguuuuguacauupagagaucguugguucacapaagucgccuggaaaaaccaauagu\n", + "ggauuagaagaguuguuggaggagcuaggccuapauaupaggugupuugaauaucuapcupagaaucggaagguauuggagcuauuuggaguggcagagauggugcaggag\n", + "gaugauuupaggaagacggagaaacagcaaggauuauauuuuccuuugaagaguugcupaccuuuccuag\n", + "gagaaccggagccuuaccaucaaacuucggaaacggaagccagagaaaaagguagaauggacaagugacacuguggacaaugaacac\n", + "agccuacugcgcccgagucccgcggccccaguggcgccucagcucugcggugccgaggcccaacggcucgaucgcugcccgccgccagc\n", + "acagccauuggucapcaaauaccacuagcucugcauccucagucacuuugugccauuucaucaggucagagccaaag\n", + "cuuuccgccagcgcccgcaggacccggaugagagcgcacgcuucpucuccpaagucgcggcgccuucggauguggcggaugcggccgugagccggcpag\n", + "uuccuccagauccagcuggugcccucgccugacguuugaacgaccaccugcucaccuccucccuuuugcgcguugauucuucagacuucaaapcccaccg\n", + "gugcugcugcugccuccacuguacucagacccagguagcacaggauuguccauccuccagcagcucagugcaacggugugaacucagccuguuucagagccuccacacc\n", + "gccagcgcccgcaggacccggaugagagcgcacgcuucpucuccpaagucgcggcgccuucggauguggcggaugcggccgugagccggcpag\n", + "ccgcaucugaucupcgcuccpaapcgagacuggagcagagccgcupcgccggagccgaggcgagcgccgcgcgcaccacug\n", + "aucgaucucuuupcugccugaccuccuupugcuugcuauuaauuaacagacuuugupaaaaaaaggagcuugccuucugagcuuuguaccaaagaccupaaaa\n", + "cuaaccaucucagucuuuccugaggacuupaacugccgaggccucugccaauguguugacugucgcuaupcucacuguuguccaggcagcucau\n", + "ggauuuugcuuauguagcaagagauaaagauacaagaauuuugaaaugucauguauuucgaugugacacaccagcaaaagccauugccacaagucuccacgagaucugcuccaag\n", + "gcacapauuuugcuuauguagcaagagauaaagauacaagaauuuugaaaugucauguauuucgaugugacacaccagcaaaagccauugccacaagucuccacgagaucugcuccaag\n", + "cucaaguaggaagcuagugcgcuguaaccgcaucugaucupcgcuccpaapcgagacuggagcagagccgcupcgccggagccgaggcgagcgccgcgcgcaccacug\n", + "caaguaggaagcuagugcgcuguaaccgcaucugaucupcgcuccpaapcgagacuggagcagagccgcupcgccggagccgaggcgagcgccgcgcgcaccacug\n", + "gaucupcgcuccpaapcgagacuggagcagagccgcupcgccggagccgaggcgagcgccgcgcgcaccacug\n", + "ucucacucugucaccaggcuggagugcagugacgugaucucggcucacagcaaccgcugucugccagguucaagugauucuccugccucagccucucgaguaacuggaacuacag\n", + "gauuugccucaaapcacugcaaaaauugaacagaggaaucccaaggaagcugccugaauuugccuguauacucucguucugcgacuuauaaaggaccagacaaaucaaauuagugguuuug\n", + "cucagguaacggaggccuuggaaagagacucugcgucaggucacccagcagagaucagcaauccuuggcucacugaggag\n", + "cucagguaacggaggccuuggaaagagacucugcgucaggucacccagcagagaucagcaauccuuggcucacugaggagguuug\n", + "agucagacccaggaggagugaggucaauugcccuuuagucccaggacuaaccggaagcuucugcaacaggaggacauugaaaauaagauggaacccauccacauaag\n", + "gucacagaauucgauuccuguuggcccauuccgcgccuacaaacaggcuuagcgcuccacugaaaugcpaggcuccuuaacucuuguauaaacag\n", + "agacapucucacuauguugcccagacuggucuggaacuccugagcucaagcaagcuucucaccucagccucccaaagugcupauuauaggcuucagccaccacgcccaaccagccag\n", + "ccgcgccuacaaacaggcuuagcgcuccacugaaaugcpaggcuccuuaacucuuguauaaacag\n", + "aguguugguggacuggcuuggaagcaguucaguuuggaagccugauuggagagcucacgagaauagaaagugaggacauaaaggca\n", + "uugaacacauggaggcuccuaaagagugauguuccuggagapccuggaagcucugcaccacuucccacaugucuggccccaugcaucucuucaucu\n", + "gcuuugcccaggaugguuccuucuggaaugucuauuccccuccuucccucccugaagcucuuugucapacaaagguaggaucccuccccuuccgucuucuccacugg\n", + "gagaaaagccauggccggugagucuuuuacuguuccaagaacaggucccupaagaaagaguuguggaaapcuggcucuucuggaagccauaauuaguaucuguggaaguuuag\n", + "guucccucccaggaauccgacacgugacggucuguccgccgucucagacuagaggagcgcuguaaacgcc\n", + "acacauacacgccccauupagcagcuguggagaugugaggacagugaggucugcuauucucccag\n", + "gcacacagccapccgcccpcucucgacgcgccgacggccpcggacggacggacggacgccgagcgcagugccccgcg\n", + "gaggaugccpaapcugguggucpccuagagcggcgguugcacuuaguugcggcugcugucacc\n", + "ggcugaggaugccpaapcugguggucpccuagagcggcgguugcacuuaguugcggcugcugucacc\n", + "guccccgcccagcaccccucgcaccaggcggcggcggcggaggaggagagcuagacccgccgccpcacaac\n", + "cauucaucccaggcuuccagcucagcccgccccaggccaggugaucggccgccacauccccugcgacugaagcaccugcuccucc\n", + "aggccugaaggacgupacacpccagaguggcuggccccacgcacggacaggagugaacccgagcu\n", + "gucgcggacuggcupcgucucggcgcggcuggcggcpccggccuaagcgcgcccgcgcacccaucugcccccguccuaggugccgaccaacccccagg\n", + "aggccucugcuggcaugagcccuaagugccpcacugaccacagccggcggccggapucaggapccuuggaggag\n", + "aaguaaguuuguauuuuaccauagauugauguucauguuccugacacuacuacaagauucauacuccugaugcuacugacaacguggcuucuccacagucaccaaaccag\n", + "ucucacucugccgcccaggcuggacugcagugacacaaucucggcugacugcaaccacugccuccapuucaagcgauucucuugccucagccucccaaguagcupauuacag\n", + "auugauguucauguuccugacacuacuacaagauucauacuccugaugcuacugacaacguggcuucuccacagucaccaaaccag\n", + "gaauccaccuguuuuucpaguuuguacuuggcaguguguggugcagccagcauccggccaggugugcgcuugcaaccgugcgaaagcccugccgcac\n", + "auguuaucugccaggagcuuuaacuucaugaauguuugaaaccupagcgagcgcuguggcccauucucaag\n", + "cpagauacagaugacccaccaagaauuacucagaacccugugaucaaupaauguggcccugagugauggacacaacaccgcggaggaggac\n", + "agcugcgccccgccupuugcucuugaggagccaaacuuugccagauuaggcugacagugagaaaauaaauucuuccacgguagauacupugaaaaagugcacgucagcpcaagg\n", + "aaaaaauaaaaaagaaugcugagguagagcuccuagagauucuaugcagucacucugaugupugagagaaccucccccaucccccagcagaggccacugcagagccaugcagag\n", + "aagaacaagauugcacucugagagaaggaaggcauggugaagaggugguguuguggupccuuaaaguaggcuuaggacuugagcucpauuuggag\n", + "cpagauacagaugacccaccaagaauuacucagaacccugugaucaaupaauguggcccugagugauggacacaacaccgcggaggaggacauggaggaug\n", + "acaccaguuggcgcuccgaggcaaccuuucaguucacuguggagcgcuucagcagacugagugagucgguccuuagcccuccguguuuugugcgaaaucugccauggaagauu\n", + "aacucgaacuccaggcugucauggcggcaggacggcgaacuugcaguaucuccacgacccgccccu\n", + "acucgaacuccaggcugucauggcggcaggacggcgaacuugcaguaucuccacgacccgccccu\n", + "gcugacaaacpcucaucauaaugcacuggaacgaaaacguapaccacaucaaagacagcuuucacaguuugcpacucagucccaucacuccaaggagagaag\n", + "gcaucccpcccaaauccuagacaaagccacagaauauauccaguauaugcgaaggaaaaaccacacacaccagcaagauauugacgaccucaagcggcaga\n", + "gcuuaauaaaucccaauccagccuagcugauuuacugaagaacaaapaugacuaguuuuugcuacgccaag\n", + "puucaacagaaauauuuggugguuaccugcaacuaugaagcuaggaaacuuggaguuaagaaacuu\n", + "gaguucaugaucaaguguugcccacaccaaaugcuucauccagagucauaguacauguggaucuggauugcuuuuaugcacaaguagaa\n", + "agaagccagcugagagcgccugcgcggcugucgguugaupaggucaggucupaaacuaggcccupuuuucccugagcaggagcggugcccgapccucag\n", + "aggcaccpaauaacagaagccagcugagagcgccugcgcggcugucgguugaupaggucaggucupaaacuaggcccupuuuucccugagcaggagcggugcccgapccucag\n", + "gaugacuugaaaguapcauccuucacccaucugaapaggaaauaguggcaggugacagucugcaugugcaguuuucag\n", + "augccuucaccugaaugacaucuaccuccaucaggaccccagaugucugacagcccugugugacaccaagauaaguaac\n", + "gagguugacaaacagccuuuucpaaupacucgaacucguaagccacgucuguuccuccauuucccgccucagcuggaugacggagapaucuccpauuaaagaacaacgaccgcag\n", + "gugccgucauuuaauuucccagacacuugaccuccuucugauuuguguacucccuccaaggcugaguugca\n", + "aaucuggcugcugacuacccuauuggacaacuccaauauuagagaacauuuccaccaauucagaaaguuuauuaugcacugcuguucuagagcapaucagcaaacuugcuguaaagagccag\n", + "ugucugacucuguagcccaggcuggagugugcaguggugcacuaggcucacggcaaccuccgccuccggcucaaacgauccucagccccguccuccguaccag\n", + "agaggcaccgccccaaguuuguugugaccggcpacgccggugguggcggcagcggcggcugcpcaccpccgcggcgccacc\n", + "gcgccgccgagcgcccugaggacucagcgaapupcgccgccgaggccuccugccgcuggcpuuuccgcggagugccgcccggcuccgcucugccgccggcgcggcuc\n", + "gaggacucagcgaapupcgccgccgaggccuccugccgcuggcpuuuccgcggagugccgcccggcuccgcucugccgccggcgcggcucaupcagagucggccpcpccgg\n", + "cuuggauccucuggugauccaagccuuccuaccagauaugaaacuaggacauupucaucuupcgcauguaacag\n", + "ggapugagaacccacggapaggaacgaaacuccgaugaagucagagccccuuacccgccgccgcggccaggccccccaac\n", + "gucccggccagaggaggagcucgcugccpacgcupcugagcggccggcggcgcpcccggcggcggcggcagcpuccpuccggagcgccac\n", + "gucapaagucaaagaugcaucccugaguucuuccuagcaggcaagcagccgugcaccaaugac\n", + "cugcuuucaaggugucuagauacagagugaagaaugucacaguaggaagugcacuggacuapagucaggagacccpuucuuguguuggcaccaucacuc\n", + "cucccggaagcggagcaccgagccggcaaaggcuupugugagacagcagcgguggcagacaccgcagaagcaaagagcagugaggcuccugcauucpuggagcacc\n", + "cgagccggcaaaggcuupugugagacagcagcgguggcagacaccgcagaagcaaagagcagugaggcuccugcauucpuggagcacc\n", + "auuggcugccgcgcpcpagcpucggcucaguggcccugagacccuagcucugcucucgguccgcucgcuguccgcuagcccgcugcg\n", + "gacuucagagcupccugcgccugcpccguacgaguuggcccggagcaaggcggcccaggacaggcapcugcacgcg\n", + "gugaagaaaccaagacgcagagaggccaagccccuugccuupucacacagccaaaggaggcagagccagaacucacaaccag\n", + "ggauuuuugugauccgcgauucgcucccacpcpaccuuuguaacugcpaggcccaggacaggcccacccugcpcpaggcagccpugapag\n", + "gcuucuuucccagccugccuccuggaggugaacaugugcagguggagaagugcccacugcaucpccaaaagag\n", + "agaacgcugccuaccucaccccaacggcauuugaaaguagacuggcucaucugaaaugcuuauuugcaagcaucuaacuuccugacccugugucacagauggccccacuuggccccaagccccug\n", + "puugucaggcagcgcgcgaggcggcpcagcuagcagcuggcggacgcgacccggaggcggupugcggcugagccaugcccgguggcgcggccugagccccuccaccugcugcaauc\n", + "agagcucaggaccucuacuugcauauccauggcaaucuauccucuugccuugaaagcauacaaguuucugagaauucaggauagauaauaucuuguggauugauuccucag\n", + "aauuaaaacaauaaacagaggaaaacauuggaacucugcugauugauuuuuaccagaaucugaccaguuacuaaacaauacaag\n", + "gugugcupauaugcagcuaugaapaapuggaauguguuccauccgucucagcgaaccccuuuugaaguugaggccaagaaaggaucuuguagag\n", + "cauaauuuuauaagacuaaaauucauuaaugacagucuaguucuucugauggaaauuguuuuuuaaaaaaauuauggaggauc\n", + "aguccugguccucggcuaggcggcuupucgcggcguaacupagccagccugacgccggcggaccccgccugugauccuggcaacg\n", + "gacpccgucucgagagccggcaucuccuaggagcuaguccugguccucggcuaggcggcuupucgcggcguaacupagccagccugacgccggcggaccccgccugugauccuggcaacg\n", + "ccuuuggaguccuggaggcggcagcguuguuguccagcccgacgguucccgagaugupccccgcgcuccgagaagaggccugcgcpcc\n", + "pcugucuguggccucagcgcucggcaggcgcgcacucagcuccacacccggcucucucggcaucucagacccgg\n", + "uuucacacaaucaucaggugagccgaggauccauuggaggaaggcauuaucuguauccagaggaaauagccaaggauauucag\n", + "gaaaaaucccucugcuuucucuggccaguuucacacaaucaucaggugagccgaggauccauuggaggaaggcauuaucuguauccagaggaaauagccaaggauauucag\n", + "aguuauggcagupagucgaagcgapucugaaguucacgacuacuagaapapaguggaaaggcucucagugaaaaag\n", + "apaagcuugguuaaaaacaguuauggcagupagucgaagcgapucugaaguucacgacuacuagaapapaguggaaaggcucucagugaaaaag\n", + "caaaacucuggaucaucuuuaaagaccuguggcacacagaccacuggacaaaguucugcugccucuuucucuupaagucuguaaau\n", + "guucuapacguauacuugagcaagagagaccacagcucuuguucccgcugauccugcagcccaguggauggaguccagaaucuacagaccugccag\n", + "agcugcagucagcaccgucaccccagcagcauccgccgccugcaccgcgcgugcggcccgccccggccugaccccgccgccgaacccggcgccagcc\n", + "gguaccgupapccgcgcgupcagcpagcgagucccuccguccccgcgagucggcgcuuuuggccccgcpapccpcucg\n", + "augagaaaagcaucauucaagcucagauucguguugaagccugccacaagguccaccuguuguugupuuuuupugaccag\n", + "puuacccccagcagugugugagaaugaagagugupccacugugucucuguugaccugccagauaggaaauagcgccagaguugcugcaauccacgucucccug\n", + "agcgcugcpauaaaggaggagcguccugcuucccggcugcccuguugcugucggagucacagg\n", + "auuuaapcgagcupccgagaacgcagcggcuguuugcgccccuucugccucccgcgcggccagcaccgguacuugcgagcc\n", + "aagcggaggcuccgagcucuaggccggccggcgguggcggcggcgaggccpacucpcuuapccugcuguggaggcagcggcggacgccgagcuaagca\n", + "gaccupapauuggcucucugcagccucagcagugaccugcpupapupauuggcucccugcugcagccuag\n", + "gugccuagupaggaccagacggcccugucccuggaagagugccuuaggcugcuggaagccaccugccccuuupagaaugcugag\n", + "ggaggcuccgagcucuaggccggccggcgguggcggcggcgaggccpacucpcuuapccugcuguggaggcagcggcggacgccgagcuaagca\n", + "aaggagacggaggcggcccapaupcugguuccuugcggcagcuucuccagcugcccugaugcagagauuggcucccgucugcagcuag\n", + "acccuuccagccuggugugcucccugaaagccaagagcuccuugcagcccccuguccggcuucccggcaccggcugcccupcucaucucgcagacc\n", + "aaguaauucugcaugacaauucgcucuugcuugccauggccagcuuccuccaaaccaaguuuuaapuccaauccccaaagcuagag\n", + "apaaguagcacuuguucgcuggccgccccuggaggcuagaagcuccggcgccgagagupcauggcgacuuggucucagccggacucgg\n", + "ccuggugugcucccugaaagccaagagcuccuugcagcccccuguccggcuucccggcaccggcugcccupcucaucucgcagacc\n", + "ccgagcucuaggccggccggcgguggcggcggcgaggccpacucpcuuapccugcuguggaggcagcggcggacgccgagcuaagca\n", + "acuuguucgcuggccgccccuggaggcuagaagcuccggcgccgagagupcauggcgacuuggucucagccggacucgg\n", + "aucaguguguucucuaccccuuggagacugcuuuucuccagcucugucaacucaaccuuucccacc\n", + "cagcagccuuggacuccgcccguggagcccupccuguugacccaccagcuuaggagcacccaccaagcucugg\n", + "guguucupaagauggcaucaugucuggcuaccgccgccccaccagcucggcuuuggacuguguccucagcuccuuccagaugaccaacgagacggucaacaucuggacucacuuccugcccaccug\n", + "acucuuccuccaucagccuggcuggcagcagccuuggacuccgcccguggagcccupccuguugacccaccagcuuaggagcacccaccaagcucugg\n", + "capucuccagcacccaucucpcagaggcupagugacugcuggugcaagccccaaagugcaugcggcaaaaacauggaugcagagcugguggcaagaagapcuaaguuauaga\n", + "gucaacguggagguaccaggccaccaugcucagucucaagcugccccaacuucuucaaguccaccaggucccccgg\n", + "ucuuccuccaucagccuggcuggcagcagccuuggacuccgcccguggagcccupccuguugacccaccagcuuaggagcacccaccaagcucugg\n", + "uuuccuggagcuggaaagcccupcucaguaagguccuccgcacaggagccuucgccuauccauuccuguucgacaaccucccacucuuuuaucgg\n", + "ucccccagguggugapccaaagcucpauggacaagagaaaggaaggagaugucacugcugaauuucugcugaauuuccuucugccugcugcccgauuucuauuugacuggcaauagucug\n", + "uuucuuccccaaacagccccaapcccpccugcugcagcupagccggacuuccuugucccaccaggcacagcucuucagaccccugccuupucacauuu\n", + "cuugaggcagcccuaggugaggccaagaagcaacuucaggaugagaugcugcggcpuggaugcugagaacaggcugcagaccaugaaggaggaacuggacuuccagaagaacaucuacagugag\n", + "auuugccagugaupaagaguuagaaacaggaugcccagcccuucucgccucaagaggccacup\n", + "aaacagccccaapcccpccugcugcagcupagccggacuuccuugucccaccaggcacagcucuucagaccccugccuupucacauuu\n", + "auuccuugacccgaggaggauapauguggccuucggucuuuccucgcagcuccpcaagcuaggagupauggaagucgag\n", + "acuugauguaauugucuucacaauucugugaagauggacuuggugucucugcuucacaugaapaccugagguucagagaggcuaaguaacuuuccuaggucacagagcug\n", + "cuccgcucgugccgccggaagupaggugccgcgcgcpccggcgcucgaccccuccccccguggcucggccgcccccuccccccgcuccgcccgcucag\n", + "ugguccucacagccagugcaccggapcgcgcucccgagcuggcgcaguuucccagcgcggugcccgccccucauccuccuccagucucccuccccucgccgacugccgccccaggcuccgcc\n", + "agugcaccggapcgcgcucccgagcuggcgcaguuucccagcgcggugcccgccccucauccuccuccagucucccuccccucgccgacugccgccccaggcuccgcc\n", + "aagagagauggcgcucpacggaapuucccugcccugccccaggagccugcaupagaaggcgugaggaggugaaggaagcuuaugguaccugcacaccgacaggcuggagcgcgaga\n", + "gcaacccuguggccuguccuggucucugacucacccugaagaaugagaaaccuguuuaaagugaagugugauggaaucaagucagacgugaggaaggaccuaccuccuuggucaaagcupaup\n", + "gaucuugcucuguugcccaggcuggapcagugguggagucauagcucaucaaaagcucaaccuuccaggcucaagugaugcuuccgucucagccuucugaguagcupacaacag\n", + "aguguuugacgagagccgaaggaggcugupagguguuggcggcggcggcgcpcgccugaggaggaggaggagaagcgg\n", + "upaguggagucagcaccaagccaggcuccccgcgccugccuugcccucaccugcuccugcucucugccagaggcagcaugguccgcapcacc\n", + "gucuaucgcuaccuccgugccuuccugccggaaaguggcuuuaccauccugcccugcacgcgcuacucc\n", + "agaaaucaacuuuucaguaauuggucaguauguggauuaucuugugaaagaacapagugaagaacauuuuug\n", + "auucuuacuuugacccccaggcuggagugcaguggcacgaucuugguucaccacaaucucgucucgaaggcucaggugauucucucaccucagccgccugaguagcupaccacag\n", + "guuucuguauacauagccuucaggacugcuuuugguggaaagagauagcagguggugcuaauucacuguguuggupaacucuggcuacacugaaag\n", + "gcuggagugcaguggcacgaucuugguucaccacaaucucgucucgaaggcucaggugauucucucaccucagccgccugaguagcupaccacag\n", + "ugacucaagacccucuuaggaacuucuucacugaacucaaggaggagaucaggcaagaucugugcugugcagauccuuuggauugaggcugcugugcacaggaauaugg\n", + "guauuuccucuuauuccuuacuccacugcaccuaaucaauaaccaagaaccauguaaccauugcuuagapacuugaacaggcagaugaugcuggugaauuaaaggaagacagccuccaa\n", + "uugcguacuucuugucccacagugcugucugcagcucauccuugapagcuaaucuccuguuucag\n", + "gcugcuucugcugaggcuggucugcuugaagccucccaggagaaagaagccaggupaauggagagagagaggaag\n", + "agagccucccuggacgcuguuugcaagguccucaccgccuggaaguccaggagccauuuuuapaacagcauucaagcucaacaug\n", + "cugupcupccaucggaaaacuuucaguuuuguuuccuugccugcaagaaacgaaacucaaccgaaagccugcagagagcagaac\n", + "aaugcaacuuccgguuggagucacucggccaggcgccggcgaccugapagapaacgcagcugaaagcgugaacu\n", + "auagcaucgucggccucugccccaacggcuucaapapacucgucccggcugcuuugcccpaa\n", + "ggcaagguugupacaucuugagcugaagcapuuuugagccacugcugcugcugccauugucacc\n", + "aacacupugccupcccuggcaagguugupacaucuugagcugaagcapuuuugagccacugcugcugcugccauugucacc\n", + "uugugacuaaaagcuggccuagcaggccapagugcagcugcaggcgupuggcaggagccgcagagccagagcagacagccgagaaaaagguggacagugugaaagaaccagu\n", + "ggucucgcucuguugcccaggcuagaguguacuggcgugaucauagcucacugcagccucagacuccuggacuugagaaauccuccugccuuagccuccugcauaucupacuccag\n", + "cgguguccgcggcgcupucgguggcggaggcugaggagaaggaggagcpccguggaggcuucgccgccuag\n", + "guacugcuauaaccagaauuugguagaaaaaggauuuacuuguupcccucuugauaaaaagag\n", + "ccgguguccgcggcgcupucgguggcggaggcugaggagaaggaggagcpccguggaggcuucgccgccuag\n", + "guacugcuauaaccagaauuugguagaaaaaggauuuacuuguupcccucuugauaaaaagagauguppauucucgaccugcuaacagaacuggaccuuuucg\n", + "gaucaagauuauaggaccggcccaagugaggagaaacccagcaggcuuauucgauuaagupuaccugaagaugccacaaaagaagag\n", + "auucuuaaugcuuuucggacuccugauggcaugccuguaaagaacuugcaguugaaggaguauaacacag\n", + "gaagaagacaaacucacugacuggaauaaacuggcuugucugcuuugcagaaggcaguuucccaauaaagaaguucugaucaaacaccagcagcugucagaccugcacaag\n", + "caaaaccuggaaauccaccggaagauaaaacagucugagcaggagcuagccuaucuggaaaggagagaacgagag\n", + "agcggcgcggcgccuuugugguagcaguggccccgcgcggaggaaguuccgguguccgcggcgcupucgguggcggaggcugaggagaaggaggagcpccguggaggcuucgccgccuag\n", + "ggaggaaguuccgguguccgcggcgcupucgguggcggaggcugaggagaaggaggagcpccguggaggcuucgccgccuag\n", + "agacaacucagaagacacuagacaacagcagucuuaucuaaagaaauaagaccuccaaggacgaagcaucaga\n", + "cuguagguccaguguaagaguuccgcuauucggucucacaccuacaguggacuacccgauuuuucgcuucucuucap\n", + "aguguaagaguuccgcuauucggucucacaccuacaguggacuacccgauuuuucgcuucucuucap\n", + "gcccaggacgagguggccaggcggcccccauggcgucccuggucuaggcggagaaccgccupcg\n", + "auuucgccgcuggcgucaggacuauuuucacguuuuaaugccgagaggucucugugacgauuuug\n", + "ggaccggaaguggaagugguccccgaaggcuauuucgccgcuggcgucaggacuauuuucacguuuuaaugccgagaggucucugugacgauuuug\n", + "ggaaguggaagugguccccgaaggcuauuucgccgcuggcgucaggacuauuuucacguuuuaaugccgagag\n", + "guauauagguaccauuuucaaagaaaugauguucugagcccuauaagcacaaucaauaugcaucacaagagacaaacuguaaucucuga\n", + "ggugcuagaagucggaccggaaguggaagugguccccgaaggcuauuucgccgcuggcgucaggacuauuuucacguuuuaaugccgagag\n", + "ggaccccacuugacuuaaacucupcccpaggccgccgguuuucuccccgcuugccpugguccucuucccuuugucg\n", + "gaccaaagaaguaaacacuguguggagapacugacguguuuggapaaaupaauguacacgauaauuaaagaguaaaguugugcucaacg\n", + "auuccugacauucagacaacugacuuguaacugacuuauaacugacuuguaauacacugcuacuauaucaaaccgaca\n", + "acuugacuuaaacucupcccpaggccgccgguuuucuccccgcuugccpugguccucuucccuuugucg\n", + "acauapuaccuccaacuuuccpuuucagaagagaauuuuuuauugaaacuggaagaccaaaauaauuacaagc\n", + "cuggugcucuccgccccgcuugccucccguucuuccccgcccgcuccauccpucgcugacggcugucucuggacuggacagcaguggcguccgcuuuucucuaaggaacccg\n", + "gcaagaaggcuuuagcugaugcacagaucccuuauucagcaguggaccaggcauguguuggcuauguuuuug\n", + "cgcgccuguguugccgcccgcggcccuggcuucpcuucapagcucuggugcagucuccgccugucagugccggcagucguccgcggcgcccgccccggucccgcacuggugcagcc\n", + "guugccgcccgcggcccuggcuucpcuucapagcucuggugcagucuccgccugucagugccggcagucguccgcggcgcccgccccggucccgcacuggugcagcc\n", + "acgcgccuguguugccgcccgcggcccuggcuucpcuucapagcucuggugcagucuccgccugucagugccggcagucguccgcggcgcccgccccggucccgcacuggugcagcc\n", + "gaaagaggcaaguuccuggugcaaagguggcucugcagcauaauuuaggcauuggaggagcugugguuguaacacucuacaag\n", + "paagccggaaagaggcaaguuccuggugcaaagguggcucugcagcauaauuuaggcauuggaggagcugugguuguaacacucuacaag\n", + "pagcucuggugcagucuccgccugucagugccggcagucguccgcggcgcccgccccggucccgcacuggugcagcc\n", + "pcagcggacuuccggaucuuugcupaupcagccuggagaggcacugacuuuuggaapagaccaagaccugugacggauggcgcuucccaaagcuugauccupacuccugga\n", + "ggcgugccccaggagagcggcguggacgcgugcpccuagaggcccacgugauccgcapcggccgaggcaggaagcu\n", + "ucgcpucucacgucccgugcacgccuugcuucggccucaguuaagccuuugupcuccaggucccuggugagauuagaaacguuugcaaac\n", + "ugcaucguuagcuucuccugauaaacuaauugccucacauugucacugcaaaucgacaccuauua\n", + "gguuuggucggcggcuggaggagaguggacccccccacuuuaaggcucuguccucggcgcguucccgccgccccccggucccgacgcpcucp\n", + "gacaaauggcucagguggacuccpcuggagcuguccupagcuuguuugcggcagcggcugcugcugccacugcugugcupcccggucgccag\n", + "gucuuugucccuccucuuaacauacuugcagcuaaaacuaaauauugcugcuupaccuccuucuagccuuaaauuucagcucaucaccuucaccugccuugguc\n", + "ugagcgucaggagcacguccaggaacuccucagcagcgccuccuucagcuccacagccagacgcccucagacagcaaagccuacccccgcgccgcgcccugcccgccgcugcg\n", + "ggcuguucguuucuuggaaccucacacugucagagcauucgaguagcuugaggacaggaaauuugapcggacuaucugcaagguguuccaggagaaggacacagucgcauccugcaag\n", + "guuucpuucccuagaaaaaucuggacguguaaaaagaacucuuaacggccgaugcagcucuuccaaagcuaag\n", + "ggcgccagcggcuggagcagcaapagucapccapccagagagccggagagaggagcccccgaccgagagcccag\n", + "auaaauagcagcagagccggagcuggagccggcgccagcggcuggagcagcaapagucapccapccagagagccggagagaggagcccccgaccgagagcccag\n", + "gccccauaaauagcagcagagccggagcuggagccggcgccagcggcuggagcagcaapagucapccapccagagagccggagagaggagcccccgaccgagagcccag\n", + "auugugucacaaaccaaggucacuaagccauuauugcugaagaaupaagacugcpcaaguccaccaucacg\n", + "aucguggccgaggagguaucaggcacaaacgacuaugugcaacucaccuucagagccuacaagcuggacaacaag\n", + "uccaggccccauaaauagcagcagagccggagcuggagccggcgccagcggcuggagcagcaapagucapccapccagagagccggagagaggagcccccgaccgagagcccag\n", + "auugugucacaaaccaaggucacuaagccauuauugcugaagaaupaagacugcpcaaguccaccaucacgguaggcaagaucaccuguacucacccuugguccag\n", + "auguccauuuccugugucuccuuauaaaaugguggcuapaacuggacaucauucucaaagcuaugacguucagcaag\n", + "gcuguauuccpuuaguuugagugaguacaugugugacaaggacagcccaguguuccuguauaugugacugcagauauccuuagcuaguguaacaauguugaaagugaugugagaap\n", + "cagcagagccggagcuggagccggcgccagcggcuggagcagcaapagucapccapccagagagccggagagaggagcccccgaccgagagcccag\n", + "ggagcuggagccggcgccagcggcuggagcagcaapagucapccapccagagagccggagagaggagcccccgaccgagagcccag\n", + "cuggcuggcccgcacagaccccaaggauguggcacgaguagagagcaagacggugauuguaacuccuucucagcpacacgguaccacucccgccuggupcccgupcagcupcaacugg\n", + "guggcucgcuucgccgcgcucccuccuuccccgccuuccauaccuccccggcuccgcucgguuccuggccaccccgcagccccugcccaggugccauggccgcauuguaccgcccuggccugcg\n", + "auaccucccucggaccucuaacpcucucagccagcgccccapuacuucgagaggcagcapcccupacaagg\n", + "guggcucgcuucgccgcgcucccuccuuccccgccuuccauaccuccccggcuccgcucgguuccuggccaccccgcagccccugcccaggugcc\n", + "gcapuupcggcggcupcugaccuggagccuggagccccpccgapagcuggccugccagcpcggaggaaagcuagugccagcccuaccag\n", + "cuuuuuaagcgccucccgccagccucugcuguggcucgcuucgccgcgcucccuccuuccccgccuuccauaccuccccggcuccgcucgguuccuggccaccccgcagccccugcccaggugcc\n", + "agcguggupagagccuugagaguuggagccaggcpagapuagcacuggupaggaaucuaugcgguccugaagauucug\n", + "auccccupccgacgccuuccugccggcgcugaccgaggaacucaucuggagcccggacauupacacgcagcuggacguagaguuucuu\n", + "aggccaggucaugacucacuggcuuccugcaaccugacgauggcccagccagaagacaaggcaccugaaguccccacagapugag\n", + "aguuucuuggucacaggacgugaccccagccaggcccugguguugaggucaggaccuuuaccaggagaagucaauaccuaccagauccagaagauucccagag\n", + "agugucacagaccuuuguggaagcaacaacagcucccauccuuccaaccuuucuggagaagccguggccug\n", + "agcucagugucacagaccuuuguggaagcaacaacagcucccauccuuccaaccuuucuggagaagccguggccug\n", + "gcaggacagugucaggauggaccgcgcugccagaagccgacgcuagcgapaggugugaagaguuggccaga\n", + "acgcggcggcgacggugacccaggaapcucuggugccpcugagcpaagcapuagcggagcc\n", + "gcugaugcaaccuggcuggacucgcgugacaguucccggcacgcggcggcgacggugacccaggaapcucuggugccpcugagcpaagcapuagcggagcc\n", + "gagcgccgagcccagcugaugcaaccuggcuggacucgcgugacaguucccggcacgcggcggcgacggugacccaggaapcucuggugccpcugagcpaagcapuagcggagcc\n", + "gcgccgagcccagcugaugcaaccuggcuggacucgcgugacaguucccggcacgcggcggcgacggugacccaggaapcucuggugccpcugagcpaagcapuagcggagcc\n", + "agcugaugcaaccuggcuggacucgcgugacaguucccggcacgcggcggcgacggugacccaggaapcucuggugccpcugagcpaagcapuagcggagcc\n", + "cuccgcpcagcguccgagcagccagcapugcgcggcgccgagccgapcpcugapcggcccccpagagagcggccagguggaggaggagcgcggaggcgaccgcag\n", + "agacapcapcauuguucaugcacugaccgaccucagcagccccggcaugaccucapaacggaaacucugccuccagcaucgccggcacugccccccagaaug\n", + "gauuaucuuuccaagguccagaagappucagugaucaggaauaauugacaagacccuugguuagaaguuucccacacaaacucag\n", + "gupacgcucgucccugcuggupaaucucaagaagaaguaugcacapuuccugccugagaaacuuccacagcaggaucacaccaccaccacugacucggag\n", + "auagcuccpcguucgcuugcaagauggcggcggcpcaguggcugcugcguuuucgugucugaguccuuccupuucuaaugapcgcgguucugcugugcccggcccgcgaggucuaaggc\n", + "agcuccpcguucgcuugcaagauggcggcggcpcaguggcugcugcguuuucgugucugaguccuuccupuucuaaugapcgcgguucugcugugcccggcccgcgaggucuaaggc\n", + "cucapuuauagaacagccgccuucagcuauucucccccapcucugcagaaccuucccaccuuucagcag\n", + "gcuggagugcaguggcaugaucgugacucacugcagccuuccacuccupcucaagcaauccuacugccucaggcucccag\n", + "auauaacuacauauguuagcauagaagugguauuguaauuggagauaauuccuuuaccagagaucaguuugcauuguuuuacguacuuggcuaupugacuuuucugcugau\n", + "acugucuugugcuucuucguucacauguuugguaauucauuguaaccgaaaapuuuugcacaacuucagugguccuucagcccagagaagaaauaccuuuguggucagacuguuaaaguaa\n", + "agccggcagagcgcuccggccccgcacccgccgcccgucgcccgcagcccccuaccgcgcggcccgcgccccgccggcucccg\n", + "acacggacaggaaaagcuucgcugucuacgcaggugcgucccgagcaccugcgcaccuguugcgcggcuccccacag\n", + "gaagccgcugccucccpagccggcagagcgcuccggccccgcacccgccgcccgucgcccgcagcccccuaccgcgcggcccgcgccccgccggcucccg\n", + "cacaucucuccuucuguuucuguuuguguauguuuguccugguucupcagucacupuaagagaagacuggaagc\n", + "gaauuuaugcaaauauucucaugagguucucucagaagagaacuucaaaguccugaaaaaucacgaacucucuggacugaacaaagaggaauuagcagugcuccuccuccaaagugauccuuuuuuu\n", + "cggaccccagcguuaccaugcauccugccgucuuccuauccuuacccgaccucagaugcucccuucugcuccug\n", + "auuaugucuacuuugagaauuccuccagcaacccauaccuaauaagaaggauagaagaacucaacaag\n", + "acugcaaguggcaacguggaagcaaaaguaguaugcuuuuauagacgacgugauauuuccaacacacuuaua\n", + "ggcugaggcugaggaggaggcggcggcggcpcpcucggcucpcuccgcpcpcpcggac\n", + "guggcgaggcagcagcgacggcggcggcggcagcggcggucgcggcugaggcugaggaggaggcggcggcggcpcpcucggcucpcuccgcpcpcpcggac\n", + "gauuguccggugcccgcuagaggucgccaaacggaguccuuuugcgcugguucuuaaguggauuccuagugaaaaggcagacaacugaaaau\n", + "gaagcaauuuuggaggugguggaagcuacaaugauuuupaauuacaacaaucagucuucaaauuuuggaccc\n", + "agauacguucgucagcuugcuccuuucugcccguggacgccgccgaagaagcaucguuaaagucucucuucacccugccgucaugucuaagucagag\n", + "agauacguucgucagcuugcuccuuucugcccguggacgccgccgaagaagcaucguuaaagucucucuucacccugccguc\n", + "gcpuaaaaaagagapcgaagguaggcuggcagauacguucgucagcuugcuccuuucugcccguggacgccgccgaagaagcaucguuaaagucucucuucacccugccguc\n", + "ucuccuaaagagcccgaacagcugaggaagcucuucauuggapuugagcuuugaaacaacugaugagagccugaggagccauuuugagcaaupaacgcucacggacugugug\n", + "gagapcgaagguaggcuggcagauacguucgucagcuugcuccuuucugcccguggacgccgccgaagaagcaucguuaaagucucucuucacccugccguc\n", + "aguugcgccagcagcgucgcgcggcccaguucccuuuuccggucggcguggucuugcgaguggaguguccgcugugcccpccugcacc\n", + "gucggcguggucuugcgaguggaguguccgcugugcccpccugcaccaugagcgucccggccuucaucgacaucagugaagaagaucag\n", + "uggaaaupuuuugccauguugcccaggcucgucuugaacuccugaccucaagugauccacucgucucggccucccaaagugcupauuacag\n", + "gaaaagaauggcauugaagcagauuuccagcaacaagugcuuupauugcagaaaguuuuugaacaugacag\n", + "gagauagaucugagagugucccagcuuuauggacugccucuuccuaacucupaaagauuggag\n", + "aaauguuuccugacaucuuuguagcuucaugaguaaucagacaugcaaauagccccucaggaaucaagcuacacuuaaagaagacuuaguuggaaacuuuggagaguagauc\n", + "auauupcaguggccucagucaggcccgcuggccgcccugccacacgguagcguccaagccaggucguggcccagcgagupacgcgccccgaaccaggcagcaccuuc\n", + "guaucaugauagaggaaaccaguuuupaaaaguuaugcacagcugaauuucgagaacucuaugcucupcaguauucauaaugaccuuuauguuauaggaggacag\n", + "aaugacuacaagagagacaaugugacugaauuagaaaaugauugccaaagaauaguauuaaggagaagaaaacauuuuuggucaccaaucucucauauaccacuacuggauauuuacaac\n", + "gcauuucggaagaggacgucaacpaaggaauucccccucupugcpcuccgagapcgacuugcaggaggcuccccccpcggaggcgaag\n", + "gcugcuggagugcaaugguguaaucauagcucacugcagccucuaccucucuggcucaagcaauccucccaccucggccuccugaguagcupacuacag\n", + "gcgcagaggcgucacgcacuccaugguaacgacgcucggcccgaagauggcggccgaaupcggaggagupuuacucpcucaggcccpccggagccgguggcgcuggagcgg\n", + "gucauaaauaaaguucaucuuaaggcaaaucauguggucaagagagauguugaugagcauuuaagaaucaagacugucuaugauaaaaguguugaaga\n", + "aacaagcuuuucccacaagcgauuucuuauuuagagaagacuuuucagguccgucgaccugcpcacuaucuuacuuagcag\n", + "acaaugugcaacaaaccaauaccuccggaaggaaaacgauccucacagguacugcaccpagugugccgcacacacaaagugcggccccguuauuguuccugaggaacaucuccag\n", + "gagcauuuccggcagccauccccgcggugcugacaucccgguuguucuucugugccpucuuccugcuguc\n", + "ggaagugagugagcauuuccggcagccauccccgcggugcugacaucccgguuguucuucugugccpucuuccugcuguc\n", + "uuuccggcagccauccccgcggugcugacaucccgguuguucuucugugccpucuuccugcuguc\n", + "agcauuuccggcagccauccccgcggugcugacaucccgguuguucuucugugccpucuuccugcuguc\n", + "guggcagugacgaaagaagagacucucccggccgaggccccagugcauggagagaaggaagaaaucaauuuccuaauugguaccauauacaucag\n", + "guucucucgcucaggucucugcauguaguugucacuugcagcuccauuuccaucacgugguaaaaugcccuuucucuucuuuccugcagaugg\n", + "aguucucaggcgcuguggucucaccuuccacupcaacaaupccauuuccagcapacggcgcaguguuggccugcaugccugacugccacacaccuccagaaucaggugucugaaaa\n", + "cgagagaaaauggaagucpuagcggcgacugcggcgcugcpcuggcggagcggagcggcgcggcgcggcag\n", + "gcugcguagucgucgccpcuccguugcccgcgcuguuuuaccuucccaacgcuugaggcggacgcuppuccugcgccuuucccuccugccgcupacugcaggcuaaggcc\n", + "augcaaagcuagacugagcaapaagugacaggaaauggagcupagacaaaaauguggauaacaacaaaagaauuucaacagguaaaaaa\n", + "aaaugcaaagcuagacugagcaapaagugacaggaaauggagcupagacaaaaauguggauaacaacaaaagaauuucaacagguaaaaaa\n", + "auaugauaaauaguaccuggagcgccuacuucacaagaaagccugagagaguccaguuguacucaaggagapagaaguagccaggagacagauccgguaggacugugaaagccaug\n", + "uuuccuuaccaaucggcugccauccgaggagcugaggaagccuagagcucucagaagcaguccuuugagcugguguap\n", + "cgguguuucuccaacupcucguggcacuuuucuggacaccacuccaaacaaaauuagacucuga\n", + "guugucugcagguauggauguuguucucuuuucccugucuuuauuuccuuaccaaucggcugccauccgaggagcugaggaagccuagagcucucagaagcaguccuuugagcugguguap\n", + "gagcugcugccgccgccpcggacpcggacgcgcggagcupcggcgcggcpccggcpcgcggcpcugaccggccccg\n", + "cuccuuccgaguuaccgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "ccuuccgaguuaccgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "cgaguuaccgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "cuuccgaguuaccgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "cgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "accgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "gcuccuuccgaguuaccgccgccgucgccgccgcuccuccucucccgguccupuuuccuuggcgcugcggccgccgcucccucugcgaccuguaugaggaggaggaggaggaggaugugaag\n", + "apccgcguagguccccgcccccagagucuggcuuuccgcggcugcccgccucgcgcgucuucccugcccpucuccucgcugucgccgccgcugccacacc\n", + "agucuggcuuuccgcggcugcccgccucgcgcgucuucccugcccpucuccucgcugucgccgccgcugccacacc\n", + "guagguccccgcccccagagucuggcuuuccgcggcugcccgccucgcgcgucuucccugcccpucuccucgcugucgccgccgcugccacacc\n", + "uuccgcggcugcccgccucgcgcgucuucccugcccpucuccucgcugucgccgccgcugccacacc\n", + "gagucuggcuuuccgcggcugcccgccucgcgcgucuucccugcccpucuccucgcugucgccgccgcugccacacc\n", + "cagccgcaucupucaaucauacucaccuugcccpccaugcuccagcaaaaucaagcuguuuucuuuugaaaguucaaacucaucaagauu\n", + "ugccucaaauuccugccuuuccucaagagaagagcccccaggagaaaagccaguauugcuugugcuccuaacaaccugucucuug\n", + "gacugcugacgucacgccggcupcgcguccpacuuacuccuuuccgcapcagcacccapaccugaguguugcaaggugcgagapagcgccgcpagcgccgcpaagcgcaug\n", + "auuucccaucccucuuccucugacucucagugucccugcuuaacuuacacucuucucuucgccaagcuccuuacc\n", + "guugccuguugacgcugauggugguuucuuuugcugcuucccacccuucacuccguuuuccaacaacuuucccacaucccucaggacugacccug\n", + "aggugcuaucuccaguuccuugcacuccuguuaacaagcaccucagcgagagcagcagcagcgauagcagccgcagaagagccagcpucgccuaguguc\n", + "auacucaugcguggcucccuucacuacupugucagucuggccugugcucaagguguggcaucugguuggaguuucaauauguaggauccacuaccapuuuucgugagauuaagaagg\n", + "agcaguggaauagugaccauucuuuauucugccuuuguccuggugagcacaucugauauggcagaggaaacugaggaugccuggccg\n", + "auucuuuauucugccuuuguccuggugagcacaucugauauggcagaggaaacugaggaugccuggccg\n", + "aguauucucggcucggccauuauucugugccucggcugccggaapcucguuccugugucaucuccuagcggccuggcgccgaggcggcgguacgcaaggcuggagccgcagcpagcccccg\n", + "augauacucuccaagcuguaaggaagaagucaaggauuaaggagaccuggacuggagaggagccuuuuucaaaaaacaaca\n", + "cucggcugccggaapcucguuccugugucaucuccuagcggccuggcgccgaggcggcgguacgcaaggcuggagccgcagcpagcccccg\n", + "gucuuguagaugauacucuccaagcuguaaggaagaagucaaggauuaaggagaccuggacuggagaggagccuuuuucaaaaaacaaca\n", + "cauuauucugugccucggcugccggaapcucguuccugugucaucuccuagcggccuggcgccgaggcggcgguacgcaaggcuggagccgcagcpagcccccg\n", + "acagagauguggaaaccucacgaagccuagaapccggapacaggcupaguuagcupaguugcugacgcaguuccuucugcgcuuuguucaagaugupucuggcgcuuucg\n", + "gagagauuugcagacacagaagcggcacagagaaggccauugugaagaucaaggcagaaaccggaguuauggcaucauaagccaagga\n", + "aaupauugaggcacagaguguuaaaauagugagacacaggauucuaacuggcagacuggcacuuuaucucaauucuuaacugcuguguugccucucacuuuaaag\n", + "acauccacauuccacccupccuugcccgucuggugagcccaaucucugcuggucagucacgcaguugaggucapaag\n", + "gaguaacucaagaugauuuugauguugcaguuuuaaauuucacuuugacuugagcupaaauccuuuggccuauuauaccauggaugcuaaaaaug\n", + "guucuaacugaaaacccaaaccaagaaauagcaacaagucuagaauucuuacuacuacaaaacucaccuggaucccuaapcacagcaaaga\n", + "gagaugcucagcuacggugcucuuacaagaugaaaaggacaupuucagaucugcacuucaucaucuuucacuaag\n", + "acuaaagguggaguuapaaaugaguuuaaugugaaguaguacuccugucaguucuguuuguccupaaguauacaaggaagaaaagccuccguggaagagagagcaagcaccaggugcugaag\n", + "gaugcucagcuacggugcucuuacaagaugaaaaggacaupuucagaucugcacuucaucaucuuucacuaag\n", + "gagcauucucuaccauugcccagcugaaagcaccuagcucauagauucucugupagagugaauaaag\n", + "agucuggcacucupagcupuccuagcaccacagacuuauccuucgccugcacuuuccgucuuucuucucupcgcccaccaaca\n", + "agcugauaauugaaggaacccggagccgccgccgccgcgccgcuppuppagcuaguggaaguuacugccgcgccaccgaguccggaccggagacuuupccuaacuag\n", + "gucauuaupupcugaagcgcagagcagcugaaacauuuuuauaccaccacccgcacacuuucaaupauagaapacuccaaaag\n", + "gcggccgcggccggapaccpccuggcpagguapucgcupucccuccuccggcuucccgcaaugaggapcccuucacagaaccp\n", + "puppagcuaguggaaguuacugccgcgccaccgaguccggaccggagacuuupccuaacuag\n", + "aaauggaaacuaggaagcagcuccagugacaacaguugupaagcgapucagagaapagaggccagagagacuuuagaccgca\n", + "guggacggcccggaaauggaaacuaggaagcagcuccagugacaacaguugupaagcgapucagagaapagaggccagagagacuuuagaccgca\n", + "acagagucucacucugucacccaggcuggagugcaguggcgugaucucagcucagugcaaccucugccucccagguucaggugauucuccugccucagccuccucaguagcupaccacag\n", + "auaauugaaggaacccggagccgccgccgccgcgccgcuppuppagcuaguggaaguuacugccgcgccaccgaguccggaccggagacuuupccuaacuag\n", + "acagagucucccucuguugcccaggcuggagugcaguggcgcggucucagcucacugcaaccucugccucccpuucaagcgauuccccugccgcagccuccagagcagcupacuacag\n", + "cucucuggacuguaagaauaugucuccapccagugucugcugcgaucgagucccaccuuccaaguccuggcaucucaaugcaucupaagcuaccugcauuaagucaggacugag\n", + "cuuccucucuggacuguaagaauaugucuccapccagugucugcugcgaucgagucccaccuuccaaguccuggcaucucaaugcaucupaagcuaccugcauuaagucaggacugag\n", + "ccuuccucucuggacuguaagaauaugucuccapccagugucugcugcgaucgagucccaccuuccaaguccuggcaucucaaugcaucupaagcuaccugcauuaagucaggacugag\n", + "guccuuccucucuggacuguaagaauaugucuccapccagugucugcugcgaucgagucccaccuuccaaguccuggcaucucaaugcaucupaagcuaccugcauuaagucaggacugag\n", + "ccucucuggacuguaagaauaugucuccapccagugucugcugcgaucgagucccaccuuccaaguccuggcaucucaaugcaucupaagcuaccugcauuaagucaggacugag\n", + "uuccucucuggacuguaagaauaugucuccapccagugucugcugcgaucgagucccaccuuccaaguccuggcaucucaaugcaucupaagcuaccugcauuaagucaggacugag\n", + "auucuacacauaucauauaaaggugaauaguguaaagcuaccucuacaccuuaccaagcacacag\n", + "aggcuuaaaggauggccucgucagaucuggaacaauuaugcucucauguuaaugaaaagauuggcaauauuaagaaaaccuuaucauuaagaaacugug\n", + "gaacucugugaaucucuugaagaagauuacaaagacauagaacaucuuaaagaaaacguuccuucccauuugccucaaguaacaguaacccagagcug\n", + "uguuaapaucagaucuugauccugaagaaccaaucaaaguugaagaaccugaacccguaaagaagccucccaaagagcaaagaaguauuaaggaa\n", + "auuuuuaaauauccagauuccaagaacacacuggauacugcucuuacaaaaccaagaggaaaucaugaagaaauguuuuaguuauugaaacuacaguugaaauc\n", + "acuuccggucgcuuucggucucucagcggccgguuucugcguccgcugccgcagguuccaccgcgcuccag\n", + "aauuaaggcagagucacuguaauuauuucuaauaccaauuccaaaauagugacucuuggacaauagugcaauuauauggaauu\n", + "accccuguucagauuaaggaauuuggugcaguuucaaaaguagacuuuucuccucagccuccauauaauuaugcugucacagcuuccucaaga\n", + "agacpccuuacuauguuguccuugcuggucucaaacuccagacuugaaacaguccucccaccuuggccuccuaaagcacupaucacag\n", + "caccugugcacugagugccugcugcgugucpccccguccuaggcagupacaaggaggcuacapuacaaauaa\n", + "caccugugcacugagugccugcugcgugucpccccguccuaggcagupacaaggaggcuacapuacaaauaaaugagugaacgauguugcucuagauacag\n", + "acguggccgcgaagaccpugagacgcugcggcugccgaggccugucccgcgcggagupagupugccgcapucpcuggcgcgacccucgg\n", + "uuuucauucauuuuauuuauucauucagcaccugugcacugagugccugcugcgugucpccccguccuaggcagupacaaggaggcuacapuacaaauaa\n", + "apcgccacagcgccugcgcgcguacggcggccggaapcuagaggcggcucccupugacaaccgcgcgccccaccuuuccccacguggccgcgaagaccgg\n", + "pucugaaauaacagucccaaaguaauaacaauagcugcucuuuauugagugucuacuauguaugagauacaacuuguuugugauuupagcagaaguucaaaaag\n", + "gcuauugucgccgupcugagcucgccpccggccccuccgupccgcgcupacgcacgcpuggacgapaccgaucccpcgccc\n", + "agguuccggcuccuccgccccgcggcugcgaacccaccgcggaggaaguugguugaaauugcuuuccgcugcuggugcugguaagapcauugucacagcagcagcaac\n", + "gcgccaccpaaggacaapacupcacpaccccggccagugagcgcccguggcccpaccgccccucccuugagcucucucgccgcgaucccpcpucucgccccgc\n", + "auggcuuggugccagagugagagcaaaaguggugcugccuuaaagcucagccucacugaagcagag\n", + "accaagucuugcucuguugccaggcaguggcgugaucuuggcucacugcaaccuccgacucccugguucaagcgauucuccugccucagccuccugagupauuacag\n", + "gcaguggcgugaucuuggcucacugcaaccuccgacucccugguucaagcgauucuccugccucagccuccugagupauuacag\n", + "ggccgaggcagacaaguggaauuaggccuugcugcapacuucauuuccuucucaguacuggacccauuuaugaggagguggcuuaugaaagugugauguucgcguauuucuugacag\n", + "uggcgugaucuuggcucacugcaaccuccgacucccugguucaagcgauucuccugccucagccuccugagupauuacag\n", + "uuuauguggccgaggcagacaaguggaauuaggccuugcugcapacuucauuuccuucucaguacuggacccauuuaugaggagguggcuuaugaaagugugauguucgcguauuucuugacag\n", + "augccagcuuggagagucacgugagagcaagagaguagcuuucugguuguccuggugcccugcucaggcaaacugacugccauucucugagg\n", + "gcacuuccucuccaggaauccgcggapagcgcaggcucgaagagcuccuggacgcagaggcccugcccuugccagacggcgcagac\n", + "gaacgacucggcgcgcgcgcpagcgagcuuugaaaguugagcacggcggcggcgagccggugcccupauc\n", + "gcguuugcuuccagccucuccggcucccuagccacccaggcagucuugcupcauapupaacgcaaaagccacuguuucagcugccacggccaccuggcucgugaaag\n", + "gcuuucuggagapagaggagagauguggaggaagguacuupugagaggagcugagccuggcaauggaaggagaaacpaggaggacugcuaauuuccacuuguaaaacug\n", + "ggcaaapccucagccccgcccuacugacugugaauucuacaacauauggagcgccuaccuugugcaaggcauugugg\n", + "cccuucagagacuugaagacagugugugacucuccugugaguuaagagcacuggcugagucagacagacccgagugacaagcccagcuucgcucccucucagcggugagagccaag\n", + "agaacuuucgugagcccugcuccaggucccaggagaaagugccagccaugaggacuggaguauugccug\n", + "ucgaugguggcgugacpcpuggcggcgcguucuccucgguupapaaccagcccgcgaacccaggccpappuucggccuppaapacugac\n", + "guauaguggaagccaacccaggcaaguucaagcucccagccpaccugcaggagagaaagguguucguggagcgg\n", + "aagaggccucaaagaaagagcugcggugcaggaauucgugugccggauuugguuagcugagcccaccgagagg\n", + "agcugccgacgupcpcagccgccggcggcupagccgaggcgucggugcagaccuggagacpc\n", + "agcacugcapcucupcpaaggcuaaccuggugcggagccagccupucucagccccgcguacggccuuucacgagucuucaagccuucag\n", + "cupcpaaggcuaaccuggugcggagccagccupucucagccccgcguacggccuuucacgagucuucaagccuucag\n", + "cacuuupaggccgaggcpcagaucacuugaggccaggaguuccagaccagccuggccaacaug\n", + "ccuuuuuuccggcugcugaacuugcgcaagcupccugagcgacaacgagauccagcgguugccucccgagguggccaacuuc\n", + "acuccggcucggcggcucupccugcggcpcgcugcpuuggagcucpacgugaucgugg\n", + "gcgcgcagccagcggcucccugcccuuccccuccpcccugaguaccggccccccaccaaggaggagcccgaggucuccgucccggcggcg\n", + "ggcgucgccccgcccacuccggcucggcggcucupccugcggcpcgcugcpuuggagcucpacgugaucgugg\n", + "aaugcgcaggcgcggcgucgccccgcccacuccggcucggcggcucupccugcggcpcgcugcpuuggagcucpacgugaucgugg\n", + "uuuuuuccuuuucuccagcggccucagguucuuguuacaacugaguccpuuggaggaggugupccgcugccgccag\n", + "cuuuucuccagcggccucagguucuuguuacaacugaguccpuuggaggaggugupccgcugccgccag\n", + "guacauuuccaauugauuuaaccaagacacggcuccagauucaaggccagacgaaugaugcaaaauuuaaggaaauuagauaccgagga\n", + "uuuuccuuuucuccagcggccucagguucuuguuacaacugaguccpuuggaggaggugupccgcugccgccag\n", + "cugccpacagcupacuggacaccacccagaagccagcuggcuggcccugcccugcccugcuggaggcaccaucucug\n", + "auugucuccuuggccggaccupcugcggaagguaacupacgucgcaggcugugcagcuuucgcgaggcaccgcuuuggcgcccggaccgag\n", + "ugucuccuuggccggaccupcugcggaagguaacupacgucgcaggcugugcagcuuucgcgaggcaccgcuuuggcgcccggaccgag\n", + "uaccuggaguagaacagaaaaauuauuaugucuguguucccuupacucauuggaaauuguacagugacaucuucupauuuagucug\n", + "aaagcagauucuuuuuaugauuuuuaaaguagaaauauccauucuaggugcauuuuuuaapuuuaaaauuugaauccucagugaaccapcagagaagaaug\n", + "agcuccaggcacagcaguuggugacuccuuggupagccgugucccacccgguccugauacugccgucuucucuuucacaguccuccaggcuupccagccuupcagcagagcuucup\n", + "gucucuugcccugugcagcuuccugcagacuggacuugcaaaguccagccuguauggcuggaguucccaugccugccaaucuccugucgacugcgagucagcuccgauacuucaccagauucag\n", + "acuucccccagcccuucucagacagccacugugcaggcuuuggcagcpucacacacuccacccpaggccaaagcugccugcag\n", + "gcacauuuggcuauuuuucaaagagagcauguaguucaagaaauggcuuauuuuguuuuuuauucuucuuuuuguggucuauuuaggaaaacaaa\n", + "gupuguguacacuggcacugagcugcaguaggauuuuuccuuggauagucuggucuggagcupacagcagcugcugcuguggaaaggccagcuggcaag\n", + "agagcgcgagguggapuggaacgcpcgccugaaggaguuguugucucggcagcgcccgcggagacgugaagag\n", + "pcacauuuggcuauuuuucaaagagagcauguaguucaagaaauggcuuauuuuguuuuuuauucuucuuuuuguggucuauuuaggaaaacaaaaugaagguggccuuugucuuucaguu\n", + "gguggapuggaacgcpcgccugaaggaguuguugucucggcagcgcccgcggagacgugaagag\n", + "gcuggcuuuuuuagugagagucaagagcuggcuugguaaagucuuaaagaauggagaagaggaggaaggagagaapaagaaagapa\n", + "agaacgauggccuuucugcggugucugcgaccpaccaaggcggagcaaagucgccpugupuguuccacgcuauguupaguguucgcuuucgag\n", + "ggucuccaagccgcacggccucguccucugcuccaccuuuggccugugucucccacgcucgcucccuagacggagcucauuuguuca\n", + "gugcggagacagcgguguccugcgcgucuucpucaguacppccgcgucguapacucacuggcggugcgcgaccupcuggcuccpuggcpcgcagcugcugugacag\n", + "uagacaggaaucgcapuccucacuuguuuugacuggugugugacccugugauuguaaaauguucuucacaggaacaucgucuugagcaaucccaagaagaggaacgcguugucacuugca\n", + "agugacggcaguuccgaguccagupcggupagcgaugapucugagacggupagcgguugugugaag\n", + "cuugcggaagugacggcaguuccgaguccagupcggupagcgaugapucugagacggupagcgguugugugaag\n", + "ccgcccccgccacccaauuupagcuucgaaugcccgcccgagccuugaaggcgaaccaccugapuuaccugugucuccgaugaugauauacuugaagagauaagcauaagucaug\n", + "pagagugcpauuccupccgagagcpuggcugagccpaccucgcgugauucucggaacccgaggagaagcggcguccpcu\n", + "gagagcpuggcugagccpaccucgcgugauucucggaacccgaggagaagcggcguccpcu\n", + "aguuaugaauaaagcaapcagaaaaaaacauguapagagaaugaggaacuagguccaggag\n", + "ggaaccuagaguacuaaaggacaccagaacauugagagaaaagaauuagcgacagcuaucuggagcaagcaagaacu\n", + "aguugguaaaugacaguuaugaauaaagcaapcagaaaaaaacauguapagagaaugaggaacuagguccaggag\n", + "cguguuagccaggauggucuccaucuccugaccucaggugauccacccaccucagccucccaaagugcupauuacaggcaugacccgcugcgcccagccuaugaggauuauauuuuuaag\n", + "caccgcuagcccgcagcgcucggcuuccugguaauucuucaccucuuuucucagcucccugcagc\n", + "ucaccgcuagcccgcagcgcucggcuuccugguaauucuucaccucuuuucucagcucccugcagc\n", + "pccggcguagcuauuucaaggcgcgcgccucgugguggacucaccgcuagcccgcagcgcucggcuuccugguaauucuucaccucuuuucucagcucccugcagc\n", + "guagcuauuucaaggcgcgcgccucgugguggacucaccgcuagcccgcagcgcucggcuuccugguaauucuucaccucuuuucucagcucccugcagc\n", + "acucaccgcuagcccgcagcgcucggcuuccugguaauucuucaccucuuuucucagcucccugcagc\n", + "aagaccgacgcgaugaagcccagaccugcapuucguggauaauaaacucaagcagcgagucauccag\n", + "uauuuagcauaauuaguagugagaaggaacuuaagaauuuaacagaauuagaagaugaacauuuggcaaaaapcaagacaaggugaagaggauaauga\n", + "cuacgaggcccccgguugacuaggagcuggcgguccgagcuguggcuuggaagaccgacgcgaugaagcccagaccugcapuucguggauaauaaacucaagcagcgagucauccag\n", + "uaccuuaccaguaacaaauguggcaaauauguggacauuggagucuuagcgucugauuuacaaagaguguacag\n", + "cuaggagcuggcgguccgagcuguggcuuggaagaccgacgcgaugaagcccagaccugcapuucguggauaauaaacucaagcagcgagucauccag\n", + "pcugcupacucgcgucgguuggcgacucccggacguagguaguuuguupccpuucugaggccuugcuucucuuuacuuuuccacucuaggccacg\n", + "gccgccaucuupcugcupacucgcgucgguuggcgacucccggacguagguaguuuguupccpuucugaggccuugcuucucuuuacuuuuccacucuaggccacg\n", + "ccaucuupcugcupacucgcgucgguuggcgacucccggacguagguaguuuguupccpuucugaggccuugcuucucuuuacuuuuccacucuaggccacg\n", + "pacucgcgucgguuggcgacucccggacguagguaguuuguupccpuucugaggccuugcuucucuuuacuuuuccacucuaggccacg\n", + "ggugcgaggaggcgccgccaucuupcugcupacucgcgucgguuggcgacucccggacguagguaguuuguupccpuucugaggccuugcuucucuuuacuuuuccacucuaggccacg\n", + "ggacguagguaguuuguupccpuucugaggccuugcuucucuuuacuuuuccacucuaggccacg\n", + "acugcgcaggcgccgagcggccgaggcgccgcggucggcucupacucgucuggcgucccucag\n", + "ggucuucacugcgcaggcgccgagcggccgaggcgccgcggucggcucupacucgucuggcgucccucag\n", + "gcuggaaugcaauagcgcuaucuuggcucacugcaaccucugccuucupcugaagugauccuccaccucagccucccagagugcugagauuacag\n", + "auugcugacagaacuggaaucuccugcuugguggcccuuuagcuccaagcuuuggaagacaccaccggaaacaaagcccapaagaugucucc\n", + "aggagguuuucccaggcucgccucauugcuccugcaccugcapuucgcuggacccupcgucccgcugcccggaacacaagg\n", + "ggucccagaagcaapcagugaggaccuggcccacgucccuggcacpcugucugauucuccuucgcuguggcpaagauggccggauuugaag\n", + "apucccagaagcaapcagugaggaccuggcccacgucccuggcacpcugucugauucuccuucgcuguggcpaagauggccggauuugaag\n", + "cagugaggaccuggcccacgucccuggcacpcugucugauucuccuucgcuguggcpaagauggccggauuugaag\n", + "gccuccgcugcucacugcugugccuugaucggccuggacgagcccgcccacaccuccaucauacccagugugaagapcupacccaccacuccugagaacagcauccuupaagacccagcu\n", + "cuucacugcgcaggcgccgagcggccgaggcgccgcggucggcucupacucgucuggcgucccucag\n", + "acapucccagaagcaapcagugaggaccuggcccacgucccuggcacpcugucugauucuccuucgcuguggcpaagauggccggauuugaag\n", + "gcaauaacugucaccggcgccgagaugcgguuccggcgcuuapcgccgcuaaacucagagcccpaguc\n", + "ggcugcgacugcuuccgaggucauguucccaggacpcgcgucuucapuggaagccuggcgcacguccggag\n", + "guucccaggacpcgcgucuucapuggaagccuggcgcacguccggaggugccgaggacccaaccagcccaaacucupaa\n", + "cgcaccaggacgcgcggupuapugcapcggccggcgcagccgaggccgcgugcggaggcggacgccgcgcccagccagugcccacagcagcgcggucagccaggcgccggacccagcuucag\n", + "agcugcugaaaucuuggapaagaaaacacaucccacccugccuccpaapccucuccuggac\n", + "aggacgcgcggupuapugcapcggccggcgcagccgaggccgcgugcggaggcggacgccgcgcccagccagugcccacagcagcgcggucagccaggcgccggacccagcuucag\n", + "guccggacccuauuugucaguggccuuccucuggauaucaaaccucpagcucuaucugcuuuucagaccauuuaag\n", + "ggcauccgcuucgauccugaaauuccgcaaacacuacgacuagaguuugcuaaggcaaacacgaag\n", + "agaacccaaguuguccaagagagaugucguguacaaaacaguuaagaccgugaagagappuuuauaaugucagaaauugaggaaaagaaacuaagguggccugaaugauccag\n", + "gaaauacccacucuuacaauaacaaacaaaaucuagcugaccacaggauucuuaaagaagaaaguaaagacuuuaugcaggaagcaggccu\n", + "gucauaacaacauaggaacaggucacccgcguguuacucaaaacuguaggacggcagugapcuuugcuaaucccagaacagagguguaaccuggcugcauauccagccucgagaaa\n", + "cacaguucccggucccuagacaacccuggcucugcccgcccacuucgcguguucgauuggcuuguccuuccccuuucuaagaccggagacuaag\n", + "gcugaacuuccggccucaggacgcaggcgcpccgcucauuucgcucuuuccggcggugcucgcaagcgaggcagcc\n", + "gucugccuccgcagagcaaguccuggacggacggcugcuugagcccacaggucgugcguccuuugacagcggccuccggccpaggcaccagcucuucgaacaau\n", + "guuuaaaagucucuucuguucauccuaccpugccgucuccugccggucuuuucaucucaccag\n", + "guuccugcgugaagaccagcupagcccacugccugcugccaccuccaacuccggcccccucacc\n", + "agucuagcuuuuugccupaagaagaggaaaauauauuuagacgaacaaccagaaaucuauuucuauucucuggaagagcuuguauaa\n", + "guuuuuuuaauuacuugaccuauuuucuugcugcuggugcugucacuuupaauugguuucuuugcuuuggcaucagcuuugugguuccugauuugcaaacgaag\n", + "ggcuccacccccaagccaggcgaggcagguuccgagguuggaacaccuggcgaguccucggugucgguggccggcagucaucucgcggccguucag\n", + "aggcgaggcagguuccgagguuggaacaccuggcgaguccucggugucgguggccggcagucaucucgcggccguucag\n", + "cguccgcugcaguccgccggcgapaguuacgcacguccugauucuccuggagucuccagcccgcccaguggccgcagucacccagguccagaggcggcgguaucacaggcucuccgac\n", + "guccgcugcaguccgccggcgapaguuacgcacguccugauucuccuggagucuccagcccgcccaguggccgcagucacccagguccagaggcggcgguaucacaggcucuccgac\n", + "pagccggcgcupucgcgcggaapagcccccggagaggcpagccpuguuggcguuuugguucuuuuuguucauugagcgcaggcagcuaugucuucuucaaaggagaggagcaaag\n", + "auuuaaugugugccgaccauuuccuucagugcuggacaggcugcugugaapacaucaccuuuucgcuuuuuccaag\n", + "aaaugcagaaaucaccugccuucugcauugauccuguupagcugcagaccagagcuguuccuauucggccaucuugccagccuguggag\n", + "uucuuuuuguggacgccaggccauaucuucaaagcccgugagagauuuuucaggugcuguuuguugguuugcucuuuuuaauuuuuuag\n", + "ggucuugcccugucaaccaggagugcaguggcacgaacauagcucacugcagccucaaacuccupcuccaggaaucaugccaccucagccaccugaguaacuaggacuacag\n", + "aguuuggcgguuccgguaccgcucucacauupcpaugupagcggcugaacugcgcagcagaggacuuuuauucucgucuccuuca\n", + "gcugauguccaagugcaguugaucagcaaaggccaaccaaacccuuugaaaaauauucuaaaugaaaaugacauaguauucauaguggaaaaagug\n", + "ccuuuagaaaaggaagaaacaagucauauugaagaacuucaaucugaagaaacugccauaucugauuucucuacuggcgaaaauguuggaccacuugcuuuaccaguupaaggcaag\n", + "aguucaguuuggcgguuccgguaccgcucucacauupcpaugupagcggcugaacugcgcagcagaggacuuuuauucucgucuccuuca\n", + "gccuucucucagcuccuuggccuacugccguggccuuggugccccccuccucugguggucagcucapcuuccucugccc\n", + "agguuuguaaaugauugccuggcagccaccuuggaaacuuggcucccucaaguucuccucuugacugcauucuugaggaagcagaagagaca\n", + "aaaacugagaauauuuuugaauuucaaaaaccuugaaacuuguuuaaaggaugccauucuacuagauuauuauguaucuggauuuuugupcuagagga\n", + "ccuagcgaugcgcauccpucacgcuaacgccgcgguuuccuccgcucgauugguucuacugupucuggacugaucuccauguccuguugupcuuuuacagccuuugg\n", + "auugugaaaacugcugagagagacuugcaauccagucacauaaguauaauaaagaaauauugguccuc\n", + "aaacugcugagagagacuugcaauccagucacauaaguauaauaaagaaauauugguccucauggaagaagagcaagauuuaccagagcaacca\n", + "ucaaguaagcaauccagaugucagugaucagaagccugaaacaucaagccuugcuucaaaccuucccaugucagaggaaa\n", + "auugugaaaacugcugagagagacuugcaauccagucacauaaguauaauaaagaaauauugguccucauggaagaagagcaagauuuaccagagcaacca\n", + "aacgccgcgguuuccuccgcucgauugguucuacugupucuggacugaucuccauguccuguugupcuuuuacagccuuugg\n", + "ugucaaaauuagcgaccugcuauggcaaugaagaaagaaacugaauuugucauuuucaccugaagaaaa\n", + "aguuaucucaauauggcupcaugguggcugaugccuguaaucucagcacuuupaggcugag\n", + "agccgccgcuuggcuucuuucacacpuugcuucggaggaauccgccgugcaaaucuguccgcccccuuggccacugaucccccgaagagcuucugucgccgcucuagg\n", + "cgccgugcaaaucuguccgcccccuuggccacugaucccccgaagagcuucugucgccgcucuagg\n", + "gguugcuucggaggaauccgccgugcaaaucuguccgcccccuuggccacugaucccccgaagagcuucugucgccgcucuagg\n", + "ggcuucuuucacacpuugcuucggaggaauccgccgugcaaaucuguccgcccccuuggccacugaucccccgaagagcuucugucgccgcucuagg\n", + "ugcacuucgcpagaaguuguuggcgcgaauggauccugagccucgauaacagauuccucaaccggcccacccgccagccagccagcgccuucauccupcugcg\n", + "gucuucgccuucuugcacuucgcpagaaguuguuggcgcgaauggauccugagccucgauaacagauuccucaaccggcccacccgccagccagccagcgccuucauccupcugcg\n", + "pagaaguuguuggcgcgaauggauccugagccucgauaacagauuccucaaccggcccacccgccagccagccagcgccuucauccupcugcg\n", + "guagugcaguuuucuccaacauggccgcgcccapagauggcgugcaaguauccgcugcgguguucuggugcuagaguggagaggcuggcaaagaagaaggcacacgcaug\n", + "gccuugccagcuapcugagaaccuapaaapauggaucccagaggcgcccuuggugcagu\n", + "ccuagaucaggccagcauuucuaauuaacaagcuggauuauuauuauuauuuuuuuuaccucucaucucucugcuaugcugccagccagccugccugccucacuggccuuacauccua\n", + "ggcgugcaaguauccgcugcgguguucuggugcuagaguggagaggcuggcaaagaagaaggcacacgcauggugagaauccggccugagccgaagcggag\n", + "cagugacucacucacaugcucacaaauucagcaauuuguucaugauagcugcuuggcpuggauaauauccuggucaaaaugacugagccacaucagugau\n", + "gucguuccuccaaagaugccgupucagauaucuguucauguggacaucacugccaccccaggaacpagaucauaaagucacuguaaaag\n", + "aaacugaaucaccugcapucugacgccugcauggaaugaugapaaauuuaauuuuccaagcaaagug\n", + "gagaugapaugcaugcucaaggcagaauguacauauugapccagagcuagagaugaauuuug\n", + "cgcccaacccaaguucaaaggcugauaagagagaaaaucucaugaggagguuuuagucuapaaagucauucaguggaugugaucuuggcucacapacg\n", + "guguuugucuugacuggcuagcaacuuagaacuuuuuaaaagaggcaaaggcagaggagaacaaaggaaggaggaaguaacuuguggaauguugagaaag\n", + "auuuuauaaaguagaauaguaauucccagguugcaggcuugugagagccuuagguuggauucccuagcuugaaaaggagaucguuuuacaagugcuucauugaggagagcucugaggcagapa\n", + "agguagagcgccpaccugugacapcugguagcagcgcagaggaaaggcggcuuuuagccag\n", + "uuuucaagacuccuggaucagaaacaaagugguacuuuauauuuuucacucuucaaauaaggaaacuguugacucauuucuaaucucucgucuucuggacaaag\n", + "aguagguguuagcagcuuggucgcgacaggugcgcuagguagagcgccpaccugugacapcugguagcagcgcagaggaaaggcggcuuuuagccag\n", + "gcuuggucgcgacaggugcgcuagguagagcgccpaccugugacapcugguagcagcgcagaggaaaggcggcuuuuagccag\n", + "ggaaacccuggucgcaccgccapugagcuggcggcpaggcpcagcggagccaagcugacccggcgagcggagccpcuggagagcggcgaccacugcggaucucgg\n", + "aaggaagaaaugauguaaaucacucauccaaaccuuaaggucaaaggugagaaggaaggucaggaagaac\n", + "aaacccuggucgcaccgccapugagcuggcggcpaggcpcagcggagccaagcugacccggcgagcggagccpcuggagagcggcgaccacugcggaucucgg\n", + "aggcpcagcggagccaagcugacccggcgagcggagccpcuggagagcggcgaccacugcggaucucgg\n", + "cuggcggcpaggcpcagcggagccaagcugacccggcgagcggagccpcuggagagcggcgaccacugcggaucucgg\n", + "agcggagccaagcugacccggcgagcggagccpcuggagagcggcgaccacugcggaucucgg\n", + "gccuugcupaggcacaggcagcguccaccccgaugauguccucccgccggcaucccgcagccuucgccuuccugguucaccugucgcuuaccugucucgcucucucaccucugcuggucagcag\n", + "cuaacauuacuggccagguccgcagcagcagaguucugupcucccagccuccgcccuccucgcccuccuccgcgccggcag\n", + "gugcuccaggaaccaggaguugaagaccupucugaggcacacuuccuaaagucagcacagcagaggaggcccaggcaauaucaggagucaag\n", + "guucugapagcaaaccucuuaggaagacaggcgaccugugaggcccuagagcaccaccuuaagagaagaagagcu\n", + "gccugupaucccaucauccccaucccugcucacacguuuaccugcugcuccugaacaacaggccuc\n", + "guucugapagcaaaccucuuaggaagacaggcgaccugugaggcccuagagcaccaccuuaagagaagaagagcuguaagccagccuuugucagaaccaucauag\n", + "gaggaccccgauggcggcgccpuggcpaaggaggaaguuucaaagccagcuugacgugguuguggccguupcgag\n", + "ggcggcgccpuggcpaaggaggaaguuucaaagccagcuugacgugguuguggccguupcgag\n", + "ccuguuaggcgagagcugcgaaaggcgagagcugcgaapccaggugucpcgcuguuucucg\n", + "cccagaaacucugaggcggaucccccaacccagugucagacugaucgccuuuggcccgapcgaggagccacaggacagu\n", + "gucacuguacgcugcccagaaacucugaggcggaucccccaacccagugucagacugaucgccuuuggcccgapcgaggagccacaggacagu\n", + "uguugcuguugacuuugugccugacagugguupupccaccaguaacuacuucgupugccauucaagagauuccuaaagcaaaggaguuc\n", + "ucuccuccaaucugaaauaguuccucaguuuuuccucgucuuucaugauuuugauucuucgaagaguaccaguuagguauaucguggaaugaacuugug\n", + "cuuaucuuccuugccagauuuuaaaaacuauuauggaaaaucucaagcauucacaaaaguagagagaaagaaaggacucucag\n", + "acggaggccgagccuggcpaggcaccggcucaggugcuggcguuccgcgcggcgccgccucugcugcpccpagccagacgaggugcugccgg\n", + "agugcuagcucgccgcggccgccuccpugaguacgcuggcuccgccggcgcccpaaaugcaguucccuggacacpcgccgugcgapuagccpcgacggccp\n", + "aagagccgccucccpcggcupcgguccccgagcugcuuuccgcguucuccccucuccgcpcagugcuagcucgccgcggccgccuccp\n", + "ccuauuucaaugauauugcuguaggugcaguaugcuguapuggaucauucacagaaucagaagagacuuuacauc\n", + "aggccggcuugcpuugaguggcccgagcuaapugcggagaccuaapcggcgacuacgacggcguugauaucggugguaacgacggccucagcaggcpaag\n", + "uaagacguugcacaggcacugaacggccauauccgagcgcucucagguccucuugacuugaacupucauuuuuaacugucucgguuuuaagucuuuugugagguccaaa\n", + "uggaccuccacagagaagucgapaagaggaucagcaggcuucuaaucaaccaaauucaauugcuuugccaggaacaucagcaaagagaaccaaagaaaaa\n", + "paggcgcggccgccgcuccagcugcgaguccgcccgccgcccgccgccgccgccgccggcucggucccgcgcccgcc\n", + "gcugugccuuccucaccuacugugccapauuccgccaucaaagcucagacugcccugcacgagcagaagaccuugcccgga\n", + "gccagugugcgaggcagcgugaagcupccugcuccccgcagccucuggagcgcaucucagaccuucugagaccuauguugcuggccccccagaacccgcaac\n", + "ccgcgcagucpacacpcguccagacgccggccccuagcupcuucuccucuaggccucuggcagcpaccuggcaug\n", + "auuccagagaguccucuauuucauaugugccuuccagaacaucucuugugguauucacuacuuggcuucuguguuc\n", + "gcggcgcucgcgauccgaaaacaucuccacuuccuccucaccccgcgcagucpacacpcguccagacgccggccccuagcupcuucuccucuaggccucuggcagcpaccuggcaug\n", + "auuccagagaguccucuauuucauaugugccuuccagaacaucucuugugguauucacuacuuggcuucuguguucaupagucaccccucauc\n", + "acuucagcuacpacggacgaguacgacggagapaaugaggagcagaapcccccggapcucagagacc\n", + "agaggaagaagacpaggaggcgcgapcggaapacacuugacuuucccucuggucucuucpccgcpaapucggcgcggacggagcucpc\n", + "cuccuuuguugcgcgaugapucpuuucggaucugaccgagccgccgccgcpauggagccgcucagccaccpccugccgcgccuguccuggaucgacacccucuacagca\n", + "gaaagccggcpacuapaacuagcpacuggcagccpacugagcgcuccacaggcgccuucucuccagcgccgcgucccgucccccccggc\n", + "aagccacuacugccucuaaaauaagaccacaaggcaaacacccagagacauuugagccuccaacuaggaaacuagcagaagcucuaccacugcccacagcaaagauucaaaauup\n", + "agccacgccccaapcgcagccuaggacapcuucuggagcuucuggcagccgucugcccuc\n", + "guuccggcgccggcuuuggcggapupacuugcaccggcgucucuucuucuaacugcaguuuguggcagcgccauuuugaaugugcagcugcagcpc\n", + "ggcggapupacuugcaccggcgucucuucuucuaacugcaguuuguggcagcgccauuuugaaugugcagcugcagcpc\n", + "guucauauugagauccauugaaggcccucccagacugacgaaggcgugaccucaggcccaccgcauccaagaacacgaagc\n", + "agagcggcupcggcggcgcggcucccggugcuccccccggcgcgcgccccgagucggugapcccggcucugcggcccccggagcc\n", + "ggagacagccgcggcgcugcagagcggcupcggcggcgcggcucccggugcuccccccggcgcgcgccccgagucggugapcccggcucugcggcccccggagcc\n", + "aucucucucucccucuccguugccuuuuacugucguuccugccuccuccgauucgcuuuguucac\n", + "gcggagccgagcggagacagccgcggcgcugcagagcggcupcggcggcgcggcucccggugcuccccccggcgcgcgccccgagucg\n", + "ugcagagagaugccaaaggccaguaccuguuugaccuucuuugccaccaucugaaccuacuugagaaagacuauuuugguauccgcuuuguagacccagauaagcagcgg\n", + "cccagccuccauucaccaugugcuuccgugugaaguuuuauccugcagacccugcugcucugaaagaagaaauaaccag\n", + "gcauagaagccccaggcucugcucaucuauguggaaguggagguggcucuugcuuugcuucagaaaaccaaauccauccaaaucauagacacccuaaggcuuuag\n", + "guauuuagucuuccugcagaucaaaapaucucuaccauggccgacuccucuguaaaacaucggaugcugccuuguuagcagcuuacauccuucaag\n", + "cggagauupauuaugacucapaaacacccugaaggcuacagcuccaaguuccaguuuuucccuaaacauucagagaagcuggaaaggaaaauugcugagauucacaagacggaacugag\n", + "gaguuucagaaucaucuguaagaggccuggaauccagaggcacccaapaauuagcaacaagaaauacaua\n", + "agagaugccaaaggccaguaccuguuugaccuucuuugccaccaucugaaccuacuugagaaagacuauuuugguauccgcuuuguagacccagauaagcagcgg\n", + "guggcgauguaccgauacccgccugcgacgccgugguggcugguucccugucucuucaguagagagucuagaccccacccagucuuc\n", + "apcacuguuugaagaagcaaacaugguagcaucaagcauuccuugaaauauggcuccaapaacaaugagacgugcucuuggucuuggaagcucaucaga\n", + "ggcugccgaggcgaccguugcgcgcgcpcgguggcgcpccgaagcgcccggagcpagcgagcggcgcggcccg\n", + "ggcacuguuugaagaagcaaacaugguagcaucaagcauuccuugaaauauggcuccaapaacaaugagacgugcucuuggucuuggaagcucaucaga\n", + "cucgauggccccgccccgucccccucccgcuggagccggcccggcccgcgcuccuuuaaggcagcgaacpccaagagaagcguguuucgcccccuccgacgccaccgag\n", + "gaaaaagcuuguggugaappcaaaaaaaagaagcaaguucugaaguucacucuugauugcacccacccuguagaagauggaauc\n", + "uggaucaaucuuccuguccuacaacugacaaaggauccccuaaagaccccuggaaggcuggaccauggcacaagaacugccuucauccaucaccpagcaaguguggaagagaugcaucaacauuug\n", + "uguuugagupugaagacggcauccggcupcccuggcacucugucgaupccucuucccuccaupucccuguucccccaucugucu\n", + "acccucuucuggcugugcccaagugcugucucacccupcauacaccuguuaccagcuuggccupcccccaguppcggcugcucucagcuucacccguggaugcugcuauccgg\n", + "guaupaugucucaacagagaccugugucccccuucccugguuccgaggaggupugaccaaccugcucugguccccagacggcagcaaaauccuggcuaccacuccuucagcugucuuucg\n", + "auugaacaaaucuccccuguggacugucauuuaaaagcacaaauacacuacauagagaaaggcuugguucuuaucaggacacaaauuuaaaggcuguguggacuugg\n", + "aguuucuuugcagcuaccaggacagagcuuggugagauaauucuuuuauucuucaacuuuuauuuuaacuucaaugguacaugugcag\n", + "gcacaaauacacuacauagagaaaggcuugguucuuaucaggacacaaauuuaaaggcuguguggacuugg\n", + "uuuaaggcugcaagcaguauuuacaacagapuacaaguucuaucugaaaaaaaaaggapacu\n", + "gucucgccuucacccccccaauuuccuccuugccccucauuuccacccuccucccccucccccggccacuucgcuaacuuguggcuguugug\n", + "uaugaaaugguucaagcuggcuuauucaggucugcugagaucucuacugguuugcuuuucagaucccucgugguucgagaacaga\n", + "acgugugaggaugucagcgccuguguggccgcpacucaaggcuggccuggcucaagugaacagcacguccaggaggcgaccucguccgcpuuugcauucupuggacgagcugg\n", + "puucgguccgagcccggupaggcucccggagcgcagccupcccagcccaccccgcgccggcggcc\n", + "gcugccgcapaccgccgcgugcpcgagapagcccccggupuggcgcagccggcg\n", + "gcpccgcggcguggagagcpcpagccgcagccgcagcgaggccggcpcpagcgcacggaggupucggccaggccggugcpcuccuugcggcaggucccaaga\n", + "gugaggaugucagcgccuguguggccgcpacucaaggcuggccuggcucaagugaacagcacguccaggaggcgaccucguccgcpuuugcauucupuggacgagcugg\n", + "cpagccgcagccgcagcgaggccggcpcpagcgcacggaggupucggccaggccggugcpcuccuugcggcaggucccaaga\n", + "ggcpagcpccgcggcguggagagcpcpagccgcagccgcagcgaggccggcpcpagcgcacggaggupucggccaggccggugcpcuccuugcggcaggucccaaga\n", + "ccpacapuucgguccgagcccggupaggcucccggagcgcagccupcccagcccaccccgcgccggcggcc\n", + "gagccgcagccgcagcgaggccggcpcpagcgcacggaggupucggccaggccggugcpcuccuugcggcaggucccaaga\n", + "gacaauccuccaaacacagacuguuugacuuagaaucuucccuuuuuuacuccauucaagagcagcauucauaaauuuccag\n", + "aggccaucccaauguugguuuauguuuauuuuccacugacccuaugagugaagauauccuugaccaugaguccaucugaauauguuccagcucauccgacguuccaccaccau\n", + "guuaagagauauggagauuuccacaaggauuuggagaggagccccaguaguuacuaaaauucugcauuagaucugucaggaaag\n", + "agcggagaugapagcggccggagaagagaggaugcuguugagcguuaggucgcgaccccugcuggaag\n", + "ggagaugapagcggccggagaagagaggaugcuguugagcguuaggucgcgaccccugcuggaag\n", + "gcggagaugapagcggccggagaagagaggaugcuguugagcguuaggucgcgaccccugcuggaag\n", + "cuuccccuaacugaaagcuggaugaugacccgaaggaccagugagacugcagcuuccggaacucauucacagcaguaaua\n", + "gcuuuauuugcucucagaagucgguuuccuuuccuuuucuucagugaaucggagcucagagcguugcuucgguuucccuccagacag\n", + "gaggaapcucgugcccuuucuucucuuccapcuccgcuuuauuugcucucagaagucgguuuccuuuccuuuucuucagugaaucggagcucagagcguugcuucgguuucccuccagacag\n", + "ggaaaccagcagaugapcguaagugaaaaagcugaaguacaauugucauguuguugugcaugccauucaaaggauuuuacaaacaaugac\n", + "cccaaaguucgaaaccaacagaacgaaaagcaacgaagcacacuuaaagugaggaacccggcaagcggcgaaauucuugcugaagagaagaaaaagcgaaagguuuuccgcugcaaccaaucag\n", + "gcuucccagcuggcguguauguuguaaagagaguucuucagcuucagcgucaucauauuacucucaagaugacaacugcgcacuagaaaaugaagauguacaauuccagaaaaag\n", + "gaugaaagagapaccuaucaaugccgaaucauupaaaaucagguucaaauuuaccuauuucuccaaaagaacauaaauuaaaagaugauucuauuguggauguacaa\n", + "agcucugauuauacaaaaccaggagacauugacccuacaucaguagcaagucccaaagauccagaagauauaccaacauuugaugaauggaagaagaaaguuauggaaguagaaaaagaaaaaa\n", + "gucagucgaugcaugcaucuucuaauggagguucacaugccaccaaaaagguccagaaaaaucgaaauaauuaugccucaguagaauguggugccaaaauucuagcagcuaauccagaagccaag\n", + "agcacaucugcuauucuuauagaaaauauggaucuuuacauguugaauccuugcagcacuaaaauuug\n", + "guuuguuauugaacuuugugaaccaauucaaguaaaacagcuugauauugcaaauuaugaauuauuuucuucuacuccuaaagauuuucugguuucuaucagugacag\n", + "auauccaacaaauaaguggauuaagcupuacuuuucaugguagagaugagcggaauguacagaguuucccuuuagaugaacagauguaugcaaaauaugucaag\n", + "gguauuuggcacuagcaugguggaagaauaugaagaaauugcugauucccaguaucacucagaacgccaggaacuauuugaugaggacuaug\n", + "auuauccacuggauuauaauacuggagaggauaaauccucaaaaaaucuucuugguucugcuacaa\n", + "gauuauucauuuaugaaupuggcuguaaaaacuugccucaugcauaugaaaauugaaccuggaaauuuuuaauugcu\n", + "aacccacugcuuuauucugcccugaguggagauugguuuuggcucaggcugcuuugugaaacucagaagcauuauccucucugccaacuccacguccuagucagaguuuucugugaaggcaapc\n", + "aucccuauaggagcuggugagauugcagccugcugccuccccuccaacagccacagcuauuggauuucccacccagaaucuuuagguaaaugag\n", + "cugaaggcggaaccacgacpcagagagcacggagccpaagccccupcgcccgucggapcu\n", + "gaaggcggaaccacgacpcagagagcacggagccpaagccccupcgcccgucggapcu\n", + "guucccgcagagauacugacugupaccugccugccuggcuucuaugaacauggcgauggcugcguguccugccccac\n", + "gcpagcggagagcggaccccagagagcccugagcagccccaccgccgccgccggccuaguuaccaucacaccccpaggagccgcagcugccgcagccggccccagucaccaucaccgcaacc\n", + "puaccugagugagauucaucguagaugccuggaugaagagapccuugcgcuucuauuugccuuguuacauagug\n", + "uuucuuggaaaggcuguccuucccuacuccaagccccuccccucacuccccacccaggaucupcacuggaggcgccagacaucuuaugcccuguccaaggcuagcag\n", + "acagcccacagaguuccaccugcucacagguuggcuggcucagccaagguggugcccugcucugagcauucaggccaagcccauccugcacc\n", + "aguuggcuguagcupcgccucgguuaggugcgcugucaguccuuuccgagugccuggcccagucucucccgccucggcccaac\n", + "gcaccuccgcugagcuuuuaaaccaagucauupacuuagcgucuuucuacccggcapaapaggaguuggcaagaauuuggcucacccauucccccugcaagccuccagcgucgcg\n", + "cuuugccgcggugguggcagcgguggcagaggcgacaccgcuggaggcggcggapacpcccaccaacgcugcag\n", + "ggucucgcucugucacccaggcuggagugcaggagcagaucauaguucaccgcaaccuccgccuccupcuccagugauccuuccaucuuagccuccugaguagcupaccacag\n", + "ggacagucugapagccacugucccuuguccacugacucacuggcugguccgaguuuucuccgcuucuggcagug\n", + "uuucuacccggcapaapaggaguuggcaagaauuuggcucacccauucccccugcaagccuccagcgucgcg\n", + "ccuucugaagcuggacuugaaccugagaaaaugugaccupcugcuggcggccagcuuguccccguuaggugacaauaagcagacagaagagccaagcagcuauggaggaaaaucag\n", + "gcaacguucguucuacauaauucagcaccagcuuagauucucacuaucaaauugaacccuuuccccuuugcuauccacacag\n", + "aaggcaucuuagcgcuguccguggugcugaccgccaauccccugguugccguuucgaccagcupaucucug\n", + "agagcuaaaaccuucauccauguggaggacagucugapagccacugucccuuguccacugacucacuggcugguccgaguuuucuccgcuucuggcagug\n", + "gcuccaggcaggcugguccguccaccccgguggucagccugacaggcagaggaagcaggaagagcugacugaugaggagaaagaaaucaucaacapugauugcucgagcugagaaa\n", + "guucuugcucuguugcccaggcuggacugcaguggcaccagcauggcucacugcagccucgacccccuaggcucaagugauccuccugcuucagccuccugaguagcupaccacag\n", + "gguggcuuugccgcggugguggcagcgguggcagaggcgacaccgcuggaggcggcggapacpcccaccaacgcugcaggccg\n", + "gucuuucuacccggcapaapaggaguuggcaagaauuuggcucacccauucccccugcaagccuccagcgucgcg\n", + "aaaccugcgaucgccacgguccuuccgcccucuccuucguccgcuccaugcccaagagcugcgcuccggagcupcgaggagagcc\n", + "cuuucagaugauucuuuugaaaauucagacaaaacagcuagacaaucuaaaaaagagaugaagaagaaagauacagugccuugguggauaacugaagaugauuuuaaagaugaugguaaauguugcu\n", + "uucuuugaacauaaaucuucaucuguauuaaauuguguaccuaggacuucuuggaacaaaugugagcuauuugaaaacaaagaagacuucucagccuguu\n", + "cuuucagaugauucuuuugaaaauucagacaaaacagcuagacaaucuaaaaaagagaugaagaagaaagauacagugccuugguggauaacugaagaugauuuuaaagaugaug\n", + "gcgcgccucgcgcggccgcggcgcgagccpaccccuggaapucpugcgcggcccaggagguaccgcugucuccucacaaucgg\n", + "ggcuaguugcacauagugauuuagaugaaagagcuauugaagcuuuaaaagaauucaaugaagacggugcauuggcaguucuucaacaguuuaaagacagugaucucucucauguucag\n", + "gaaagcggagccgcgcggcugcgaggapcccacuguccaguupagaucgagucuccaapcgacucucgcacucgaguaccgccaguccggcggaccaaag\n", + "agagcgcpcgguggcagcggcguggacaccgccuggaacggcuacgcggccgcggagccpcpccpcgcgcacagaccg\n", + "cuccacucgcgccggacacapagcagcgagcacgcguuucccgcaacccgauaccaucggacaggauuucuccgccucagcccaacpag\n", + "acucgcgccggacacapagcagcgagcacgcguuucccgcaacccgauaccaucggacaggauuucuccgccucagcccaacpag\n", + "cggcgugagcuucggccgccauuuuacaacagcuccacucgcgccggacacapagcagcgagcacgcguuucccgcaacccgauaccaucggacaggauuucuccgccucagcccaacpag\n", + "agcggcgugagcuucggccgccauuuuacaacagcuccacucgcgccggacacapagcagcgagcacgcguuucccgcaacccgauaccaucggacaggauuucuccgccucagcccaacpag\n", + "acgugcgccugcagcuucccgaggaggagagcgcpcgguggcagcggcguggacaccgccuggaacggcuacgcggccgcggagccpcpccpcgcgcacagaccg\n", + "ccuucgccgaagguucccgugaaagcggagccgcgcggcugcgaggapcccacuguccaguupagaucgagucuccaapcgacucucgcacucgaguaccgccaguccggcggaccaaag\n", + "ugaauccggaagugacccuagagaaacgaguuguggcugaggaccccggcggcagacgcagguucpacc\n", + "gguugaauccggaagugacccuagagaaacgaguuguggcugaggaccccggcggcagacgcagguucpacc\n", + "aagugacccuagagaaacgaguuguggcugaggaccccggcggcagacgcagguucpaccaugagcug\n", + "gcuuacgucacuuccuggagacugguugaauccggaagugacccuagagaaacgaguuguggcugaggaccccggcggcagacgcagguucpacc\n", + "gaauccggaagugacccuagagaaacgaguuguggcugaggaccccggcggcagacgcagguucpacc\n", + "aguuugcuguaaguuuccuuacuuuguuacugaggcccccagagcuccacgcauaaguggugugaccagaaaccuuuuaacaagacccgccugagccugcguuagagcucccgcucggaaa\n", + "aguccucagcpcgcguggcgagcggacucgacucggcaccgcugugcaccauggcccpcccugugccgccucccgcggcgcggccucuggcugcuccugg\n", + "gcauaaaucuuagaagaacuaugcuuugcugagaggcaaagaauugucucuacacucugaugcpauaugcaggaggagcccaggaggucccugugapugcaaaccaauuaa\n", + "aguaagugcauacccgcuaguggucuguacaggcggcacgguuugauggcagagauauuuucuuuccaaacuguucaaa\n", + "aagugcauacccgcuaguggucuguacaggcggcacgguuugauggcagagauauuuucuuuccaaacuguucaaa\n", + "gcagcaguguucuupcugugccugucaagugaagaugacauaagccuagauaucugcuugaauuguuucgcugauuucaucuugaaagaapcugguaucucuccag\n", + "ucugacagcaaugcaagcuuccuccgugcugccagagcaggcaaccuggacaaaguuguggaauaucugaappcauagacaucaauaccugcaaucag\n", + "aauggacucaacgcucuccaucuggcugccaaggaaggccacgupcuggugcaggagcugcupaagapuccucuguggauucugccacuaag\n", + "aapaaauaccgcucuucacauugcaucuuuggcuggacaagcagaaguugucaaaguucuuguuaaggaaggagccaauauuaaugcacagucucag\n", + "gucucuacacucugaugcpauaugcaggaggagcccaggaggucccugugapugcaaaccaauuaa\n", + "aauggcaacacugccuuggcgauugcuaagcgucupcuacaucuccguggucgacacccugaagguugugacugaggaggucaccaccaccaccaca\n", + "agacaucagcuugcapaagcupcucuccgaauugcccugcuccpccccuccugcugcgugacucacaggcacauugcagagagaagcugccgcuccca\n", + "acguugucgcpccaguaacgucaucagacgugugugugucccugcggcgcuaagaapagacugaggcugaggcupaacaucpcagc\n", + "aacgucaucagacgugugugugucccugcggcgcuaagaapagacugaggcugaggcupaacaucpcagc\n", + "uggacucccgaaaaauugaccaggaapaaaaucccagaugaaacuuuggagaaauugaagagccuapcuuuuupcugcaagucccagaagaauaug\n", + "agacgugugugugucccugcggcgcuaagaapagacugaggcugaggcupaacaucpcagc\n", + "gcpccaguaacgucaucagacgugugugugucccugcggcgcuaagaapagacugaggcugaggcupaacaucpcagc\n", + "aucagacgugugugugucccugcggcgcuaagaapagacugaggcugaggcupaacaucpcagc\n", + "gacugagcugcuccuugupaacugcugauguuuugacaaaagaaagapaagguggaacuacacaguggcuuuuaaguuucugcuuggaa\n", + "aacuuugcucaaagucgcuggacucuaagcugucggapaccgcuggacagaccupaacugacagapccuggapaaacaggccaaagacccacag\n", + "gcgcgucgagaggcgacggcpcuggccuggcgcgcugcggcgcucgcucacccgcucccgaggaapcagupccccgccgccgccuccca\n", + "acuggccgcggcucguguccpcuucpagcuccugguuccuugcucuauupcuguggcugaggugauccgcgcucaguguggacgcacaa\n", + "cuguauuuupcgauauugccuuagaugaugaagacuuaaauaucuuucaaauagauaggacaauugaccuuacgcagaaccccuuuggaaaccuuggacauaccacag\n", + "agacucaacaagagcuccagcaaagacuuucacuguagcuugacuugaccugagauuaacuapaaucuugagaauaaag\n", + "upcuacagupccgcucugccucgcucccgcccgccugccucagucuccccagcucucugccaccccccucggaccagugccucuuag\n", + "acacccuccgccuggacgcagcagccaccgccgcgucccucucuccacgaggcugccggcuuaggacccccagcuccgac\n", + "cuccgccuggacgcagcagccaccgccgcgucccucucuccacgaggcugccggcuuaggacccccagcuccgac\n", + "gccaccgccgcgucccucucuccacgaggcugccggcuuaggacccccagcuccgacguaagucccucucgugcgccaccuccauccgcugccccucugcccacpccpcucag\n", + "cuuuguggucuacagccacaccaccccaaaugugccugaucuugucugaucuuggaagcuaagcauuguupccuaguuaggaccuggauaggagaaaucccuuaug\n", + "ggapapaggaapcgccggaggcpcpauccugcgaggcgcgugaagccucgcuggcgccucguccgguacucagacgcuggcpcgcaguuucucacgacpccgagccugccacu\n", + "aggcaggcauucaacaacauguuuugcuguaccuugcaguguuccgaguucuaccuuuuucacuuguapauucuagagaucaacaaaaag\n", + "auuuuupaacguuacagaugcuaccuugucucauggaauacugauugugauguacagcucaggacuggucagacucuauagcuuccaaaccaucgcugaacag\n", + "guagapacaguggauaggugcccgaggccuacagcuggccupcucgugucupcuucggacguupcccgguggcccacccuuuccguaguugucccaa\n", + "auacaggaagugacgauacuuuuggcgcgcgccgguugcuguuucuucucuggcuccpaccggcggcggcggcggcggcagcggcggcggcguap\n", + "agugacgauacuuuuggcgcgcgccgguugcuguuucuucucuggcuccpaccggcggcggcggcggcggcagcggcggcggcguap\n", + "acagccucuuggaaaggaaucucacuapcuugacugcgupucuguagcgcuuucacuguaagaaagcaag\n", + "auuuuagagaguuaaaaaguaacagacugagauaaaagcgaucguggaaauuuuuaaaaacuacuuauuuuaagaaaugcaaaacuuucuaccaacuuuguuauuuuucaa\n", + "aacggcggagccgccggccpcgcggaccggagcgcgugaggcuccggcgcgcaagcccggagcagcccgcupcgcacapucgcgcpcgcp\n", + "agaagugcgacugccagcugccgaggcguucgguccugcuguugcggccgcugccccapcugcpacg\n", + "cucccggagcccugccuguucccuguccauccaggccagcagcugaaggagccucaccugccucccuucucugaguagcacggauuugag\n", + "gagaagcagcgaagauguccagcgagccucccccuccuuauccupccccacagccccacuucuggaagagaaaaguggagccccgcccaccccag\n", + "apucuuguucugccggcgccuguccggacccpccccucuccgcuuucggccggccucpcaccpcuucuggag\n", + "cuccuugugacagaagugcgacugccagcugccgaggcguucgguccugcuguugcggccgcugccccapcugcpacg\n", + "agcaaagcagaaagcccuguuccuggcuggaugccupaccugccuccupacagaggagccccucugaggccagcuggcguccugacgccauggcugccacgugg\n", + "acagaagugcgacugccagcugccgaggcguucgguccugcuguugcggccgcugccccapcugcpacg\n", + "accgugacgucccpccucggcccugguccaaagucuacccgccuccuugugacagaagugcgacugccagcugccgaggcguucgguccugcuguugcggccgcugccccapcugcpacg\n", + "cucuucucucauuggcacugccugucuacugccgapcauuugagugupacccaugcccugcauuucuucgcuaccccacagcuucugcucaug\n", + "aauccagcucaaaugucagaagaauugacguuaguuugagagaccaaacuaaguuacagccucuuugguuucuguuacucug\n", + "aacauccaugauagcagucuucuguaaaucgaacuuuucaagaauucucugaaggaaccaaguaggauauucuuacaucaugacuuaauguga\n", + "gcgcuuccucaggcugcugucgccgcugcupagaupccuacucgcccgccacccugcgcugccgccgcucugaggaguuaaag\n", + "auagucaccagaagcuggaagagucaaaggacacauucuccccucaagccccagupagcacggcccagcuggauuuuggacuucuggccuccagaacu\n", + "agacapccucacugugucacccapuggaauacaguggugugaucauagcucacugcagccuggaauuccupcucaagcaacccugccaccucagccuuccaaguagcuaggacuacag\n", + "gacacauucuccccucaagccccagupagcacggcccagcuggauuuuggacuucuggccuccagaacu\n", + "gccugucuacugccgapcauuugagugupacccaugcccugcauuucuucgcuaccccacagcuucugcucaug\n", + "gcuggucuugaacuccuggacucaagugauccaaccaccucugcuucucaaagugcuaggacuacag\n", + "uauuupaaagcaguucaagcucuaucacgaauuagugacgaguucuggcuagacccaucuaaaaaaggu\n", + "cuugcucuaagaugugugaauucuucucggucagcauauggauguguccuguucucuccuguguuuuuucagcauuaucaauggucagcuuuagugaaa\n", + "pccgucgagcugaggcgcgccuuccgagccugcuuuuuapcggauggcagccaugcugaagugcgugaugagcggcagucag\n", + "gcagagacgagaucgcgaagcuuugaaaagcgcpcaacauccpcaccupccgucgagcugaggcgcgccuuccgagccugcuuuuuapcgg\n", + "cuuuccuggcggcagacacacaucgcaaggauauuuacagagcggacagcuggaauagcuguaggaacgucaagacua\n", + "aucccgguaugcggaaguagaucaauauuugcacaucgugaucuagcuggaucugcaauauagacagguaaag\n", + "gauccggaagucggagccuagcugcgcgagaguuucugcucgcucaaccgaguugucguguugcccucgcuucucagauccccgccggaagu\n", + "upcggagucpcgccgccggccupauccggaagucggagccuagcugcgcgagaguuucugcucgcucaaccgaguugucguguugcccucgcuucucagauccccgccggaagu\n", + "gagaguuucugcucgcucaaccgaguugucguguugcccucgcuucucagauccccgccggaagu\n", + "gaagagagcaagcagauuugaaccuaucugcuuucaagcuggucaucaugaugaaacuuagacaca\n", + "ccugcaaagcaaaaupaagaaagcaaccuccaaagugcccucugcaccucauuuuguucaccccaaugaucaugccaaucgagaggcugaauuaaagaagaagugg\n", + "pauccggaagucggagccuagcugcgcgagaguuucugcucgcucaaccgaguugucguguugcccucgcuucucagauccccgccggaagu\n", + "pacuuaggapcuuguggcauugugauucccagcugucuucaaauugcuucuucucccauucugacaggaagagagcaagcagauuugaaccuaucugcuuucaagcuggucauc\n", + "ggccupauccggaagucggagccuagcugcgcgagaguuucugcucgcucaaccgaguugucguguugcccucgcuucucagauccccgccggaagu\n", + "cgcccccgcccgcggcccagagugcgcucgcgccggcaccagcucccggauaaacggcgcgccgcgcggag\n", + "gcggcccuggccagaagcggaggagguggcacccpaccgagcupucuuggaggaagagagg\n", + "cuggccagaagcggaggagguggcacccpaccgagcupucuuggaggaagagapugapaauacaguacup\n", + "gucuccgcccaaupcggcccuggccagaagcggaggagguggcacccpaccgagcupucuuggaggaagagagg\n", + "gcauaagcgucagugccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcguc\n", + "agugccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcguc\n", + "gcgacgcguguugcgcuccggucgcauaagcgucagugccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcguc\n", + "gcgucagugccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcguc\n", + "cccaaacuccuuugccuggcuucaaagacuuccugagcuggccuguuuuuccugccuuaccccgucuauucuacuauuuauaag\n", + "gcgcuccggucgcauaagcgucagugccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacag\n", + "agugcugucacuugucugcaauggccggcagaauacaucauugucuuuggacuggcugaapaag\n", + "guucguuuagcaaacaccaaaacuaauaaaucaucuaccaucuaupacagagucuuacguggugucccugacaacaaa\n", + "uugcucupaaaggaauucucucuggucaugcagaugguaccaucguuagguauuucuuugaugaugaaggcucuggagagucacag\n", + "paaguugguuaaccacccguguccacccuaugccuuggcaupcaaccaauagcaucguggcugcaggcugugaucggaaaauuguagccuauggaaaagaaggucac\n", + "cgcguguugcgcuccggucgcauaagcgucagugccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcguc\n", + "gguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcgucaugcacuugaagcaccugaggacccugcugagcccucag\n", + "ccugucgcugcggcugcguggcpuuguccagguaaccacpaguugucgcugucuaggagcaucugaaagacaggugugcguc\n", + "auuauacagacgcauaacuggaggupauccacacagcucagaacagcuggaucuugcucagucucugccapaagauuccuug\n", + "acuucupugauggagaagaaacaggcugugcugugucccuaaupaaacguggcugagacapagugagaapugcguugcagaauggugccuguggcaugaugccagcuuugcaauc\n", + "guucpagcccgcggcccucccggccgcccugcuugcgagaggagcccaggccgcccgcccucgcgccucgccggccccucccccggucgccgcggcugccgcgccgccgcugcag\n", + "ggcacucaacaggugcucugaguggcacccacggccagguccupagaggacagaaaacaacupacuccucagcccccggcagcucccagugcccagccacccacaacacaacc\n", + "gcaguguuggaagcuccgguucucccggaaguggcccaggucucucugucpuccccuccaucucgcugcugcugaaggccgcgapcggcggcg\n", + "puuucaguuaggcgaauaaucuggagaguaaagcaaauucuugugccuucuuuauagguuuugaaagugacacagauucggaauuuacauuuaag\n", + "guuuugauaacauuguacuggcupaagaaaagcacaaagcaacccguacuauaaugguccccaucuuaauuugaaagcguuugagaaucuuuuaggacaagcacugacgaag\n", + "guaacagguaauguuuaacgugccagucacaaagaucacagaaacaguguaugcccpcauaagauagcacgacugugu\n", + "gauaauauaaacguuuucuugaaagcuugugaacagauuggauugaaagaagcccagcuuuuccauccuggagaucuacaggauuuaucaaaucgagucacugucaa\n", + "ugupuuucaguuaggcgaauaaucuggagaguaaagcaaauucuugugccuucuuuauagguuuugaaagugacacagauucggaauuuacauuuaag\n", + "gcuccuccuucgcggcgguaccgccucuguuucugcggcgauugaacagccgagcuuugcggccpaucgcggaaagug\n", + "agacpacaugcagccucuuccgccugagccccggaapugauguggcugcggcaucgccggccucgcu\n", + "ggcagccagcacuuugcgcucacccagagaguagcuccacuupugcgagaccgagapcauauccguucacgccgaucc\n", + "ccagcacuuugcgcucacccagagaguagcuccacuupugcgagaccgagapcauauccguucacgccgaucc\n", + "pagcgcacggugccccuguccgaggaaagcucaagaggaggccgaggagaggaccagugcagcgagcpccggucccpcapcgccpuc\n", + "cucccaccuccagaguccaapucuauguggupcaguuugagcuggcuggauacuagapaggcugcaccugaagcauuuggupugagcagc\n", + "acucccaccuccagaguccaapucuauguggupcaguuugagcuggcuggauacuagapaggcugcaccugaagcauuuggupugagcagc\n", + "upagcucugcugaccaapcuapcucaccuccuaugccaucacccagcuaccucaucaugguagccuuggucccugaacacuaaugg\n", + "ccaccuccagaguccaapucuauguggupcaguuugagcuggcuggauacuagapaggcugcaccugaagcauuuggupugagcagc\n", + "guguuccggccgaucccaccucuccucgacccuggacgucuaccuuccggaggcccacaucuugcccacuccgcgcgcpcuagcgcpuuucagcgacpagcccucaapac\n", + "ucuuupucuucgugcacacuaaagucagupauuaacauugaccugaaapccagacuacuacuccagccugaggaucucpuuucapcccgcccgaggcauuaggaagaag\n", + "caguggaagaacaaagcccuaaacccupaugagcagaggacuuaauggauggaacagaaaaguccugcacucuaggagccauugucuucacapcggaggcucagcugugauugac\n", + "ccuuuuuguguuccggccgaucccaccucuccucgacccuggacgucuaccuuccggaggcccacaucuugcccacuccgcgcgcpcuagcgcpuuucagcgacpagcccucaapac\n", + "ggccgaucccaccucuccucgacccuggacgucuaccuuccggaggcccacaucuugcccacuccgcgcgcpcuagcgcpuuucagcgacpagcccucaapac\n", + "cuuuugaaauucuaaauucugaugcagaacguaucagugaaacucccucccacugucucuuguauuagcaucaaggaagcgagaaaaaauaag\n", + "accugcaaagcaaaggacguaguguugaaaacgagaccagaaauggugcuguuaaagaggugaacaaaagcauuuacuuuuugaacgaguuucaaaacugugapuggcaaauaggcaag\n", + "aaggccugccgguugcucpucguaugacgcacuuuuccagcucgagcccucacgaggccgupuacgaccggaagccgcag\n", + "acugaaucucgcucuguugcccagcccaucucggcccacugaaaccuccaccucccpuucaagcgauucuccugccucagccucccgaguagcugagauuacaggcgccugccaccacgcccag\n", + "gguugcucpucguaugacgcacuuuuccagcucgagcccucacgaggccgupuacgaccggaagccgcag\n", + "agcaucgcgcgcaaggccugccgguugcucpucguaugacgcacuuuuccagcucgagcccucacgaggccgupuacgaccggaagccgcag\n", + "pucguaugacgcacuuuuccagcucgagcccucacgaggccgupuacgaccggaagccgcag\n", + "cccuuucccggccggcggccgapcaucaugaagcpcuggcggcgcugccgcucccpcggccgcpcgg\n", + "aguuggcgcacucgauuuucacugcgcgguuccaagaggagacagccgccacuguaccpccucauagccacuuccuagag\n", + "gugaucuuaauugcacaccuauugaaauaaaccuguaguuucuagaaguggaagaaaauuugcugagacgucagcupauucuuccuggagaacuccagaa\n", + "accccucuccggagcugcggcccgaguuggcgcacucgauuuucacugcgcgguuccaagaggagacagccgccacuguaccpccucauagccacuuccuagag\n", + "agcuggccucaagagaapcgguggcucgcacggcgcpcggcuuugcucacugcagcupagaugcag\n", + "aauaacauacagaggacagcuuucucuucugaggagucagaaguucaguucgcccaacauggaaugacuugag\n", + "aauccaguuccagauucuagacuugapuucupcuguuggucuguagaagcgaaggagagaagg\n", + "acucaaauccaggccaaguguauggcugucugagguauuggaacagaaggagguccauuccuguuggugacaacaccguggcccuguucupaugagcaagguguaaag\n", + "cagaauccaguuccagauucuagacuugapuucupcuguuggucuguagaagcgaaggagagaagg\n", + "ggucacpuuucauuupaccaguagccuagucuuucagccuucaggcuguuuuuggcuugaag\n", + "aaauguguggagauuuauuuuauaauagcaaugugaggaauaccuuccuaauuaugacaaaaacaaaaacaacaacaaaaagaccauugaagaaaag\n", + "gacccaaaggaguaauaaaugauuggagaaaguuuaaauuagagagucaagacagugauucaauuccaccuagcaagaaggagauucucaggcaa\n", + "pcccuuggcuccaggapacuupaagccupucggccugapagucccaggccugccgcagagucaucccaguccggccag\n", + "uguucacaggcuugcacaaucugauuugaaccucacacaupaaguaggcaaacapaaacugaggaccagagagg\n", + "gaggagcuugccauccaacapucaacuggagacaacucugaaggagcuucagacccugaggaacaugcagaaggaagcuauugcugcucacaag\n", + "gauuuuuuuccuugauuccuucgupacucaagacapugcccuguuuacucagcccacugugcucaaccucuugcaggagugugcag\n", + "gcuggagugcaauggcgcaaucucggcucucugcaacuuccgccuccupuucaagcaauucuccugccucagccucccgaguagcupacuacaggcaugugccaccaugccugg\n", + "pacuccpccccggcggcggcccaupcpaggcgugaggccgcugccuguccpcucppuppagcpcpag\n", + "apaggccgcggcpaaaauggcggacpaaggcpagacgagaagccugaaaagucgcagcgagcuggagccgccggag\n", + "aagccuaaagaaacuguuccaacucuugcuccaaaaacucuuucaguagcagcagcuuuuaaugaagaugaagau\n", + "accuccaguucugccggcuucugcgcgccpccgccucuccuuccgccggugccgcggcgccuc\n", + "gucaccggcggcgccgcugcuguggcaaaggaaggagcugacupaguucgaggcggcpcggcggugaccccggccuggaacugccccg\n", + "ggcaggcacpcapacacaaggugcucagupagcuuuugagccaggaugagccaggagaaggaauuucacaag\n", + "agcaauuuagaaaauacagagaaacacaaaugaaaaauugaagucagauacaaucaauuccaauugauuuaacauuuaaguaucaugag\n", + "gagcgcccggcuagaagcgacaccagacggagccuccggaguuccuccgcccccaccucgccpuccuggagccgcaguccucccagcugcccuccucguggcc\n", + "ccuucaaauguuuaucuggugugacuguauuaugcccucagagaguacuguauguugcccaggcuggccucgaacucuaggcucaagugauucuucugccucagccucccaaguagcupacuacag\n", + "auuuuuggagaaupaagaauguaaagauggagaugaccgaaugaggaauauuguuuugccauuaaauaagugaauagugcgaa\n", + "aguuccuccgcccccaccucgccpuccuggagccgcaguccucccagcugcccuccucguggcc\n", + "ucgagacgcagccgccgucggccgagcgcccggcuagaagcgacaccagacggagccuccggaguuccuccgcccccaccucgccpuccuggagccgcaguccucccagcugcccuccucguggcc\n", + "aaaugcauucacaaagcacggauuugcaacuucagcauuccuacauagccauggaauuuauaacuuaaucacaggaaaaupagaaauupaaauaac\n", + "cccggcaccuuuuuugcucccugauggacugguucgcuugguuaauaaacagauaaacuggcauuugguacuugcaag\n", + "uuccgaaagacccgaaaccccaguggagacpuagcauggaguuacgauuguacccuacuggccuaugccgaaagcacaggaacugugapuguuugaucuc\n", + "auuugacuuguaaagaauuaauuauauugacugagagagaagcccagaagaggaagaagaggaaagaaaaggagucap\n", + "apcgcggcuucgccuucaccgucggcucccugcuccugucagaaccucggugacgguuggccag\n", + "uuuuuuuacaguggcucugaaaugagagaaauugcagaaauucucccugcucaggaaaagguagaggcaaggauugacuuaaag\n", + "augccgcaggcggagaagcuggccaaucapcgcggcuucgccuucaccgucggcucccugcuccugucagaaccucggugacgguuggccag\n", + "aaaggaucuccuagcuggccccaucugagapcacaggcguggapaggagaggccuggaauggapauaaugagcugg\n", + "gcgacgcugcagaggcuccgaggcggcggcggcgacucccucuuucccucccuccuccuccguccgcccguccguccgcgcgucuguccguucggcccgguccggcccgaagc\n", + "gaaaccupcuggagugagguggaaggauguuugcugccacauggcgaccgcgaagugacucccuuaccgccgcpucgcggaggaggcap\n", + "ggcggcggcggcgacucccucuuucccucccuccuccuccguccgcccguccguccgcgcgucuguccguucggcccgguccggcccgaagc\n", + "caacaggugugcccupcuaugaagagaccaagacgcuccuggcuauucuuaguaguucucaauuuuauggaaaacuccagaccugucagcagaacagccagaucuacapcc\n", + "ccuggcuugcuccucaggcucccaggaaccugccucaaaacacaggucuccacgaccaggagacaggugcuguggucuggacagcupucccag\n", + "aguccggcaauucggcuugcpccugcgcapcgugcguaaupcggagcgaaucgcgccgcugacuuccggcccggaggcugapaguuuguggagucgcgagugcugguguccg\n", + "gcgaaucgcgccgcugacuuccggcccggaggcugapaguuuguggagucgcgagugcugguguccg\n", + "gcugagcuccagcugugccagaggcacccgagcccugagaguccgccgccaacgcgcaggugcuagcggccccuucgcccugcag\n", + "aaucuuaucuuggcuuuggaucuuagaagagaaucacuaaccagagacgagacucagugagugagcagguguuuuggacaauggacugguugagcccaucccuauuauaaaa\n", + "cuuugcgucucpcucgcgcgcguugccgcggcaccggaagugacugagcuugcaaguuccccugucucuucapaaacugaggccggcuuguucpagagacggcgcgagcagucagccag\n", + "gacuuuccgaggaaggcauuucggagaagacpuagaaaaggcuggupagauucagaguccacuggugcuuucgauuugacuuaagugaaguaucuuggaaccuagacccagaccuuc\n", + "auuucggagaagacpuagaaaaggcuggupagauucagaguccacuggugcuuucgauuugacuuaa\n", + "gcggcaccggaagugacugagcuugcaaguuccccugucucuucapaaacugaggccggcuuguucpagagacggcgcgagcagucagccagguaggccggcagccag\n", + "agaugccgaaccaccaccapugguuggcaaacugcagccacccaapcuggaguaguuuucaaacag\n", + "ggacapucuugcucugucaccuaggcuggagugcaguggcaugaucgaauuccupcucaagcgauccucuugccucag\n", + "auggccaaagugcacccagaaugucuucucucuccauucagugcacgcguuacuuuggcuaaaaggaggugagcggcacucugcccuuccagagcaagc\n", + "aguggcaguuggccagaugccgaaccaccaccapugguuggcaaacugcagccacccaapcuggaguaguuuucaaacag\n", + "gaggaaaagcagacgcgugacagagucagagagcaggcauagagugcuguggcagucagccagugcccacaucaacaccaaggagaguccugcpugcugugcaaggccp\n", + "cuccauucagugcacgcguuacuuuggcuaaaaggaggugagcggcacucugcccuuccagagcaagc\n", + "cpugaagaaugupagaguggcaguuggccagaugccgaaccaccaccapugguuggcaaacugcagccacccaapcuggaguaguuuucaaacag\n", + "ggauuuccupcccggcccucuggcgcuaccauggcguuuggcaagagucaccpaucccuacgcgaccuccgupccaccucauag\n", + "gagucpagccggagagcgguggaggcggauuuccupcccggcccucuggcgcuaccauggcguuuggcaagagucaccpaucccuacgcgaccuccgupccaccucauag\n", + "gccaaaagaugcagugaaagcuuugaagaaaaggauuuccaaaaacuacaaucauaaagaaauccaacuuaccuuguca\n", + "agagcccpaagcgcucpcgaagaggaggagccaapuaccgagcpuggagucpagccggagagcgguggaggcggauuuccupcccggcccucuggcgcuacc\n", + "cucuggcgcuaccauggcguuuggcaagagucaccpaucccuacgcgaccuccgupccaccucauag\n", + "gcuacauuugcuggaguucagacugaagauupccaguucaugcacaucugugacauaauuaacacuacccaggaugg\n", + "gucagaugucaggcgcggaggugcucupcaccgaggugcuggcgaaccaaacaaguaucaccccggacgccugcccccauuccgagagagcpcpauggccacag\n", + "auccaaacggaaacauuggcucuuccupuuccagccugcugucuugacaggaacuauaccaucagcucuccupucucuuacaugccaagucauccugcagaucupacucacuccguaauca\n", + "gcuugauugcuguaaguugaacacgucaguggcaupcaccagcugcacaacccuaggagccaccaaacacaguauauucuauauaaauguugcugccaggagccccaguucaaacuacaau\n", + "aaacaaagaaaaucaagucugcgaggagcgapuuugcuccccucugcuccggauuupuguccapuagcpcgcggcacggcaaacag\n", + "gugauuuugauaugcugcuaagguuugauaagagaaaugagauucagagaacagauuauauuguugaagagcuugacuggaaaug\n", + "gugacupupcugccucacuucugccugauuupaagcgcugcaaggacaaccggcupuccuugcgcgccgcggcucapaggagcaccgacugcgccgc\n", + "gcugcaauacagugacacgaucacagcucacugcuacagccucuaccuccupcuuaauccauccucccuccucagccucccaagcagcupacuacag\n", + "gacucacucuaguugaaagcccupaaggaacaaacucugcagccugacugcuguguuuaaucccagcucuccucuacuagcug\n", + "acucacacagcugccugguaggugacuggaggccuugauugguucucauugagauuuugcugcugugaccccaacccugccucccuccccacccugcg\n", + "ggucucacucuauccaauaggcuggaaugcaguagcaugaucaccacuuacugacgcuuugaccucccagucucaagcaauccucccacuucagccuuucgaguagcugagacuacag\n", + "agucuugcuuugucaccaggcuggaaugcaguggcgcaaucuuggcucacuacaaccuccaccucccgguuucaagcgauucuugugccucagccuccugaguagcupauuacag\n", + "gcauaaccupuccugguuuacaggacagacaaguacaagagacugaaggcagaaguggaaaaacagaguaaaaaau\n", + "pcugucagaguuggucuguuacucggugguggcggagucuacggaagccguuuucgcuucacuuuuccuggcuguagagcgcuuucccccuggcpugagagugcagagacgaag\n", + "agaguuggucuguuacucggugguggcggagucuacggaagccguuuucgcuucacuuuuccuggcuguagagcgcuuucccccuggcpugagagugcagagacgaaggugcgag\n", + "cuuuuggaagagcaaugaaugaaaacagaggugaapaccgugaaggagapugauggacaaacuccaaggcaaacugcugucaacuuccuaag\n", + "acaugccacaaaauguugaaugaagauaggcagcguuggcaaggagaguuucugaaacuuccacuggapcucugcguguuccggcaggaaug\n", + "guauucugaccuuuucagcuagcagaggaugaggaggacaaggugguggugucauupcaugucaaccaagagcaag\n", + "aggaggcgcuguggacgacucpccgaupcpugcgccugcgcauagaccccagcugcccacagcuucccuacacugugcaucgg\n", + "augccuuagcugapagcagapuugcugagcccugugccugccaggugcaagaaggaggaag\n", + "ggcgguccgguggagccpccucucupcugcuguggcucucccppacuccgugacauguucucugagguucuggcucucuccupcaagcucacagauugcagccaccccccaggcacc\n", + "uaguugccgccuccccugccccaugcccacccccacugcucacucaaggcuagccucucucagupugacugagcugucuucaguggaagcccgaggcag\n", + "acccccacugcucacucaaggcuagccucucucagupugacugagcugucuucaguggaagcccgaggcag\n", + "cgcgcgccuccucpcuccacgcgucuugccccgcagaggcagccuccuccaggagcpcccugcacacc\n", + "gucccagauggagcaacagupcucgucccucagcugcaccguggcagcaccaucucccagagccuggcccagaggugccccuupagaga\n", + "aacuacacuucugcuccccacugucuggaggcucugcaagaacucuacaaccacauccacagguacuaugaucag\n", + "ggccaaggcuauaaauucgcaggccgcggccpccccacaggagcagccgcccpcaccggagcugcpcugcguggccp\n", + "gaaaauccuguugcgaauaagaaggauuccacagaucacauaccggagagguuuugccucagcugcucucaacuuuguaaucuugugaagaagcugacaagcuugg\n", + "aaaugaaccggagaagaaucccaauupaauugcggaaaacaggacucuapuagagaaagguuguagaaccaauapuuugag\n", + "cuuccugguccuucuccaccuuucccuuuccuccagucuggacuuugccuucuccaccuccuuggaagacaggcugcucaucccauuguggugucucggcugguguauguuuucugccuagg\n", + "auggaguuucgcucuucuugcccaggcuagagugcaauggcacggucucagcucacugcaaccuccgccucccpuucaagugauucucuugucucagccucccaa\n", + "uagcucaaaauguucuaaagauaaaaucuaaugauuucuuauaggaaggcuaggcuuggupuacaaguaagaaagccaagcagagagaag\n", + "cuuaauggacagcacgaggagguapacugacguuacccauguuuuacaguggaagaaccugaggcuuaaagag\n", + "gacgagucccggauuuaccapccggupauccccucpcucccgccuuagcaugcuggccpacaucuggugaac\n", + "pacggcgaggcaggcgcucagagccccgcagccuggcccgugaccccgcagagacgcugaggaccgcgacg\n", + "cggcgapuccugccgapaccccguucugcgcccaggcaggcucgaagcacgcgucccucucuccucgcagucc\n", + "gcuccagcagccguuaagccccpacggcgaggcaggcgcucagagccccgcagccuggcccgugaccccgcagagacgcugaggaccgcgacg\n", + "cccugcccuggccaaggaggaggcugaaagagccugagcugugcccucuccauuccacugcuguggcag\n", + "guucuagaagauuucugaggacucagcaguaacuugcagugcuggacugaggcuauuuccuuauaucaacuuuuugaaaacuc\n", + "agaacuucuuaugugcggcggcgugauguupcggccacagagagauugguguuuuugugaggcagugagaccuaag\n", + "pacccugugccgcggcggaguccaagauggcggcgugcgguuccgcugugugaaacgagcgcpcggcpuuacucagcuccgcggagacgaccuccgacgacccgcaaca\n", + "acccugugccgcggcggaguccaagauggcggcgugcgguuccgcugugugaaacgagcgcpcggcpuuacucagcuccgcggagacgaccuccgacgacccgcaaca\n", + "ggcgccuuccuggagcgcpagauguaaagauagacaaauaauuuucccaaugagacuguagaagagagagcaauuggcca\n", + "ccgcugugugaaacgagcgcpcggcpuuacucagcuccgcggagacgaccuccgacgacccgcaaca\n", + "uacuuaggaagccuguggugagaacaacaacagugccugagaaucccacggcucupaagugagccccgagg\n", + "gacuauguggcagccugcaagucccagugcggcgcugauuugugucuaaauuagcuuuccggaggacuauuucaaauuacuaaagagauaggaggcauuguuuauu\n", + "gcacaacgucgaaagcagccaaupaguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "paguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "paguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "aucuaaagcuuaaggacuauggaguggaucuuauugaaguuucagacaauggaugupuagaagaagaaaacuucgaaggcuuaa\n", + "cucugaaacaucacacaucuaagauucaagaguuugccgaccuaacucagguugaaacuuuuggcuuucppaagcucugagcucacuuugugcacugag\n", + "aguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "gaguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "ggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "apuggagcacaacgucgaaagcagccaaupaguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "ppaacauggccgaggcgcguggcgaggcagcccccuggaggccccggaguggcgaccucaguguugcagcgaucucgugccccuupugcgccuugaggccgag\n", + "ggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "ggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "ggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "gupagcccuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "gagcacaacgucgaaagcagccaaupaguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "cuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "pagcccuggapaacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "paacuuucccaguccccgaggcggaucpuguugcauccauggagcgagcugagagcucgag\n", + "cgaugucaccauuucuaccugccacgcaucggcgaagguuggaacucgacugauguuugaucaca\n", + "ggagcacaacgucgaaagcagccaaupaguucaggaggcggagcgccugupagcccuggapaacuuucccaguccccgaggcggaucpuguugcaucc\n", + "apcpcgucpccagcugagcuaucccgucagaccgcgccaguuugaaugaaagcucuacaag\n", + "aucccgucagaccgcgccaguuugaaugaaagcucuacaagauggcggcggucpccgaggcgcgaggaggugaggcuggagcgcggcccccucgccuucccuguucccag\n", + "aguggcggcgcggucapcuggccuuggcuucagcugcgguuuupucccggacucupaucggcggcgcu\n", + "ggaaguggcggcgcggucapcuggccuuggcuucagcugcgguuuupucccggacucupaucggcggcgcu\n", + "gcggcuucccggaaguggcggcgcggucapcuggccuuggcuucagcugcgguuuupucccggacucupaucggcggcgcu\n", + "cuugaagguuuaucuauacuguucaccugugacuaaggaguuguuguuaacgagcccgaaauacagauuuuggaagaaacgaauu\n", + "augaggaaacugaggaaccagagagguuaaauuaguugcccagugucacacagccaguaaguggcaggaccaggauuccagccag\n", + "gcggucapcuggccuuggcuucagcugcgguuuupucccggacucupaucggcggcgcu\n", + "uggcggcgcggucapcuggccuuggcuucagcugcgguuuupucccggacucupaucggcggcgcu\n", + "ugcuggucucccgcuuuggcucugaagcacaugcaccugccccaggacucggaggagcugcacacpcacccagcagaagcugauguugcugcggcccugccccagacucugaguuaagccagaag\n", + "ggcuucccggaaguggcggcgcggucapcuggccuuggcuucagcugcgguuuupucccggacucupaucggcggcgcu\n", + "guuaaacggcaucuuccuuggauggucucaggaucacagccuucucuaaagaaguauuccucuccaaagagcugcaggccuucaacagccuuauuag\n", + "guccggaggcpcccccpcgacucpcggaccgcpcggagcugccgcccgugaguccggccgagccaccugagcccgagccgcpacaccgucgcuccugcucuccga\n", + "cuccpuccccapcugcgccpccggccuggcaapacgagucaguggacacuccaggaagagcggccccgcppcgaugaccgugcgcugacccugacucacuccag\n", + "gcucugaagagcggccauuccucagauucgaagcugaacacaucuccaacuacacagcccuucugcugagcap\n", + "aacauguacugaugcugcagcugagcugcugcccagccccupagaagacaccagcagcaugcccagccapcapuggagagcugcagcugcag\n", + "gccgucagcacccgagcugcaggcggcgagcgccauugugagcagagccggcpcaggaggcccpcgccupuccccgcggcgcpcggagcggccggccagccag\n", + "gcccagacccucagcgucgacgcugcgcacaagcgcagucaacugcuggacccggccggugugaaguuucacacccaaaaggaugaapcacccaccuggcuuaagagaacgacucccag\n", + "cugcuggacccggccggugugaaguuucacacccaaaaggaugaapcacccaccuggcuuaagagaacgacucccag\n", + "ugaguuuccugucacuggaagugcacuucucgguacccuuacuuguagaaguucucacagaugcugcuucuccucuggcucagauc\n", + "aagcgcagucaacugcuggacccggccggugugaaguuucacacccaaaaggaugaapcacccaccuggcuuaagagaacgacucccagguaaapccagacccag\n", + "gucccuucagagaagauccucagagcuggaaaaauuuuacgaaaugccauucucucucgagcaccucac\n", + "guugcuuugcggcguuuuccgcpaaacuguguaaapupaaacuugaaaguuggaugcugcagacccg\n", + "gaggcgcugcuugccgccgcuguugccuccgcugcupcgccpcagcuccccpuaucugcggccgcc\n", + "gcggacucagaagcgagcggcaccccpaccaucccacagcagauccaguggccgccaacgucaggcug\n", + "gcuccugaapcauggacucuagcuuauuacagacauacccuggcaucuagcacaauaccuggcacauaauag\n", + "ccuccauuuagaaapagcaugagaagcacugaaaaguaaggcacugugaucuacacggaaaccauauauupcucacagcuacugaaugagaccgacugguggagacaguuuagugaaccug\n", + "pagccagcuguugucaucauucaggagcuaucagccuauuucuacauacuuuauaucuguuuuggauuauuuggauuccaguuguaag\n", + "cacuacgccccaucgguguucgagaaguacacggccagcgugaccguuggcagcaaggaggugacccugaaccucuacgacacggccg\n", + "ggcaagaagacuaugaccggcugcggccccuguccuaccagaacacccaccucgugcucaucugcuaugacguc\n", + "ggcgauugcccggcagapcgucagacguccacccugcagcccapucpugcpuaagcggagcccagucccucaccccgaacccgcgugcacgcuggcgucccuggcccaggcgag\n", + "guucupccggagaapcgacguucpcaccccccgaauggacaaucuuuccuucugucaacggcapcaggccuaguuugacucugacaguccucccacuaag\n", + "gucucgcpagcgcugcuggcggucpcgcucpcggcccuggccpagacgaguugcauguguugguucagcuggcgauagcggcpagcggagccggcpccugugcgaccgccugg\n", + "accaguucgcgcucuccuccggcagaaguagcagcugcgcucuugcucucupagaaccuggcguu\n", + "ggcgcuuccggucggcggagccugguggccgcagcggcgguggcgacgacggccgagacgup\n", + "auuupccacauagaucugguuuuggccauugacuggcaacauggcaguagccaacugcagagccaccapagcagccucauucugauugaguauaacgaagacgcug\n", + "gauguggaguapccgagcgcggaacgcgapcugcupuguuugucgcagcpuuuuccucggcgguuugcggagcugcuagg\n", + "gcagcgccccgcccgcccgcggcuccccagccccaggccpagguaggaaggcgccggcpagucpauccugcuuup\n", + "aaagcucccggcaacuuucucccucgcagcgccccgcccgcccgcggcuccccagccccaggccpag\n", + "gucggaaugaacugaucgcccgcuacaucaagcugagaacpaagacccgaacucgaaaacag\n", + "ugauggcapcgccccugucccccagcuugugguucugupucucuccuggucucggccucagcugcugcccugagucucugucccugcccuuucuag\n", + "cgcccgcccgcggcuccccagccccaggccpagguaggaaggcgccggcpagucpauccugcuuupugu\n", + "cccacuuuucccaaacaaagcucccggcaacuuucucccucgcagcgccccgcccgcccgcggcuccccagccccaggccpag\n", + "aagugcuacgcggaggauuagagcaggcggugcgcupcpagcagcgcggagcccggcucggccacaccgaucgcccgccgcc\n", + "gcuacgcggaggauuagagcaggcggugcgcupcpagcagcgcggagcccggcucggccacaccgaucgcccgccgcc\n", + "ggauuagagcaggcggugcgcupcpagcagcgcggagcccggcucggccacaccgaucgcccgccgcc\n", + "uuuuccuaauuggauggagcugupcgugagcaccagcgucagaucpcccucaggcuaccag\n", + "ccuucuuugcuuugguggcuuccuugugguuccucaguggugccugcaaccccugguucaccuccuuccagguucuggcuccuuccagcc\n", + "uuuucugcccuucuuugcuuugguggcuuccuugugguuccucaguggugccugcaaccccugguucaccuccuuccagguucuggcuccuuccagcc\n", + "guuccuccgacuuccggacaucucccupagucgcgcagaguggagucaaaggcaaccagugcucgcugcggucucupaucpaccgcggcggcggcccgcgagcp\n", + "acuuucauuacgugcacgccccapccacgucccugccgcugucuugguccugaagccuguucugccccagcccccugcccgcupccc\n", + "agcuugucaggaagaucggaggugccaaguagcagagaaagcaucccccagcucugacapagacagcac\n", + "ggucuuccugcucuguuucccaggcuggagugcaaugguaccaucauagcucacugcagccuuaaacuuccpcucaagugauccuccugccucggccucccaaugcauupauuacag\n", + "ccuuuauuaagcuccuacuguaugccagguacuuupcugcagguacagcugugaaaaaaaacag\n", + "uuaccauccucaaaggauuggcuaaaagcaagcaacuggauugaacacccuaagaagaaagauucacacugcaccag\n", + "cucuucuuuugcuucuaguuaccauccucaaaggauuggcuaaaagcaagcaacuggauugaacacccuaagaagaaagauucacacugcaccag\n", + "agaauuguuaagagagagagcucauaugaaauugguuaucgupauauuuaaaauaaaacaaagaacaguuuacuuu\n", + "augaguaucucagaguccucaacgupuguggccgaggugaagaaauccuuccupcccuuguccccguccuguaag\n", + "agcugcggcgcgugacgcpcgcgcggcuccgucggcuaccgcpcpcgcaggcgacpcacggcpcgagcpcggu\n", + "ggacagcuuaaugaagacaaacugaapaaacugagauccuuagaaaaccagcuauacaccuguacccag\n", + "cagccuuauugagguacaauucaugugcuugupuuuggauggcacaaucugugucupcuaaggaaagcagacuuggcaccaacauuaacccugacag\n", + "cucaggauuuggcacacagaagcucaauguguauuuguugaauugcaucaaauuuacagaaauacuccccuupa\n", + "ggccgcuggccuagaaauggccucaaauggaagcugccacccgauccugguggaggcuuugagcuaggcuagagaucaggacuccapuucagugcgcacgugcugccccugcacuag\n", + "gagucuaguccucaacucuaaccaaaguaaaggaaacuggaaagacacacgcuuuuucagucauuaauagaaaguuguccag\n", + "aaacccggcgagugaaucuacccagagcugaagcuuccuuugcaacuupaacaccapccacagugacuuuguggcuuggcuuuagauaaauuugacc\n", + "aaugcucacccugacucauucapaaggauccaagguuuuugaugcapcacugacucucugccuguuuuuccccuucaucaucugcuccccuuaaaaaaugguaucaacugcauug\n", + "gcuccugccauacgccagacaguuuuguagacacgaaggauccagagauuagcaacaccuuuaccauuuuuggugacaguuaagcacccaucuaagaaguuuucuuug\n", + "gagccuaaaggacgucauacccaupccagaccuaacauuccuuucugcugaucccaaguuuuuagacaaaguuucccuuccuuaaccaauugcgaaucagaaaauccucgaauccaccaaugaccu\n", + "gcaguucccggucucgccuucacugcuguguguccucagccucuguggcccuguaaccugcggcauuggaagauccacagcuaac\n", + "gacucugcacuuguccaagagaagaauccagagaaaucagagcaggucaaauaguucuaaaagcc\n", + "aaccuuugaaguuaggacagauucuggcccuggacaggagugaccucagccuucugagugacacuggauuuaggcagaugccugguguucugugaccacacuucccuauaug\n", + "auguaugccauucacaggacuucggacucagcaacugccagccucacagucaaupaagugauguucugcagaaaagcaguagauggucggaag\n", + "ggacuggugacauucapacguggccauagaguucucucuggaagaauggaagugccuggaaccugcucagapacuuguacapaggugacucuggagaacuuuggucacuuggccucacuag\n", + "cggacaguguucgucccauccggagaggaucgcuuucuccuggcgucaccagcgcupuuggupuagcuuuucccucuuugcuccuccauucuugaagaaagaagaag\n", + "puggucggugugcuugugacccugccuuuguguggcugucaccggupacuggcpagcugugu\n", + "cupccgaaucupcugupuggucggugugcuugugacccugccuuuguguggcugucaccggupacuggcpagcugugu\n", + "ucacagcggaguggaaucucuccaucuuguaagauuacuuuuaacacguuggcauccugaggugguugugaauuauucugaagacuguug\n", + "caaacuuuuaagaacugugagcagaggccaguaauuuuggagacaggaccucggccugaaagugauagaugucuuuguuguuacugagugupccagguguaag\n", + "gagugugugucupccgaaucupcugupuggucggugugcuugugacccugccuuuguguggcugucaccggupacuggcpagcugugu\n", + "uugcaguauccaguuuauupaccaucucgaguucugugauggauucagaaaacuuuuagaccauuuacaauuggauaaa\n", + "cgcupcggaagcuaccauggcggccgagcgaaagacaagguuguccaagaaucuacugcgcaugaag\n", + "ucaucauauupacagaugaaggagaugacccagacacccaguccuuaaggucuccagaaaagauagaugcucagaaaguucagaugug\n", + "ggcgcupcggaagcuaccauggcggccgagcgaaagacaagguuguccaagaaucuacugcgcaugaaggugcpacgcugagagcgccacuccpcg\n", + "gacaaugugcaaaugacaccguuuugugcucaccapcaaagcaapagcgcccucacuucagcaucucagcccugcuaaagaaaaagcugcugg\n", + "gucggugccaggucccaaagacgcagcugcgcpugugccpaggagccccggaauccacaggcugcgag\n", + "uuagucggugccaggucccaaagacgcagcugcgcpugugccpaggagccccggaauccacaggcugcgag\n", + "cuucuccagauuucaagaaucuggcucagugauaugaaauacaagacuugugaaaagugucaauugcaagagaaauggaaggauaaaguauacag\n", + "agaucuguuugguucaguugcugagaagccugacauaccaggacugccugagacaagccacaagcug\n", + "cacaaugacaugcagaccugcauauuggagcuggacggagaaacupcuaaugugacagacagcaacaagaguaaggcaguugcuucgcuauugagagaaagaaccauauga\n", + "gcucugcgagapaccccuaccagcuguaccagcgucuggaacagcaagcucgagaguaugugcuggag\n", + "cuggacggagaaacupcuaaugugacagacagcaacaagaguaaggcaguugcuucgcuauugagagaaagaaccauauga\n", + "agagcuuccpcugcgcucuucguugcccaguuuccgcucaguggucgcgucuccgccccccacccaccagucccgcugcauucucggccpcucuaggcgcc\n", + "auugagcugcgacccuuguucaacgccguuggcgaagccagcugcuggaggugccgagaaucugaguuucggcaagcagccag\n", + "guaacaggacauucaguuaguaaugaugguugcagguugaauagucucgcccuagaucucaccuaacuugcag\n", + "uaaguaucaagugcuugugugccgauuaaagaacaacuucggauacaaupaggugucaaggaaacg\n", + "cauugagcugcgacccuuguucaacgccguuggcgaagccagcugcuggaggugccgagaaucugaguuucggcaagcagccaggucuggaaacu\n", + "guucaacgccguuggcgaagccagcugcuggaggugccgagaaucugaguuucggcaagcagccaggucuggaaacu\n", + "gccguuggcgaagccagcugcuggaggugccgagaaucugaguuucggcaagcagccaggucuggaaacu\n", + "cccauuguaacgccggagupacgcugcuuugcgucugaaaggugcaaauugaaacucgaaagcccgcaaauuaacpugucucucuccugaugaagag\n", + "gaggcagaaaagugccccugccucggcgcuuucgguuuuggcupaucauccgcggcggccpcucgupcgccuggagugapuucugguucccgccggcgag\n", + "cccugccucggcgcuuucgguuuuggcupaucauccgcggcggccpcucgupcgccuggagugapuucugguucccgccggcgag\n", + "gcgcuuucgguuuuggcupaucauccgcggcggccpcucgupcgccuggagugapuucugguucccgccggcgag\n", + "acgucggcccugccucccggaccacccugcpcgcaccagcgaucupugcpcucggccucccugcgcuccuggcugaccgugugaccuugg\n", + "gcacgucggcccugccucccggaccacccugcpcgcaccagcgaucupugcpcucggccucccugcgcuccuggcugaccgugugaccuugg\n", + "gaccgagacgugcagcuguccaaggcucuguccuaugcccugcgccaupccuugaagcupcuuccc\n", + "ggucuuaaccaugaacuucucuggaggapaggcaggaagcagcapuccapuagaapcucccagaccccgagaacag\n", + "acaaaugagguguaugcugacuaacagccaccccugguguggaugugauuggcaguuccgagagaaauaupacgucuucacgguacaccupaccgaggcccgugguc\n", + "gagaaugauccaucugugagacugaaaauugcaucauuguupuuuauuaucaaagacagcaggauuuucaccagacugcauu\n", + "gcaaguuuuccggauccguccacccccgccucccuccuaguguacggaagcugagapcccgcpuaggc\n", + "ggcuccpcupupaucggcuggcugccccggccccucaccuccaucuuucuacccccapucgcggcgagcgcgccuaugacaucuacucgcggcugcugcpagcgcaucgugugcguc\n", + "agcauauaaacagaguccgcguaagaaaacuacacugaauaggaauggcagcuuuuaaaagupaacuacaguauagg\n", + "aucagcuuaucaacagacuuccaccaccaccaccagcauauaaacagaguccgcguaagaaaacuacacugaauaggaauggcagcuuuuaaaagupaacuacaguauagg\n", + "agucccagcuggaucuccggccagagcccgaggcugcugcgccpcggcugcagccuccgcuccagcgcccgcgccgugcccugcaucccpagcccggcuggacccgcggcggcucggccg\n", + "agcuggaucuccggccagagcccgaggcugcugcgccpcggcugcagccuccgcuccagcgcccgcgccgugcccugcaucccpagcccggcuggacccgcggcggcucggccg\n", + "augagaauucugaagcacaaagagguuaacugcuuugcaccucgcuggccucagucuccccaucugaggacgg\n", + "agagcccgaggcugcugcgccpcggcugcagccuccgcuccagcgcccgcgccgugcccugcaucccpagcccggcuggacccgcggcggcucggccg\n", + "cggcucccpugugguggucgcaccagcucucugcucucccagcgcagcgccgccgcccggccccuccagcuucccg\n", + "cuguaggcpagucaucaaggcapcagaggcaggaccagauggccguuugaggugcugagcaaagcucccgguuugcgcggagag\n", + "cuccgccgccggcucccpugugguggucgcaccagcucucugcucucccagcgcagcgccgccgcccggccccuccagcuucccg\n", + "cuacacagaggaucagagcapupccugcupcugcagcupauucugagcauccuuucccggaggcacggaaagugagugagugagcccagugag\n", + "agaapagguggccggucuccgucgugaccucugacgguuucugagcguuggccuuuggcacgcgcuacccccuuuugcuuugguucugcc\n", + "cuccgucgugaccucugacgguuucugagcguuggccuuuggcacgcgcuacccccuuuugcuuugguucugcc\n", + "acgcccgcagcapucagaapagguggccggucuccgucgugaccucugacgguuucugagcguuggccuuuggcacgcgcuacccccuuuugcuuugguucugccaugccgauguaccag\n", + "gaagagucuaaccugucucugcaagcucuugagucccgccaagaugauauuuuaaaacgucuguaugaguugaaagcugcaguugauggccucuccaag\n", + "gacauccuuugccauucaaccucugauuugcacaaggugacuaaaggaccagcagcaaacaaaagcaaag\n", + "ucaggucccucagcugcaggucuguuggaguuugcuggagguccauuccagaccuuguuuaccupuaucaccagcggaggcugcagaaccgcaa\n", + "uugucugaaccacgcacaggacauccuuugccauucaaccucugauuugcacaaggugacuaaaggaccagcagcaaacaaaagcaaag\n", + "gccccggaggcpcacuuppaaaguugagacgugauuaccpuupcpccccaucupapuuugupugaacucpuccaccgcccgcugaggag\n", + "auuaccpuupcpccccaucupapuuugupugaacucpuccaccgcccgcugaggag\n", + "ggaapccccggaggcpcacuuppaaaguugagacgugauuaccpuupcpccccaucupapuuugupugaacucpuccaccgcccgcugaggag\n", + "augupauggupupuacagagagcupapaggcaccccppcpcgupagacuguauucpcgcgagcugccccag\n", + "pccgcugcagccgagcagaacgcugagccgcuccgccccacggccuccucuccagccggcgcgcccgccucccgcag\n", + "gcagccgagcagaacgcugagccgcuccgccccacggccuccucuccagccggcgcgcccgccucccgcag\n", + "gcugcagccgagcagaacgcugagccgcuccgccccacggccuccucuccagccggcgcgcccgccucccgcag\n", + "aggugagccguggcucagguccggagcgcggucpacacagcgccucuaggagaaagccuggaaggcgcuccp\n", + "ccuguucccguccuugaggacgccgugccpucaguguuagccuccagcccugguuguggaaggcgacagaaguc\n", + "cucuuccuguucccguccuugaggacgccgugccpucaguguuagccuccagcccugguuguggaaggcgacagaaguc\n", + "guacaauccugagaaccuggccacccuggagcgcuauguagagacgcaggccaaggaaaaugccuaugaucuggaagccaaccuggcuguccugaagcu\n", + "guaccaguucaacccagccuucuuucagaccacggucaccgcccagauccugcugaaggcccucaccaacuugccgcacacagacuucacccugugcaagugc\n", + "guucccguccuugaggacgccgugccpucaguguuagccuccagcccugguuguggaaggcgacagaaguc\n", + "accucuuccuguucccguccuugaggacgccgugccpucaguguuagccuccagcccugguuguggaaggcgacagaaguc\n", + "pccgcccgcagapcgcaugccuuccupugaggacgcugccaggcucccagcucuggagucaccgccccgugcuapcaagag\n", + "gucaccaaauaucuauugagugcuugcucugugaucuggcagacaacucaaaggcacagagaugaagaugaaacacaccauggagccapaapccuggaugcugupaaacacuacaacag\n", + "cccccaaggacupaucaauauuggaaaccugugcuuuaguucuuccaccucugcugcugcuaugcugugugaccucag\n", + "agaugcuucupucgcggugugcuaagcgaggaguccgagugugugagcuugagagccgcgcgcuagagcgacccggcgap\n", + "augcuucupucgcggugugcuaagcgaggaguccgagugugugagcuugagagccgcgcgcuagagcgacccggcgap\n", + "gucgcggugugcuaagcgaggaguccgagugugugagcuugagagccgcgcgcuagagcgacccggcgap\n", + "agcagguguuugcugaagacagcuuacucagaucacuacugccuggaggugguugauauauccugguguaaaccuucaagaapcacaggcaggaaaac\n", + "aguuucuccuuuguuuuacguuupaggagguggcauuggaaauagcagagugcuucgcgguaacap\n", + "acaaauguacugaggcuggagccugugugaacagaacagaagaggccuucacucuaguagugcucacaguccagcag\n", + "guguuugcugaagacagcuuacucagaucacuacugccuggaggugguugauauauccugguguaaaccuucaagaapcacaggcaggaaaac\n", + "accauacagacacacgccacuuugcuggagcauucacuaggcgaggcgcuccaucggacucacuagcugcacuc\n", + "gauugauuccuaaagacucauguuaugugaagaagcagcucagaagaggaaaggaaaggagccaggcauggcucuuccucag\n", + "gccagaagacggccagaggcacaaagaagccagcgcgcuggcagagucaapaupcapcugccpccagcapaccagcugaaggcugcgcapugcpccacacag\n", + "uggaaaaaguaugucggcaagucagcugguuucccagugcaggacgcgcugacagcucgagugagcggacugcccaggacuucggaacuagacgag\n", + "gguguggaaaaaguaugucggcaagucagcugguuucccagugcaggacgcgcugacagcucgagugagcggacugcccaggacuucggaacuagacgag\n", + "gugacuguaaucaaugagagacugaagacagaucaacauacaucuuacccaugcucuuucaaagacugugcugagagagaacuuguggcaguuauauguccuuauugugagaagaauuuuugccugag\n", + "cccuuacggcgccggagagauggcggaguuggacaucpcagcacugccagguggagcauugccggcagcgag\n", + "ggcuacugccacuuuaguggacuapcucggugccagcacuucccpuaaucaggcguggucugaccgaggaucaagaagcacaucaucaccaaugacauc\n", + "guuugguccuuguuuuucaagguggcupaugagcccuupcgccucaggugccuguaucacccacuccucccuaccaaagapcaucuuccuacag\n", + "ggauggugacagaauggauaguauagaaaauggauuggaauugaggaggaaacuagaagcuaagaggaguuaggaggcccuuguaacaauccag\n", + "gaagaugagagacugcuuaggcgccaccacuaguaccaugagucccugcacugguuaaagccaucgccacaaccuggacaggcagcaag\n", + "guguguaugagaaaaugacauaaaguuucagaccccguugugcuuugcuccagacccagacaacucuuggucggauggugaggag\n", + "agucccuguaccccucuucucccacugagaaugguacugagaaccaacccaaguuuggauccaaaagcacuuuagaagaaaaugccuaugaagauauugugg\n", + "gagaucugcccaaggagaauccauaugaggauguggacuuaaagagccgaagagcaggacgaaaaucccagcaacugucugagaacuccuuggacucuuugcacagg\n", + "agugcucugcucacuuggcugcgaggagcgccacgaaaggucagaggaaggagcugupaagcucgcagcag\n", + "uaauauccagugcguccucccuggcacuccgauucucaguagucaugaaccagcuggcuucuauaucucucaccaaucacag\n", + "acauaauauccagugcguccucccuggcacuccgauucucaguagucaugaaccagcuggcuucuauaucucucaccaaucacag\n", + "uuucaggaagaugagagacugcuuaggcgccaccacuaguaccaugagucccugcacugguuaaagccaucgccacaaccuggacaggcagcaag\n", + "ccuuucacagaaaaccacuggaggagauacucacaaaaaugaapaagaacaggaaacaggaagacaugagaugaaggaaacaggagauucaacaugg\n", + "gaugccugcccgccgcccgcccucucugcaggagcggcuccuccuccpccgcgcggcucccggcgagaccccauccaggcgccgcgcccggcccggcupaacgcagag\n", + "aguugucagaggcapcuggacucaaggcagguguuuuuccacugccccucpccugcgacugugccuguuugucugg\n", + "gugaacaacacaaaacccugcccuaaaagacuuguugaacggcaucguaggugagaapccuggcgaagcccugcucccuacgguucugugaguuccucc\n", + "agcccpcgcggaugccugcccgccgcccgcccucucugcaggagcggcuccuccuccpccgcgcggcucccggcgagaccccauccaggcgccgcgcccggcccggcupaacgcagag\n", + "auaaagacagguapcugaapuggagguapucuccagcugcaguugucaagaacccaacgugaaggcugacugagcagagaaacugcugcugcccagaaagaaagcacuuuuagcagug\n", + "gugcgcgcccggucccgccccugcccucccagcccuuuucccucugcucccgacucccggccccggcagcgguguccagcucc\n", + "acauaauauccagugcguccucccuggcacuccgauucucaguagucaugaaccagcuggcuucuauaucucucaccaaucacagguaauuuaggucucccucag\n", + "gucacauaauauccagugcguccucccuggcacuccgauucucaguagucaugaaccagcuggcuucuauaucucucaccaaucacagguaauuuaggucucccucag\n", + "uuugcuccacgaggugccuauggapapaacacgauucuggaggcugcupauupupuuccupaggcaguccuuuugcaagagcugcuaagagcgcugg\n", + "cupugcpaaaaggcgcagucucggupauugcgugcaggapucguggucuggcuguggcggaggagcauaagaag\n", + "acucugcgguggagcuguggaagccaggcgcacaggaugcaagcagccaggcccapaggcagcagcugcauccucagagaggaagccagg\n", + "ggaaaaggcgcagucucggupauugcgugcaggapucguggucuggcuguggcggaggagcauaagaag\n", + "ggaggaucagguggagaapagcugaggccagaaaggagcccaguucuagaagaguauaaucupuccuuccugcaggacagugccuugguaaugaccapcuccaggaagag\n", + "gacuccagauucaauuauuuauauauacuucaggauuuaaacuuugcuuccagaguugucauggaggaggccaagaagcaaauaga\n", + "acgauucuggaggcugcupauupupuuccupaggcaguccuuuugcaagagcugcuaagagcgcugg\n", + "cpaaaaggcgcagucucggupauugcgugcaggapucguggucuggcuguggcggaggagcauaagaag\n", + "gacugacaggcggcgcacccapcuccucucuccccagagcgacapcccggagagccgupccucacc\n", + "cacacgcgcacaccggaccccgcgcgcacacgcacggapcgcgagcgagcagacgcgcacaccggcgagccaaguuccgcagccuggc\n", + "gagcagccagaccuggapcuupuaaaaauggcugaauauuuagcuucgauauucpacugagaaggacaa\n", + "cccugcccucugagcucaggccccgccccuuuuaaauucugugcagaccauagugcugcucaaccuguaccggaauccacagaacacagcccaaacugcagacggaucacacu\n", + "ggaucacaacucugccacugccaucagcaggaacaacccagcuuucaccuuccacugcuugccaucccaaag\n", + "guuguaaaauuaaagcacugagagccaagacaaacacguauaucaagacuccuguucguggugaagagcccauuuuuguugucacuggaaggaaagaagauguugcc\n", + "gaaacaggaggaagccagcucugugccuggapacucgccgccaucucaggucucuuggcuuugccapcccaccggagaaaacugacgacccguuucuguaauccuu\n", + "gcgaaacaggaggaagccagcucugugccuggapacucgccgccaucucaggucucuuggcuuugccapcccaccggagaaaacugacgacccguuucuguaauccuu\n", + "cucauugccuauggaucauccucucccagcuuuugcaagcaccpcugcucgcccgcugauuuuccuccuccauaggcucacugcggaggcaacggcgag\n", + "uugcaagcaccpcugcucgcccgcugauuuuccuccuccauaggcucacugcggaggcaacggcgag\n", + "gccgccgccgccgccgcucucggugaggcucgcgcucgagcugcggcgccggcuccugccgccupccccpcccggccccucccgcgccgcccpcg\n", + "gcucgagcugcggcgccggcuccugccgccupccccpcccggccccucccgcgccgcccpcg\n", + "guggcugguuauagcgguuggucugguccgagcauaccuggcuaapuagcuaccauagccuuuauuauucaauugaaaagccuuugaaauucuuucaaacuggagccuuauuggag\n", + "agcuuacucacauagcauauugguauaucaaaaugaaaugcaaggaaccaaaaauaacauaauugaaggcaguaaaagugaaauuaaauaggaagaucaucagucaaggaagacccacuggaga\n", + "ggacagaaaaugaagcaguguuuuaucauguguauuucagcaggucuucuugaaauuuaacuaaaaau\n", + "cucpcggucaccupcacpcgcugcaggugucpccucaaccuugcggagccgacagccaucgauccucgg\n", + "agagcuuacucacauagcauauugguauaucaaaaugaaaugcaaggaaccaaaaauaacauaauugaaggcaguaaaagugaaauuaaauaggaagaucaucagucaaggaagacccacuggaga\n", + "gcuucccagguggcuuccccucuuccccupcugauuuccacugagcagccaaccgcagccucuggccacaaggagagcggagcacag\n", + "guupcpcggcgguccgagcggcugcggcagcggaagcpuccpucgcgcapcpcggcgcagcpcggaggcggccgug\n", + "caggaugaucaucuuauuggcauuuaugguugaccccugcggaagcauuacauuggaggaaacacaauaacugaaaaaccaa\n", + "ggucucacucugccucucaggcuguagugcaguagcaugaucucaucucacugcaaccuccaccuuucaggcucaagcaauccuccuaccucaaccugccaaguagcupacuuaag\n", + "ccauuccacagauuuugaaguacaccgaaacuggcuugcuaucacucacaguuugccaauaucacagugguauuaugag\n", + "gcaacuucagaguggacguuggauuaccccccuuucuuugcaugguuugaguauauccugucacauguugccaaauauuuugaucaagaa\n", + "gccgcagcaauggcggcgcucacaauugccacpuacuggcaauugguuuucggcuuuggcgcucpugacucuucucaaaugccuucucauccccacaua\n", + "paagcgugcggugccgcagcaauggcggcgcucacaauugccacpuacuggcaauugguuuucggcuuuggcgcucpugacucuucucaaaugccuucucauccccacaua\n", + "gaucuccugaccucgugauccgccugccucagccucccaaagugcuggaauuacaggugugagccaccgcgcccggccccacuuugcacauucuuaca\n", + "ggupaagcgugcggugccgcagcaauggcggcgcucacaauugccacpuacuggcaauugguuuucggcuuuggcgcucpugacucuucucaaaugccuucucauccccacaua\n", + "agapcuuucuccgcaugcgcpaucccggauguggaucaaguuggupaagcgugcggugccgcagca\n", + "gcggugccgcagcaauggcggcgcucacaauugccacpuacuggcaauugguuuucggcuuuggcgcucpugacucuucucaaaugccuucucauccccacaua\n", + "aaguuggupaagcgugcggugccgcagcaauggcggcgcucacaauugccacpuacuggcaauugguuuucggcuuuggcgcucp\n", + "ggaagcgugcggugccgcagcaauggcggcgcucacaauugccacpuacuggcaauugguuuucggcuuuggcgcucpugacucuucucaaaugccuucucauccccacaua\n", + "ccagcuuaccaaaaccugaggcagaaaguggauaauuuugugucaacacaucuggacaagcaggaauggaauccuacg\n", + "ugaugccuaaagcuguggaccgcgupcucgccucccupacuagguuucagcggccgcugcg\n", + "aagugaugccuaaagcuguggaccgcgupcucgccucccupacuagguuucagcggccgcugcg\n", + "augaccuggaagugaugccuaaagcuguggaccgcgupcucgccucccupacuagguuucagcggccgcugcg\n", + "gcauucgcgcgcuggagaccggcggccucucaccgagccugagucguggccgcugcgccgccaggaggcuucccpagccggcpcccaggaccucucgagcgcagcag\n", + "agaaaagaagaaaugcucaucugaaauucaucaccucucuggagucuucaaacugaccaagcauugaaaag\n", + "aacacaguuucagaaaacaguuuccagugccucuggccuuccuacugaaagcagacacagagugcaugaagaccguucaaau\n", + "auuuuguuuucuucauaacauuucccugucugaaauuauuuuauucaugugguaucauuuaagugcuuauuaucucucucacccugcucccaucaccacuggaguaaaagcu\n", + "agcucugcauaaccaggcucucapaagcaguggaggcagccuucuuggacaacagcucacuugucuacacagucaaaa\n", + "gaaaauaucugugcccagugupcuuccaacauacagcuaaggauguagccacucccuggaggccauggaaaapaucuacuuucagcccuuuauuaaaagcauuucaaaaa\n", + "gauggagugcaauggcguggucuuggcucacugcaaccuccaccuccuagguucaagcgauuguccugccucagccuccugaguagcupauuacaggugcccgccaccacgccucg\n", + "ccccucuugcuuuaucuccucauuucugugugcaggcgagcuucuuggccuaapcaggaagag\n", + "agccucagccuugccucucccccucuugcuuuaucuccucauuucugugugcaggcgagcuucuuggccuaapcaggaagag\n", + "gcccauagaaugcccapcgacaaacuguccugagccccucuggugcagccaccugccugucccauacgccccgcccacc\n", + "cccaggcucugcucucuppuppcgcuccaagccpagccgugccagccgagucgugcpcuguggcapaapccacc\n", + "ggagcgcggcpcpccpcggcpcpcuggcpcggccpccaugcapcgcagagccggcuaaacccugcugagacccggcuccgugcguccapcggcua\n", + "accgcucaaacggccacaacgapagccgauuuagauccucupccuguuccuuccuuuucuuuaaacgucccagucuagcuuagaggaggaccuguuuugu\n", + "gaggcagcugaagaacagagucuugugaugguggaaccaggacuucguuguuccuucauugugupcagaagagguggaggauuuuaggcgccaccuggucuuguccccacugcccag\n", + "aaacgucccagucuagcuuagaggaggaccuguuuuguguaaggcuugccggagcaaccagcaccuuuccuggaauacagucuuguuuguggcuuuuccuuuguu\n", + "agucucgucgcgagaagcagcggcccpcgacugagcggacaaacggaaguguagguuacggucugagacaucaccgccaagcupcaucpag\n", + "gacagaggcgcgcccaccgcggccgcgcguggcgucugccgaggccccguuucuggaagcgucucuggccgaggcucccggccaccuugacccccpcgcucg\n", + "gagaagcagcggcccpcgacugagcggacaaacggaaguguagguuacggucugagacaucaccgccaagcupcaucpag\n", + "cpupaggupuccpugugcgccgcggcgcuggcugcgaaggcaguggccgaggcpcucccucupccgugcccggccuggcuaacaaagccgccgcggccucuguugugug\n", + "aguuccggucgcagaggagacaccgccgcaguugccgguacaucpauuucuggcucuuuccucuucgccuuaaauucg\n", + "agaaagaaaagguaucaguacagaaaagaagagucagaaaauaccgugcaaaggcacauucagaacguaaccaggauagcuggagccaggauucaaggagagag\n", + "acgcuugcgcgcpauuuaaacugcggcgguuuacgcggcguuaagacuucguapuuagcgaaauugagguuucuugguauugcgcguuucucuuccuugcugacucuccga\n", + "aaacugcggcgguuuacgcggcguuaagacuucguapuuagcgaaauugagguuucuugguauugcgcguuucucuuccuugcugacucuccga\n", + "acagaugugcugaggcuguagaaagugcuuuuuauuugguupagcuugugcauaaaugcgagapcugcacaucugacggacuagaggugacuc\n", + "auucuucacugaaccuccugcuccagccucugccuccuccauuuugaugucuagaaucapauccaggaucaucaccaaggucauuuucccag\n", + "cucccgcgcccugcaccucggcaggucucgcucucggcacccucccggcgcccgcguucuccuggcccugcccggcaucccg\n", + "cuggacaccuguucugcuguuguguccugccauucuccugaagaacagaggcacacuguaaaacccaacacuuccccuugcauucuauaag\n", + "agaupuuucaccauguugcccaagguugucucaaaucacupcucaaguagugcucucaccucggcuuccuaaaguguugguuuuacag\n", + "agucucacucuuguugcccaggccgcaguacaauggcgugaucucagcucacugcaaccucugccucccpuucacaugauucuccugccucagccucccgaguagcupauuacag\n", + "gcuuuguauguggcaaauuuugcaaagguucaagaaaaaacccagauccucaaugaagaauggaagaagcuucguguccaaccuguucaguca\n", + "ggucucacugugucauccagagcuggagugcagcggcacagucauggcucacuggaacucaggcucaagcaauccucccgccucagccuuccaaguaacuaggacuacag\n", + "aggccugguggagcppcccggccpugcgccccgccgcccagugagcgcccpcggcgcggcccpccgagccagccacgcugaggcggaggaggacpacaag\n", + "gaugcacaaauggaauucupcccggcugcaggcuccugaapcuccuugcuucacuuugacugg\n", + "ccuuagagccuguucupcucucugcaggcgucugcgguugcuguguccuuggcccaaggauaccuggaaucuuucugugcccuuggaugaaagagcugcuugcuuguupuccaaagagag\n", + "ggcagccupaguuggacguggcucaggcagupuagaaapcagccagccacagcccgag\n", + "agugaucgcagaggcagccupaguuggacguggcucaggcagupuagaaapcagccagccacagcccgag\n", + "auuccugucucccagugaucgcagaggcagccupaguuggacguggcucaggcagupuagaaapcagccagccacagcccgag\n", + "auaaauaggauuuaccaauccuuggaugaagugcuupaagucuuuaagugccauaaucaacugccauuucaaagaauauagaugguuuugaaaaguucaugcugucccuucauugaauuuuag\n", + "aaugauugaagauagupaaaagaggaaauaccauggcagaaagaagacagcuguuugcagagauga\n", + "ugauuauuuacagauauugagacucuccugauugcugagccaaacuuagcaccaauaaaaguacauccucaucupagcaaaggcagauuuagcauucag\n", + "aaccugaggaacuuguccuugaauaggacagaccuguucaagucuuaaaguuauauuuauauucuaauaaaaauaaaauuap\n", + "pcucaagaucuggaucgcauccgacucuccaccuacagaacagcaugcaagcuuagguuuguucagaagaaaugcaauu\n", + "aaaucaccugcuaagaagcugacuaaugcauuaagcaagucccugagcugugcuuccagccgugaaccuuugcacccc\n", + "guucupauacauaugcagaacgugcaaguuugcuacacaggcauacagguaccauggugcuuugcugcacccaucaacccgucaucuacauuag\n", + "cuccaggcucaaaccucccugcagaccaauggacaccuucuaagaguuuggcgagucagugacugaagcgcccguccauuccaag\n", + "ggcacuuccaacauuauuaaauaauaagaaagcggcuccuacuccaggcucaaaccucccugcagaccaauggacaccuucuaagaguuuggcgagucagugacugaagcgcccguccauuccaag\n", + "agaupuuucacuguguuagccaggauggucucgaucuccugaccucgugaucugcccaccucggccucccaaagugcupauuacaggugugagccaccguguccggccag\n", + "auugaaguuaaagguuacuuuggaguuuguuuggaaauguguaaggucaaauacuauaguuuucagcauauguaguacuucagaggaagaauuaapcauguuggugcauuuaacuacaaaaccag\n", + "guggcagguugcugcucucuccuucagaaccccgcucugaggaaagcuaaggaagagaacaggacgucugagugugugacugag\n", + "gaugcaguucaguggcaugaucucggcucacugcaaccuccaccucccaggcucaagcaauucucaugccucagccuuccgaguaccupacuacag\n", + "gacaacgguucucaaaaugaagacacuuucaugagauucuugagguuaaaacuauuuuaauaacaacucuaucauauuauuugccuuuuucacuaupacagucacacagaugugcaaaaguaaug\n", + "ggacugcggcgcggcgccuccccpcggcpcggcgccucaggcccgcpcggcgguagcggcugcugcaggauguccggcccpcgcpccgcgcag\n", + "ugcugacacugagcagcaggaggcagcuuguucggaaacucuuuuccgagcauugagcaaacuuccagacucagaaucagcacugaaaaaggauuucuucc\n", + "gcgccgcagccaggacugcggcgcggcgccuccccpcggcpcggcgccucaggcccgcpcggcgguagcggcugcugcaggauguccggcccpcgcpccgcgcag\n", + "gaguccucpcugauguucagcuuccaaguguuuccguaauauccgucaaugaaagcaucuccuuuuacccacguagagacag\n", + "acuaugugcuuccggucuccaauaccgcaggapcggucuuccccggcucgccaacucggcugcucupauucgugcgcgguaagaagcugcgcgguagcgcggugag\n", + "cucuuuucucuccugcccguguucuucccgccgccugaccuggcccgcccgccuuuccagucuggccpcpccugaagcacggcggcucpccgupaccg\n", + "agucuggccpcpccugaagcacggcggcucpccgupaccggugagugucaacccgaaccuauaucugaagcccuucagacgcggaapcuupaggccaguuugccccgcagcg\n", + "ugucgagauggcuaugaacccuguguaaauaaaggaauguguguuaccuaccacaguggcacaggauacugcaa\n", + "ggagccuupaggaccccgaaucacugauggaauupcagugcauggagauggcucagcaggaugagg\n", + "aaaaugacgaagaugaggaugaagauguucaaguugaggaggaugagaaaguacuggaaucaucugcccccag\n", + "pcgccaucuugucuuguucccgaagaaguagaagcaucgaaagcguuggagagguguuaccggaacggcggcgacaapuguucccgaacuagagugg\n", + "ggcauacauaaucuugcugcuaugcuucgaagcuguagucugaaucaaccuaaguuuuaaacagaaggugaaccucugag\n", + "pugagacaaaucpcgccaucuugucuuguucccgaagaaguagaagcaucgaaagcguuggagagguguuaccggaacggcggcgacaapuguucccgaacuagagugg\n", + "aucuugucuuguucccgaagaaguagaagcaucgaaagcguuggagagguguuaccggaacggcggcgacaapuguucccgaacuagagugg\n", + "ccpugagacaaaucpcgccaucuugucuuguucccgaagaaguagaagcaucgaaagcguuggagagguguuaccggaacggcggcgacaapuguucccgaacuagagugg\n", + "gaagaaguagaagcaucgaaagcguuggagagguguuaccggaacggcggcgacaapuguucccgaacuagagugg\n", + "auagaaaaucaaguauauuuuaaaagaapaugupaucaaggaggacagccuuggcagcaguggcccuugaaccagcaacaauggaugcagucauuccagcaccaacaggauccaa\n", + "cauacaggaaaggaucaaucuagaaggauucauuuaguaaacauuuauuaaaugccugcuaugaacuaagccuupauacaaaaauaaagaagaaaccaugcccugguuau\n", + "auuaaacuuuaaupuaacuaguagacaguaacacucupapcucaaaccacauaaccaaaugugccaagauaauccugagcucacuauugucag\n", + "uccugaagauuuuccucagauaaucuuucaucucuuuguuccugagacuauauauuagaggauuacagagugguguuaucacagaaaagaacaag\n", + "uggauuuuuaucugagaucuacaacuuaugaagaauacaaaugauguauauucuuuucuacucuucauguauggacuagapcuugcacaguag\n", + "uaagaaaaaaauggcugagacccacaggaacaaagaaacaggacaggaguuagaugcagagaagagauuucaacaaaaguuuggaaaag\n", + "uugcaggcugcupcupcuaapcugcucaguuuccuucagcpcacupaagcgcc\n", + "cucuucccuuagguguuuaaguuccgcgcgcaggccaggcugcaaccugacggccagaucccucgcuguccuagucgcugcuccuuggaguc\n", + "gacucgcuuuccgugcggugcggcgagugaggccccggucuuccuccucguccugccgcapccagaaccccugacgguauucagcugcgcguaagucuggccggugccaucugucuccgca\n", + "ucgcuuuccgugcggugcggcgagugaggccccggucuuccuccucguccugccgcapccagaaccccugacgguauucagcugcgcguaagucuggccggugccaucugucuccgca\n", + "ggaaguuggucucgacaccuggacuagccpuuguauuuggaaacgcggagugaguuuuuccgugcuguguag\n", + "auguaccagcgccggaaguuggucucgacaccuggacuagccpuuguauuuggaaacgcggagugaguuuuuccgugcuguguag\n", + "agacggaccgapccggaagugacgccagcuggcccgcuugaggcguapuggcgcucuccguucggcggcgcuccc\n", + "uuugcuuuuaguucucauugugagaucacaaguggaggcuccaaccaguccagaaguuccuuucuaupaagcuguggcagcaaggccgugaagagagucugacuuaauugcaa\n", + "guuucupauaaguaugugcaaauaaaaaauaaacaugagaaggaacuguaaccugauuauggauuupaaaaagauaaaucaacacacaaapaaaaguaaacugauugacagcccucagga\n", + "cuagaaagcggaaaaagagcaaaacagccaacuaccuuaucuccauugauccaguugauuuaucucgugaaggagaaaguuaugucggcaagcuuag\n", + "caacggacccuaccucuuguagugauucucpccacpcaccggcaaauccacgcuggcguugcagcuaggccagcggcucggcggugagaucgucagcgcugacuccaugcag\n", + "gaccuggucccauuguccccccugucuauggcuuagagguaucugaugucucgaagupaagagucuguucuugaaccugcucuugaaaucgugcaaaguuucauccag\n", + "auugaagauauauuugcccgagacaaaauuccuauuguugupaggaaccaauuauuacauugaaucucugcucuggaaaguucuugucaauaccaag\n", + "uucuagaugagcgcuuggauaagapuggaugacaugcuugcugcupcucuuggaggaacuaagagauuuucacagacgcuauaaucagaaga\n", + "ucccagcccggcgacugcucpcccggccgccaccugcacggcpagccgcucgccgcpagcgucag\n", + "cucccagcccggcgacugcucpcccggccgccaccugcacggcpagccgcucgccgcpagcgucag\n", + "gcaaucuccagccaaagucaccgcpcggacuauggcuuapcgccagapuuagagguacpaagaggaaaagacggcuaacupaaaaaaagagaaaacgaaagaaaagccaaacg\n", + "gagucugugcgaagguccguggacagacugcuuugccuguuguugcucuucggaggcggcgauccccgaaggcgagcugaaauacggcugcaggcuacaauuugcagccgaccauu\n", + "uuugccuguuguugcucuucggaggcggcgauccccgaaggcgagcugaaauacggcugcaggcuacaauuugcagccgaccauu\n", + "gcgcugagagucugugcgaagguccguggacagacugcuuugccuguuguugcucuucggaggcggcgauccccgaaggcgagcugaaauacggcugcaggcuacaauuugcagccgaccauu\n", + "aguuuucauuuguggugagauucucucccaggccacaagacauuuccugcucggaaccuuguuuacuaauu\n", + "pucccagagcupcuggcpaggcguaauccggcpugapuugaucgaagagccccgcgcgcagcugccgcucacagccccuucccgagugcagagcpcagagaag\n", + "auuuacuucugucuguaucaggaaacagaggccupucuagagacapucuuggugapaaggacucaaaaccaupauacagcaugaccpcagcaccacagcuguggaag\n", + "gaguuucccugcacaaguucucuucuguugucugccuccaugugagacaugccuuucaccuucugccaugauugugaggcuuccccagccacauggaacu\n", + "gaccaggaccapugaggcaaacaaggucccuacpcacagaauuuaagaaggcacucacucuugaugaaacuggaggaccaaaau\n", + "acaaagcagauaaggauuccuaggcuaggagcuaccucguccucuggcuccagccaagcguccuauccggagccaacuguagcupauccagcgagaggaag\n", + "gaguggacggcucgagacggcggcgcgugcagcagcuccagaaagcagcgaguuggcagagcapcugcauuuccagcaggagcugcgagcacagugcuggcucacaacaag\n", + "gugcccgcucpcugcugcggcupcuugcuuccuuauacccaccucuccuccucupucugcgugugu\n", + "acacauauucuccacgccauggaggccacugcuugaggaupaggaguaguauaagcaguucaauacugucuuuuuuaccaucuucagugcuucuuggugauaugaaguaaaaccag\n", + "gcuaaugcauguuuuccapucgcuccuggcuucguaccccuuauuugacacugacaugcccccccaccccccguugugucuccucucccag\n", + "cucgagacggcggcgcgugcagcagcuccagaaagcagcgaguuggcagagcapcugcauuuccagcaggagcugcgagcacagugcuggcucacaacaag\n", + "aacaccucagaggcapapcpccggcapaccugcugcuggaagagcagcggcccgagccpcc\n", + "uuguacagguagccaggugucggucuccagccugagaacucuggcuguuguuccuugugucgucccauauuccugccuggccugcg\n", + "acuaugcgcugcupccgaaagacacgugguucgguuuuaacuccagucugcaagaaacaugaccucagccaaaaagaggccgcuggucugagaagagaaaucaugagucauggauucp\n", + "gcugucagcuupccgcagccgcgcgaggaggcgcpagcaggaaggagcugupcupagccgcuguccuccccgccaccaccggugccpcaccag\n", + "agucugcaagaaacaugaccucagccaaaaagaggccgcuggucugagaagagaaaucaugagucauggauucpuucggaccuuggagcaggcg\n", + "agucacgugcugugacaguagcupugaggccgucgucgccgcacpcugguupcugugucugupaggcgccpug\n", + "ccuuuugauagagcagaaaaauucaaucgaggcaucagaaaacuuggaguaacaccugapacagagcuaccuugaucaauucaggcaacucaucagccagauug\n", + "gacauguuggcucuapauggagcagugaagaagacaaaggcuguacucauggaucuugaacucuaggupaagaugcagacagaaaaauacaua\n", + "ggaggcgccpugauggcgguggagacucuguccccggacupaguuugaccgcguugacgacggcucgcaga\n", + "gucuuaaacaaagucaucacuguuuaugcugcacuuuguugugaaaucaagaaauuaaaauaugag\n", + "aguagcupugaggccgucgucgccgcacpcugguupcugugucugupaggcgccpug\n", + "acaaccaggcggcagcggauacaaggccaggcggcggcpcpcggaccugcgcccugagccuuucugcgcccgcpcacc\n", + "aucuggcccaggaggcacaaccaggcggcagcggauacaaggccaggcggcggcpcpcggaccugcgcccugagccuuucugcgcccgcpcacc\n", + "acaaapcccgcgcgcagccgccgccgccgccgccgcgcgaggagccaggaugguccugguccacgucggcuaucucgugcuuccaguguuuggcucugugcgaaacagag\n", + "ggaucucaguguggaugcuggcuugaguccugcucaguuccaggugcggcccaucccucagcacuaucagcauuaccuagccacuccucga\n", + "aggugcuucggcugccacggcagcagguucucugcucucuuuucucugcuggaacupcccuagagacupcaggcgguagguagcucaggag\n", + "uuuuuccagauggcucaggugcuucggcugccacggcagcagguucucugcucucuuuucucugcuggaacupcccuagagacupcaggcg\n", + "gcugaaaguguucaucugucagaugucagaggaggaauuacaacuucauuuuacuuaugaagaaaaaucuccuggcaauuaca\n", + "acacauccaggaacaguacuuugcaucuuucaauccgaucaaguugacacucgauauuaaccaucacaguaucucag\n", + "cagauggcucaggugcuucggcugccacggcagcagguucucugcucucuuuucucugcuggaacupcccuagagacupcaggcgguagguagcucaggag\n", + "uugaaaacaauccucgaacaggaaaucuuggugcacuaauuaaggucuuccuuucuagaaccaaagaacuaaaacuuucagcaga\n", + "uguuacuguguuuuuuuucuguuuuagaaaguguaacacguuuaaaggauauccacaauuucuuucaaaaauaugg\n", + "gucucuaugucuggagcucuuagagauaagacauagaggugucugguucugagaaaaggaaguuuugcuaagugagagacacaacugacucaacugacucag\n", + "agacauccagucccugacuccaccugccuccaggugcccagaacagcccaucgupacuucacccucagcaaguggacgccguuuguccugccapcag\n", + "gcauccuugccpccagcccgaacagcagcupucggcaagcgacaggagcacpucaucuuuuccccagaggcgucgga\n", + "agucaaggugacgcauccuugccpccagcccgaacagcagcupucggcaagcgacaggagcacpucaucuuuuccccagaggcgucgga\n", + "auaguggucgcuuaacuccagcgccuucccagugccucccaaaccucuccuccuccugcccpcuguucuaggaggagccuaaauguccgcuuccccagcugaapauugug\n", + "ccacucggccgcagccggcgcuguccuccgccccccggagccgccgcgccagacccucgcccagac\n", + "gcacugaugaagauauuuucucuggagucuccuucuuucuaacccggcucucccgaugugaaccgagccgucguccgcccgccgccgccgccgccgccgccgccgcccgccccgcagcccacc\n", + "agcucggacccgcgcccccgcccccgccccgcgcaggacagccccpauccccgcccgcgcgccgcgucccacguaccccgccgcgccpcaagaag\n", + "agaagaaaccaguguguguguaguauguguuuuuugcaupcaguugguaaaaacaccgcgucccuuaucuguauggcuucagagca\n", + "gcgcggcccuagucggcuccucaacguggagcgaupaggccuugagaagaagaaggugauupaaagacg\n", + "uaugaacgaggcucggccaccaacuacaucacccggaacaaagcccggaagaagcuccagcugagcuuggcugacuuuag\n", + "guguucguccggaagcuccggaaggcuuaupaagagcgaguggaacacuguagagcguuuaaaggacaauaagcccaacuacaaacucgaccacaucaucaaggaacg\n", + "gaaggcagccuggaggagguggccauggaggauagccuucguuaucgucagccucuggugagaagcagcagcauccuuccagagagucacuucugauccccaag\n", + "guccuuggcapcacgugcpaggaaguggagcucccuguacgcgcggcccuagucggcuccucaacguggagcg\n", + "ggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "ggaaguggucacggaacucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "guuguuuuuucgugcucgcuagucgccgccgccgcuccgccaupaagcgacagcaccaaaaggacaaaau\n", + "ggaaguaccacugcccagugcuguuuaccguguucaccaacaacacccacaucguggcugugaggacgaccggcaacgucuacgccuaugag\n", + "gcaguggaacagcuaaauaucaaggccaagaacuuccpaccugcugaccgacgagcccuucucccggcaggacaucaucacccuccag\n", + "gcggaacccggaaguggucacggaacucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "aguggucacggaacucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "gcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "ggaacucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "gaacucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "aacucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "cucggcugcggcuccauggucugaguugucagccguuguuuuuucgugcucgcuagucgccgccgccgcuccgcc\n", + "pcaccuccucccacugcpcaaapcaggcaguucgugcgcggacacaagcacuggcggaccguggcc\n", + "ucuggcauugcaagccucgcuucguugccacuucccagcucuucccgccuuccgcgguauaaucaacacuacgagagauagagccgccuagaaccag\n", + "gucuccagaaaugcuuupuucaucuuucauugcugcaaggaacuuccaugccucuaacacucaucuucaaaagacug\n", + "cauuuugucccagucaguccggaggcugcggcugcagaaguaccgccugcggaguaacugcaaag\n", + "aaaugcuuupuucaucuuucauugcugcaaggaacuuccaugccucuaacacucaucuucaaaagacug\n", + "accuucuuugcggcucggccauuuugucccagucaguccggaggcugcggcugcagaaguaccgccugcggaguaacugcaaag\n", + "auugcaagccucgcuucguugccacuucccagcucuucccgccuuccgcgguauaaucaacacuacgagagauagagccgccuagaaccag\n", + "auguugaagauggcagagccaauugcaucccugaugaucguggagugccpccugccugagaugcucaccucucuuccuuuaccagagagagaaa\n", + "ucucuucuccucuccuugccuggccuccugaauccuaucuuagccuccuuagcccccugacugacucucucucgcuucuuccaagccucuguagcugguuccgcuccupuucuggcc\n", + "gccgcugcucccgucucuuugguuacgcucgucagccggucggccgccgccuccagccgugugccgcu\n", + "cggccaucggucacuaaucugcagcacuggaauguccgcpccaaucagcpucucupcuccccaapugcuaauaaucccacaaugauuagcapccgcgg\n", + "cccagccugacuccuggagauugugaauagcuccauccagccugagaaacaagccpuggcugagccaggcugugcacggagcgccugacpcccaacagaccc\n", + "agaaagaaaagguguaguguuupaggucaacpcuaugcuggcuugacapcupcucuucagaacag\n", + "aaaagguguaguguuupaggucaacpcuaugcuggcuugacapcupcucuucagaacag\n", + "aucgccpapcgguugaggcggugguggcggcgucggcggcggccpcgcuggcugapcgcugaggcpagcuguggcggcgcupcgccccuggcuccucggccucugccggcc\n", + "gcgupcugacgccucgcucaauuucucacapcugcgcagguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpa\n", + "ccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpaaugagccucuuugaucucuuccpcuuuuucggcuuuccuggaccucggag\n", + "aacuuccagguccugagucagagacaccuggugagagacuacpapacagacacuucpacuca\n", + "cgcucaauuucucacapcugcgcagguuucccccgucugcgaauggaccacuggapuucaaag\n", + "gcuuuccgguagcgupcugacgccucgcucaauuucucacapcugcgcagguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpa\n", + "auccpugccauccagagucaaacccucgaaaucgcuuuucguacugaguuggucugcagaaagaagaacagauuuaggaggaaggcggucauaggaaacugaaa\n", + "ggcugcgcagguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpa\n", + "upcugacgccucgcucaauuucucacapcugcgcagguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpa\n", + "gacgccucgcucaauuucucacapcugcgcagguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpa\n", + "gguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpaaugagccucuuugaucucuuccpcuuuuucggcuuuccuggaccucggag\n", + "cuucccagaccccuugcucuugucccacuuugccacccaugaguugauuuaauggcuuaaauagugcugaaauauugguggccaaucugccuccacucucagccacagagaucccuuuuuuggap\n", + "guucgcgucccaguacpaaugagccucuuugaucucuuccpcuuuuucggcuuuccuggaccucggag\n", + "aagucgcaacauugaacacucaccccgccacaguaaccaaggcggucauuaagaggagaaacagcaaacuaagccuuucuccaaccup\n", + "pcugacgccucgcucaauuucucacapcugcgcagguuucccccgucugcgaauggaccacuggapuucaaagguucgcgucccaguacpa\n", + "acacuuacuugcaccagugcccagagapugcaggcugaggagcugcccagagcaccgcucacacucccagaguaccugaagucggcauuuca\n", + "gaupuaacapcgupcuggcacacuuacuugcaccagugcccagagapugcaggcugaggagcugcccagagcaccgcucacacucccagaguaccugaagucggcauuuca\n", + "guugaggaggapagcgcuugapacuggccuggcgugcacuccgcaccucpacauuauugcgcguggaacggcugcuuuuggaag\n", + "auucugaugcucacaguaccaccucaagugccuccccagcucaaucuccuuguuacaguaaccagucagaugacggcucagauacagag\n", + "auugcaugagacucguucaggagacaucugcaaugccuguguccugcuugugaaaagauggaagaaguugccagcaggaucaaaaaaaaacuggaaucau\n", + "gugguagaugcaapcuggacccagucuaaagacuacauugaaaccaaagaaagugaaaacucuaucupaacaggauaaaaagcaaccagaucaguaaacugcagaaggaauuuaaacgucaua\n", + "agaacugcaggagacuaucuuucuagacaaggcaguugaggaggapagcgcuugapacuggccuggcgugcacuccgcaccucpacauuauugcgcguggaacggcugcuuuuggaag\n", + "agaauucuuaguuguuuucuuuagaagaacauuucuapaauaauacaagaagauuuaggaaucauugaaguuauaaaucuuugga\n", + "gaauucuuaguuguuuucuuuagaagaacauuucuapaauaauacaagaagauuuaggaaucauugaaguuauaaaucuuugga\n", + "cuuacuaaagacgcpaggaaguucuccagcgagcagcuuuccccaacguggaaaggaccacgcaaggacaccugagcuuuccaacagauguucagcgccapauccacag\n", + "gaggaappagcgcpcaggaggaguaccucggccaagaaaauuaugcaugcguuapaagcucugagaga\n", + "agaauauuuaggcgaaagcgagaggaappagcgcpcaggaggaguaccucggccaagaaaauuaugcaugcguuapaagcucugagaga\n", + "aaagcggccauguuuuacauauuucuugauuuuguuuguuuucucgugagcuuaggccgcugguuuuggugauuuuugucugauugca\n", + "gcuggagugcaauggcgcgaucucagcucacugcagccuccgccucccpuucaagcgauucuucugccucagccucccga\n", + "cugaauuccaggcuggagugcaauggcgcgaucucagcucacugcagccuccgccucccpuucaagcgauucuucugccucagccucccga\n", + "cagauuaugagcuuacagaaagccuggccuacauuuuacucuuuuuggauuucuuccucaucaagagacugcugcagugccugucau\n", + "agacggaauuuugcucugaauuccaggcuggagugcaauggcgcgaucucagcucacugcagccuccgccucccpuucaagcgauucuucugccucagccucccga\n", + "auuaugagcuuacagaaagccuggccuacauuuuacucuuuuuggauuucuuccucaucaagagacugcugcagugccugucau\n", + "ggaaguapcupaauccpacugupcaaguugacggcucccapucgucpcugagccgagapug\n", + "gcuggagugcaauggcgcgaucucagcucacugcagccuccgccucccpuucaagcgauucuucugccucagccucccgaguag\n", + "agugcguuacuuaccucgacucuuagcuugucpacgguaaccpacccggugucugcuccugucgccuucgccuccuaaucccuagccacu\n", + "cuagugcguuacuuaccucgacucuuagcuugucpacgguaaccpacccggugucugcuccugucgccuucgccuccuaaucccuagccacuaug\n", + "agugcguuacuuaccucgacucuuagcuugucpacgguaaccpacccggugucugcuccugucgccuucgccuccuaaucccuagccacuaug\n", + "gaccaaugaaggaauuauuggcaugcacuaaaggagauagcaagaupucagacacacauaugagagucauuggcaacacccpuaauguaag\n", + "acucaacacacauacacccupcugagcugcucuugcuggcugcagccgupccucugcucaccgugccgcugcugcugccugcgaa\n", + "ccucgccucccucucccccaacacuguccccucuccccaaccccucacagccugcgcgcgcgcggagacaccucag\n", + "ucuacaupaggacagagaagcgcaaagaacaagagaaaagaugcauccaucugagaucuaaaaggagacaaugag\n", + "uaggaccaaugaaggaauuauuggcaugcacuaaaggagauagcaagaupucagacacacauaugagagucauuggcaacacccpuaauguaag\n", + "ggaccaaugaaggaauuauuggcaugcacuaaaggagauagcaagaupucagacacacauaugagagucauuggcaacacccpuaauguaag\n", + "ggccugcpaggcugcccggaggaggcagcggcggcggcagcgcguccucgguccccaggaccacggcuucuuuccugccag\n", + "ggccuugcggccugcpaggcugcccggaggaggcagcggcggcggcagcgcguccucgguccccaggaccacggcuucuuuccugccag\n", + "gaggcugcccggaggaggcagcggcggcggcagcgcguccucgguccccaggaccacggcuucuuuccugccag\n", + "pagccgcugcuggucccggccuugcggccugcpaggcugcccggaggaggcagcggcggcggcagcgcguccucgguccccaggaccacggcuucuuuccugccag\n", + "gagccgcugcuggucccggccuugcggccugcpaggcugcccggaggaggcagcggcggcggcagcgcguccucgguccccaggaccacggcuucuuuccugccag\n", + "ucgcccgccccauuugauauaupccugaaauguaugccaucccaucaccaucggacuggacuguucacagcacuggagagacagagguccuucauucacuccag\n", + "gcuggucccggccuugcggccugcpaggcugcccggaggaggcagcggcggcggcagcgcguccucgguccccaggaccacggcuucuuuccugccag\n", + "gucgcpaagguugugauaagucccugauagccucccgugcccuuuuuugacaggucuucacugauuc\n", + "gcpaccacuuccggccuagagapapcagucuccgaguuucggapcuuggagugaguggacgcacucpaauuguaggaggacgag\n", + "agcagcpaagucguggcgagauuaaguaaugagaacuupcccaguuuuuuuuccaagccuagaapcagaauauguucguauccuuucugaccucccaggcauaugcaaug\n", + "uuuuccagauuuaggagacuucagaaaggupcagauagaauggagauggcaaagaucucuuupcauauaupccuggcgaaguaauggaauaauuucuaauuuucggagaaggcaagug\n", + "agugaagguggcuacgagguaguuucucuuucucccuuaccuuuauuguugcuuguguuggaaggcgacuguucagag\n", + "uuuuccagauuuaggagacuucagaaaggupcagauagaauggagauggcaaagaucucuuupcauauaupccuggcgaaguaauggaauaauuucuaauuuucggagaag\n", + "agcgcaugaguuccgcuaccccgccccacccccgcuccacuuugcagaaaccpauugaauggapaapaaggag\n", + "aacuupcccaguuuuuuuuccaagccuagaapcagaauauguucguauccuuucugaccucccaggcauaugcaaug\n", + "uucagaaaaaggaaaauaaagcaacgcacgagccggcupccaggaccuupcupcuggagugaagguggcuacgag\n", + "uuuuuuuuccaagccuagaapcagaauauguucguauccuuucugaccucccaggcauaugcaaug\n", + "cguguaucuaggcagaucgcggcuguuacaaccauucagaaaaaggaaaauaaagcaacgcacgagccggcupccaggaccuupcupcuggagugaagguggcuacgag\n", + "uuuuccagauuuaggagacuucagaaaggupcagauagaauggagauggcaaagaucucuuupcauauaupccuggcgaaguaauggaauaauuucuaauuuucggagaaggcaa\n", + "auucagaaaaaggaaaauaaagcaacgcacgagccggcupccaggaccuupcupcuggagugaagguggcuacgag\n", + "aagcgcaggcggccaauggaacccpagcggucgcugcugcugaggcggcagugucggcaguccaaccgcgacugcccgcacccccuccgcpucccccagag\n", + "gacucaccagcgcucuaagucagaugccacugccagcauaagucucagcagcaaccugaaacgaacagccagcaacccuaaaguggagaaugaggaugag\n", + "aaucucggaaaggcgagaaagaagcugucuccaucuugucuguauccgcugcucuugugacguuguggag\n", + "ggaaccagcpaaacugaggcucpuggagcgcaggauugupacgcgccaaggcugcugucuuucccagcagcagcggaag\n", + "cucgcgagaggacccgucagccccagucaggcgucgugcgaacagcagcugguaccgaaggcggagguggagcccgagag\n", + "aacpuagguucucgcgagaggacccgucagccccagucaggcgucgugcgaacagcagcugguaccgaaggcggagguggagcccgagag\n", + "aagccuuuucuucccucuaggccagaggaccccaccuggagcccuaguagccaapaagaguuaagaaggaggaaaguaag\n", + "agaacucacacuucuuccuggcaaagaagugcccaggacpagcupagccapcugaucuaggaggcupagccaggugacagg\n", + "gcuggagacuccgcpagcgcggccpaggcuucgccccggagcuggcccgacgccucccgagcuggcapcucucggcggaggucggagcgupcuuccuccucccgccag\n", + "pugcgagcuggagacuccgcpagcgcggccpaggcuucgccccggagcuggcccgacgccucccgagcuggcapcucucggcggaggucggagcgupcuuccuccucccgccag\n", + "uaagcccgcpcapcgapcpcgucpacauuaccggacaggccuuguccggcaauaccaag\n", + "uuucaugcaggcucuupaaagcuggugcugcugcugccugauucccgccgacagaccuupaccpccaacacuggcagcuggag\n", + "paggaggaaggagccpccgcuucgaucuguguggccuggauapcapcaaapaacugacccgcuucgcucccpccuccuccuuuupcauguugauccgcggcugcgcucc\n", + "gcucuupaaagcuggugcugcugcugccugauucccgccgacagaccuupaccpccaacacuggcagcuggag\n", + "pagagcggcuccgcggccaccgaugcccggacccccucugucuucugcuagacaugcucuuccucucg\n", + "agacggacuccggcggaauppuguggcugcuccgccapuccccapupagagcggcuccgcggccaccgaugcccggacccccucugucuucugcuagacaugcucuuccucucg\n", + "ggccuggauapcapcaaapaacugacccgcuucgcucccpccuccuccuuuupcauguugauccgcggcugcgcucc\n", + "agacggacuccggcggaauppuguggcugcuccgccapuccccapupagagcggcuccgcggccaccgaugcccggacccccucugucuucugcuagac\n", + "ggaacugacccgcuucgcucccpccuccuccuuuupcauguugauccgcggcugcgcucc\n", + "cggaauppuguggcugcuccgccapuccccapupagagcggcuccgcggccaccgaugcccggacccccucugucuucugcuagacaugcucuuccucucg\n", + "cuagacgcgcggcgcauucagguucuccuggaccguagugguagucgcuggcccgaguuagaggccagcugagaagucuucgugcuucag\n", + "gacgcgcggcgcauucagguucuccuggaccguagugguagucgcuggcccgaguuagaggccagcugagaagucuucgugcuucag\n", + "guuuccggaggcgguggccaaagupcpcuaggccggagcugcuggupaggcagccacuugagaucaccaggccuccuguagaccggcpugcapcccggucccagaguuaagg\n", + "agccacuugagaucaccaggccuccuguagaccggcpugcapcccggucccagaguuaagg\n", + "gcggccgcacuaguaccccggagcccaupcgcgccgagccpcgcpcgcugaacggcggagcpagcggccggaggagcc\n", + "gcggagugcaggcgccggauucccuucugucgcgcggccuuauaguuccggcuguggcgcgcggacggaaaguuuaugccgacggaaaguuuaugccgacggacuguguccggcgaupcacp\n", + "aaucgcguggugacuccpcuugagguugaauuaagaauagucagguggugaguggaacgucucuupugucggaauucaaaacggaccuggagg\n", + "aagcgcacguugaaucgcguggugacuccpcuugagguugaauuaagaauagucagguggugaguggaacgucucuupugucggaauucaaaacggaccuggagg\n", + "ucgacgguguccuaugccugcuuuccuugcpcggaggaacuacaauucccagcgugacccggaggcagcccpcagaapcgguugcugcagcuuuggccgagguucpcucgaacuuggaaa\n", + "aauucccagcgugacccggaggcagcccpcagaapcgguugcugcagcuuuggccgagguucpcucgaacuuggaaa\n", + "aggcaacagcccggaagccgcuggcupuuaaccuguggcgcgcuccgcgguuccggcgccugaaguuuuagcugcgguggcggcggcagucpaccgacugcaag\n", + "acacacaccgcccaagcccggacgguggccgcgaagcuapccaccauggcggaccgcaggcggcggcuccggccpacguuggccccggugcgcgapcgugaacugcagguccag\n", + "cucuuaucaaaggugcuggaagugcuugauccugaccggaagcuggaggacacaupcuuauugucaggacaccaggaaagga\n", + "aagcuapccaccauggcggaccgcaggcggcggcuccggccpacguuggccccggugcgcgapcgugaacugcagguccag\n", + "aaaggaagaccguccucgacugcagaggaagcaggaagcugucggcccagcucugagcccagcugcuggagccccgagcagcggc\n", + "aauagaaccaggauugcauuugaaguuaagcugcaaaaaaccagucgaucaacagauuuucgagucccacagucaauaugcacc\n", + "ccucccgcucugcgccgucgccccgcccacacgccgccacccucgcgucaguugucgcuccgcgccugcgcccguugucucccugcucgcuccpucccggcgccgcgcc\n", + "aaacgaacugaacgucugaaacgaagguggcgcggccuggacaaaccugacccuucgacaucccccgccccugcgcccgcccucgcuaagcpaggagcgaccgcuaca\n", + "ucuccagaaagcuucuuguaaccuggaaagauugguuauaguugaucauuuuccuccaucuuaaaagucaccugaagaauuccacaaggacuuag\n", + "uacuuuccucacagaucucuucagcacuguguucaggaacucucacuacucaaaggcagccacacagcucaaagaugugcaggagcauguc\n", + "gaaugaauauauucgcgcgcucuuugcagcugccugaauucuuccuuccccagcaucccccuccgcccggucacccagacggccuucuccagccuugccgagcuuaa\n", + "gacccgucccugcuccugaccaucaccgucacupucacugugcucguguugguccugaagagc\n", + "gagacuccagugacccggcpaggagaggcaacuuucccugucpcuugaguupagaggagcapcggccuuguagg\n", + "gaagaaggauguguucacuuccccuuucgccaugauuuuauaaguuuccugaggccuccccagccaagcugaacu\n", + "gagaagucuuaggagguaggaggcaggaggaacugaagcccagcugugaaggccgcagacugcagugagaggag\n", + "auuuuaaauccagcuccauacaacgcuccgccgccgcugcugccgcgacccggacugcgcgccagcaccccccugccgacagcuccgucacu\n", + "cgcccggaucucuuccgccgccauuuuaaauccagcuccauacaacgcuccgccgccgcugcugccgcgacccggacugcgcgccagcaccccccugccgacagcuccgucacu\n", + "gguugagcgagcpagaggcccpcacgugcagaaaggagccccgcgaguggcgcgccpau\n", + "cuccauacaacgcuccgccgccgcugcugccgcgacccggacugcgcgccagcaccccccugccgacagcuccgucacu\n", + "gaucucuuccgccgccauuuuaaauccagcuccauacaacgcuccgccgccgcugcugccgcgacccggacugcgcgccagcaccccccugccgacagcuccgucacu\n", + "gagagaagcccapuaccacuaauugapagugaggaagagagcagcucgcuucuaacuggacugcac\n", + "guuggugacagcgucccaagcuggugacagacccacucuguaacuuucagcuagauucagccaccagaucccagaaac\n", + "agacaugupuucuuucaaacauacuggacuuccuccuuagguuuuaguuguguuagucaauaguugaauguugaaggagaggaugccaapauauuaaagaag\n", + "pcgcggccggcgcugcagacccgcugcuguuguccpucugugcggucccgapcccuccgugccgccggcgcc\n", + "upcgcggccggcgcugcagacccgcugcuguuguccpucugugcggucccgapcccuccgugccgccggcgcc\n", + "cuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "gaugagguguaguggcaagauuucagcucacugcagcuuugaccuccpcuuaagcaguccucccacgucagccuugcccaaguaguupacuacag\n", + "augaagucucacucuguugcccaagcugcagugcaaugucgcuaucuuggcuuacugcaaccuccgcuucccgaagcgauucuacugccccagccuccugaguagcupacuacag\n", + "ggucccggcugcggcuucuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "uucuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "gcugcggcuucuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "gcugcggcacagccggucccggcugcggcuucuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "gugcaaggaauauguagagauaauuccacuaucaaagacuguauauacauuuuccaagaupagaugauggugauaaaacuauuuugcuguuccag\n", + "agccggucccggcugcggcuucuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "gccucpugguucaucccgccggagaggaauggcgagaaccuggaguguugacuggcaaaacauuugcagacgcgguuuuucuggcaauuaauuggcuccauuaaaaauuag\n", + "gcgcgccgcugcggcacagccggucccggcugcggcuucuggcugcgcggccugcgcgcgccucccpcggauuccagccccgagcpacagcgcggcpagcgacga\n", + "ggugaccugacucucugaggcucauuuugcaguuguugaaauuguccccgcaguuuucaaucaug\n", + "aauguggagaaauguuugaaugaauuggaaauuucccagaaccugaaaagacacguuuucaaggcaapcauuacucucucugccugucuaacpccaguggagacagcuacuaauuucca\n", + "ucugaaccaaucagaguccuugugacuggagcagcuggucaaauugcauauucacugcuguacaguauuggaaauggaucugucuuugguaaagaucag\n", + "gagucaguuccgcgguagaggugaccugacucucugaggcucauuuugcaguuguugaaauuguccccgcaguuuucaauc\n", + "gagucaguuccgcgguagaggugaccugacucucugaggcucauuuugcaguuguugaaauuguccccgcaguuuucaaucaug\n", + "ucuccgagucaguuccgcgguagaggugaccugacucucugaggcucauuuugcaguuguugaaauuguccccgcaguuuucaauc\n", + "cgcgguagaggugaccugacucucugaggcucauuuugcaguuguugaaauuguccccgcaguuuucaauc\n", + "cucuccccucggcucccggacgcgacggaggucguaguaguagugaguacgugcugaggagcaaaggaguaaccaagagauccagugaccgacagagcaagagcc\n", + "gaguccgagcgcgucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "guguuuupaacgaguuuaguauauuaaaaucaccapucuguuguuuuccgaaauggaaauuggccuauaccaggagagcggaucccagacguggcugcauugucc\n", + "gacgaapacpacccpagccuggacgaguccgagcgcgucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "gcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "acpacccpagccuggacgaguccgagcgcgucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "pagccuggacgaguccgagcgcgucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "gucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcaccauggcuguguuugucgugcuccuggcguugguggcgg\n", + "gaapacpacccpagccuggacgaguccgagcgcgucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "gucaccuccucacgcugcggcugucgcccgugucccgccggcccguuccgugucgccccgcagugcugcggccgccgcggcacc\n", + "agagcpcauuuguguucccucaaauggcggugugaagagaguucgccugagccagaucccaggcag\n", + "guuucacugaagaaacuucuuagagauucauugcacuucugagauuuaauguuuacaacuuggaguugucgaccuucuuauaagauacauuuuggaagucaaa\n", + "uuuuaacaapaggcaugagacaucaaucaagauauguaaaaugaacauugguucaguccagaaaggupacaacucuuaagcupapcuuccaggucacag\n", + "auggcugcucuugcuacauaagaccuggaacacaggacugcugucugcccucucugcucgcccugccuagcuugaggaucu\n", + "aaacuauagugacacugaaacugaaggagagauuuuuaauuccuuagugcaauacuuuggugacaacuupcgaaaaguuaaagcg\n", + "aagccucugucagcucagccuccaaaggagccagcgucuccccaguuccugaaauccupuguugccugccagucgcc\n", + "uuucuuuucugauucugagaugcuugugagagcuucagccaucuaggaacgcauacgcugcugcuugaccacgcuguagcag\n", + "uaugguuugaaguggugaacauggauuuuucucggcuucacauguacaguccuccccagugugugccggagaacacpcuacacguaugcgcucag\n", + "uuccagcuauucuucagaugcucuggauuuugagacggagcacaaauuggacccuguauuugauucuccacgg\n", + "ppacgcpucgcggccupcgcccucagcgcpcugcgccapccuccupccaacggcugccgcccccgcccgucccgcgccccgcagcuaccccggcccgcgcag\n", + "agagcaggccugcgcaccucaggagcccaggcaugguguauagguggapuagccuacauuggauccaggccaaggcccuguccugugccpcuccucugcgu\n", + "aucgcccggccucupccapacccgcgaggcggcggcugcuugcuccgaacggaacgccgccpugugcguuagaccagcggauagacgcccgcggcuup\n", + "auagcacaauccccuuguuuaaccaauacggaaaccaaagcucauggaaauuccupaaacaucacauaacuacagagugcagcugaagaaauugagugu\n", + "acggaaaccaaagcucauggaaauuccupaaacaucacauaacuacagagugcagcugaagaaauugagugu\n", + "gugauaucuauugaagcupapucacaguaucagugaguggucccccaauuucuucuugagcaucgaugaauuagcag\n", + "ugguguaauauuguggaucugacuucaugugucacuaagaacaggagauccaagacugcucuucupaugag\n", + "agagcugcucagcacgcccupaucgcpcgguuuucaucggccgguuugugaaacggacaagagag\n", + "aguucagucuuugauugguugcugagaggcpcuacucgacugcucuggagguagcggccgcggugaggagagcc\n", + "gauaaaugcggapacgguccagcuuuagcucucugcucgccgccgccgcugucgccgccaccuccucugaucuacgaaaguc\n", + "agaggaggagagagccuggcagcggaggagcagaggcpcgccgcaccgccccgcacgcucgcucgcucpagagucgcpcggccgcuupcgcacuugccpucaccuugucccggag\n", + "gagaaauggcuucccugaggcaaguguaaccuacauucccagcccaccagccugacgcccagccapagagaguacc\n", + "agcugauucuaucacauuguaagaugccuuuggauaauucuacaguccucuuaaaugaaucuuuagaacuuggcaagucucacuagauaccuucaaucaucauuuugagcucaaag\n", + "aauucugagacuuaugguuggucauauagaagaguaccuugaaccuauaguuuccugaagaaucaguuuaaaagauccaaggaguacaaaag\n", + "gcugacgacgcaugcgccpapcgcaaucacggacucggcuugcggcugccgguuuaaaaaaggaaaccccggagagcgagagcgcgaaggaaaucuggccgccgccgccgcgagcgcucccg\n", + "cgagucaccgcagcpagaccupupapaagaagccggagccgccgcaagccacacg\n", + "agugcgcgccggccpcaacccuaugcuggcguaaucpuuccuccgagccgccguaggacugguuccggcpcuggugagga\n", + "paagcuugccupacacgccgupcaugucccaggcuggcpuppagagacccuupacccaccapccguccccggcucgcucgcccuaccugaggugacccccuacccgcgag\n", + "ucagugcgcgccggccpcaacccuaugcuggcguaaucpuuccuccgagccgccguaggacugguuccggcpcuggugagga\n", + "gagaagacagacugcugcuuuggaccuguugguaaugauggccugagcuaaacaucuaacuagaapauacccuuccauuucaaagaacagaaugcuaaggaagcuguggcaa\n", + "gaaaagugcagccgguuugaaaugcaagauggcggcggcguggcgcugagaggcgcggcggccccugcag\n", + "guuugauuucugaugacucuggccugaguuccaggaugguuuuuucuupaccagacaugaacaaaaguugaccuc\n", + "aaauauagcauguugauuaagagaauggacucugaagccggauuucaucaguuuggauuuuggcuuuuccucuuucuagcaguuugg\n", + "uuaacgcgucacpcggccuggcagcuggcggcauugaggcggacgcgucuagagguccgucugaccgcggcgucpaccugguuuccpcaugagcugagagcaccacgccgaggccacgag\n", + "cagugccagcgccacagcccuucaaucauuuugguugcuauccagcuucuccacaucaaguccaacuucagaaaccccaagccuguagagaaaaguugaccugugcugacucuggugaug\n", + "ugccagcgccacagcccuucaaucauuuugguugcuauccagcuucuccacaucaaguccaacuucagaaaccccaagccuguagagaaaaguugaccugugcugacucuggug\n", + "gcagguaugaggcuggcgccgguggcuucgaugcugcuuuccggugacuucgaugcuguuuuccagugcuuuuuccuuuuucug\n", + "gcugcagugaagcuggacccgcaggcpcgugcguggagcpccgcggccgcgccgcagagaugugacucpccgaaggccagcuggagcgucggcgcugcpccgcpucg\n", + "uauuuacuaaacaucgugccaggugcugugugucgagcuugagucuacagccaugguucucauccag\n", + "cuagccugcauuucucuuuccauccucucgcauaucccagaagaaagagguacuugaagaguuugcaagagauauuaguaguacccguggcggccuga\n", + "aguucgauccuuuuggugaagcuagupcgccauuuugaaguupcagaaagugacuccagugguggaacccggagccaaccauuuuuaguuac\n", + "acgccccuguccuggcaagagcuagaaggugagcgugccaguuccugugcacacaagcgcucagcauccupcagcacagaccaccgaaaagag\n", + "auuuccaaguugaagcaacaacugcagaggacgaagcugagccgcagupaaagagaaggagcgagguucaccacuccuapaccacgcagugcpagcacugagg\n", + "auccuugauaucccugaupcaccpccccagcuccuccccagaguggcagcugugaucauccccuccuccuccuggagccuggcaaccuugccagcucuccuucc\n", + "uucccpagucguaucccgagcauggagguuacugagaccguuauuucuucauggccugccuagcuuaagcaguagcuggaaaa\n", + "auuccccgcacccacccacgucuucccpagucguaucccgagcauggagguuacugagaccguuauuucuucauggccugccuagcuuaagcaguagcuggaaaa\n", + "aucaguccgcauuccccgcacccacccacgucuucccpagucguaucccgagcauggagguuacugagaccguuauuucuucauggccugccuagcuuaagcaguagcuggaaaa\n", + "gccgagccpaaaucuccgcccccagcuggagcggcugugcpcugcguagcggugcupucpccgacgugccacccacccggagccg\n", + "aaaucuccgcccccagcuggagcggcugugcpcugcguagcggugcupucpccgacgugccacccacccggagccg\n", + "gaaaucuccgcccccagcuggagcggcugugcpcugcguagcggugcupucpccgacgugccacccacccggagccg\n", + "gugcpcpaccggcccggccuauauauupuuggcgccggcgccagcugagccgagcgguagcuggucuggcg\n", + "ccggagcpccuuggaggcccagcccgcgcggcgacgucuccgcguggcgucacggcaccgacugacggccacccacc\n", + "aupcaccaguugcgucuugaagugccaucagcuguaaccaaaguuccacaucccaagacgacagccaggcguuccugcccucaagaacugaagaca\n", + "aauauuucuacggaaggcgcugcacagacuagcaaaggcuguuucuuuuaccugacugaggucacugcaucagcugaaggcagacgaugugcuuaagccugaguggagcagag\n", + "ggaccugucagccuupuguagcaccugcaaggaggacaugauucuccugcggugacagccugaccpccccccacccaccaaggcaggaccacggcgaccupagc\n", + "ggaaapcgcapagucugaaagcuccaggagcagcagaaggcccaguggccggucuccaaccaguacugagaagcgc\n", + "gucacccggcagacuccggapuagagcgcugugccgguuccgcugccgcuggccaggagcgcpacaguucpcugcgccggaggccggcccgccuucccpuuccguuauc\n", + "aguccuccaupcuagaagagagaaggacggagucgaguggcacccuagaagacgcucugugccuucggaggucuuucugccugccu\n", + "aggcggccguggcgcpuggcggcugcugugcuggcugupacggaggcggugaagugccaucuucggcuaggucgucacaggcuccggcucauggcaucaaguggcauccaucauaag\n", + "auuggcuuccgccucupaucugagagaagcgaaagcgucuuucugapugucuugagaguggcagapcagcpuccaggcuccaugaggaggcaag\n", + "gaucuggcugaggaggaaguggaggugucacuggccccggccuuugccccaaucuugugupcacugaapacuacag\n", + "guaggaacagcguaagaggagagagacacauucagcagccaaaggacucgguggaaagagcagaacaccauagaca\n", + "guucaucuuauucgccagccaaaguaggaacagcguaagaggagagagacacauucagcagccaaaggacucgguggaaagagcagaacaccauagaca\n", + "cagccupugacaaagagagacucugucucaaaaauaaaauaaaauaaagauuuaaucuauauuuguaguuuagaaacuaaugauuccagaucauagag\n", + "aaacgcupaacgccuccgacccuggauagucgccgucaggcacugaggaggccgagagaugaggccggagcccaccaaguucupaa\n", + "paacgccuccgacccuggauagucgccgucaggcacugaggaggccgagagaugaggccggagcccaccaaguucupaa\n", + "cuccgacccuggauagucgccgucaggcacugaggaggccgagagaugaggccggagcccaccaaguucupaa\n", + "gacccuggauagucgccgucaggcacugaggaggccgagagaugaggccggagcccaccaaguucupaa\n", + "pcguguucguggacaguggugauggacugguaucugucggcgccagcguuuggcgacgccaguggaauucuuucaggagcuuagcgupuccgauuccuaucgcapaacuacaagag\n", + "acacugcgccgcggcugcgcaguacacpaggcuuuuaauuccauuguggagaggacggcguuauuuuuauuaacuggaggcgacggcggcugcggcggcggcpaccc\n", + "aguacacpaggcuuuuaauuccauuguggagaggacggcguuauuuuuauuaacuggaggcgacggcggcugcggcggcggcpaccc\n", + "agacgugacccapcagacugguagcaaagcccccacgcccagccaggagcaccgccgaggacuccagcacaccgagg\n", + "gacapccaagcccagcucuccuccaagcacaggcucugcucacggaggaccupcacacupcagagugcacacaccgg\n", + "aapcgacucugaugcaagguucugagaggccugupcuguggauuccuaagcagccucagcuuupuuuugcaccuuaggucuug\n", + "agaaagaagaguggcaugcuuugacagcaaguggacuccgaguccapcagagccucaguuagg\n", + "aagugucaggacuuuacgacccgcgccuccagcugagguuucuagacgugacccapcagacugguagcaaagcccccacgcccagccaggagcaccgccgaggacuccagcacaccgagg\n", + "uccucucucaggagugcacgaaguucaaggucagcagcugccpaaugcaucgagucpcccggcugcaccuggugccagaagcug\n", + "cgugacccapcagacugguagcaaagcccccacgcccagccaggagcaccgccgaggacuccagcacaccgagg\n", + "acgacccgcgccuccagcugagguuucuagacgugacccapcagacugguagcaaagcccccacgcccagccaggagcaccgccgaggacuccagcacaccgagg\n", + "acucupcgcuaggcuccggacuccgcggcgcagacugcaccucgcagucuccccagguccgcccagcagccgcgcuucagccag\n", + "aggacuugucaccaggcuucgguacccaguuagugugaaapaagaaugcacccaccacugcaggauucagcuaug\n", + "gcuaguuauuuugcaagcpapccgugcgcgcuccugccucaggccucugucccccacccccuuuccccggucccaggcucuccuucggaaag\n", + "guaacggaguggugcgccaacgugagaggaaacccgugcgcggcugcgcuuuccuguccccaagccguucuagacgcgg\n", + "aaagagaaaaaagagaagccaaaaucugauaagacugaagagauagcagaagaggaagaaacuguuuuccccaaagcuaaacaaguuaaaaagaaagcagagccuucugaaguugac\n", + "gacgagagccpuggacccapupaacuaccucuuccucuccacgcgguugagaagaccggucggccupcaaccugcgcugaag\n", + "paacuaccucuuccucuccacgcgguugagaagaccggucggccupcaaccugcgcugaag\n", + "ggauaacagcgcguccagacaccpcgupucuuggcpcggucgcccaggaguggugcgcuccccpcaguggacgcgucguuugcccgaccgagccag\n", + "gcagacccuggcagaapcacpcapugugaguuccccacuagcapccaggugagcu\n", + "aggcapaaggauccggcaaaaaaggcacacgguucaggccuguccacuccagccuupaggaggugagcaggucacc\n", + "ugcaaguupcccaaggcapaaggauccggcaaaaaaggcacacgguucaggccuguccacuccagccuupaggaggugagcaggucacc\n", + "gaagcgugaugaaggccuacgagugcggcgcggccugaapcacgcpaccugcaaagcuagugapcpcaggcggcgcggupcpccgagcccggaggccag\n", + "cpcugaagcuuucaacggaguuucagcccupuuupucucucggupacpcggaagcagag\n", + "gugaugaaggccuacgagugcggcgcggccugaapcacgcpaccugcaaagcuagugapcpcaggcggcgcggupcpccgagcccggaggccag\n", + "guggccaugaacgguaaggcccgcaaagaggcggugcagacugcggcuaaggaacuccucaaguucgugaaccggagucccucuccuuuccaug\n", + "aggcacacgguucaggccuguccacuccagccuupaggaggugagcaggucaccauggcucggagccucuccaucauguucguccccaacagcuggcucaauggcuaccacaag\n", + "aaggcapaaggauccggcaaaaaaggcacacgguucaggccuguccacuccagccuupaggaggugagcaggucacc\n", + "pcugaagcuuucaacggaguuucagcccupuuupucucucggupacpcggaagcagag\n", + "aaggcapaaggauccggcaaaaaaggcacacgguucaggccuguccacuccagccuupaggag\n", + "gcpapaaugaaupcgcupaacacgcccgcgaggupacgcgccggccguagcgagguccuuagcgugugaguggccpucpucgcuuccccgcagc\n", + "ugaaupcgcupaacacgcccgcgaggupacgcgccggccguagcgagguccuuagcgugugaguggccpucpucgcuuccccgcagc\n", + "aaugaaupcgcupaacacgcccgcgaggupacgcgccggccguagcgagguccuuagcgugugaguggccpucpucgcuuccccgcagc\n", + "guuuggagucguuugcugcpapaaugaaupcgcupaacacgcccgcgaggupacgcgccggccguagcgagguccuuagcgugugaguggccpucpucgcuuccccgcagc\n", + "paaugaaupcgcupaacacgcccgcgaggupacgcgccggccguagcgagguccuuagcgugugaguggccpucpucgcuuccccgcagc\n", + "gcgcupaacacgcccgcgaggupacgcgccggccguagcgagguccuuagcgugugaguggccpucpucgcuuccccgcagc\n", + "gcaacggucccaaaccccuuccapacupacuacggacccugguccgaccuucucgcpcuucccacugcgccaaucaaaucccagaaaca\n", + "gcgccggcgcgcuccuuuugcaggcucguggcggucggucagcpcguucucccaccuguagcgacucag\n", + "guauaaaaapcccacaagagaccagcuccagcaucccaaggcccgacuccccgcaccacucapuccuguggacagcucaccuagcggca\n", + "gaagaagccuauaucacaaaggaacagaaguauucauuccugcaugacucccagaccuccuucugcuucucagacucuauuccgacauccuccaac\n", + "agcaucccaaggcccgacuccccgcaccacucapuccuguggacagcucaccuagcggcaauggcugcag\n", + "gcauucccpcpccggaccggcpcpcpacucggcgcpcccucccggccagcggcggcagccuccuccccggcgcccucaggaccccccagagcccccggcggcggca\n", + "cucaugcucccaccacaggcuggaagcggupaugagaguuccaacuguggccugcagagupcuggcpcugguccaggacaagagaaaguggugccag\n", + "acuccggcaccgcggcuucgaacagccauuaugcgcagcugagaccgguggaggcapaagcupacggagugagcgagapaaugupagugacccagaugucagg\n", + "aaaagupugaaaggucggcggcgccggcacugcagcupcugagaagccaggacggcccgagaacugacagacggagugacagacggacugacc\n", + "ccccgcccacccaaaagupugaaaggucggcggcgccggcacugcagcupcugagaagccaggacggcccgagaacugacagacggagugacagacggacugacc\n", + "gaaaggucggcggcgccggcacugcagcupcugagaagccaggacggcccgagaacugacagacggagugacagacggacugacc\n", + "gacaccagcagcugaaugauuagaacaggagaacacugguugccagcaguauggaaagaaagguupaucuccaggaaacagaaagaaggagcaaaagaaucacauuugaaaauccug\n", + "gcggccgcggccggaggagcaauagcagcagccguggcggccacpcpcgcggcggucggugaccgcggccpcugcaggcggcggagcggcugg\n", + "uuuugaauauacuaacacugaaucagcacuucuaaagcccuuccuucucccacuggcuucacuuggcuuucagacauaaugaggagacuggcuuuucgaggcgcugguugugcucug\n", + "aggagcaauagcagcagccguggcggccacpcpcgcggcggucggugaccgcggccpcugcaggcggcggagcggcugg\n", + "gcuucpaacugaaapucagcguggcupcacaggaaugapaaaggcagcgccugcccgagag\n", + "pcaggcccguuucuccuggugguuggugcguuguagcagcagcpagccaggacuaaggacaagcaggagcupagccccag\n", + "guccgcgcgcgccpagcggcgcccccgccgcugccgccgcgacccuuggcgccugccccugcaacpag\n", + "uuuuuuucagacagagugucacuuuauugaccaggcuggagugcaguggcaagaucucggcucacugcaaccucuaccucccpuucaagugauucuucugccucagccucccag\n", + "gucugcapaacuggccaggcaapcaggcccguuucuccuggugguuggugcguuguagcagcagcpagccaggacuaaggacaagcaggagcupagccccag\n", + "gcuggagugcaguggcaagaucucggcucacugcaaccucuaccucccpuucaagugauucuucugccucagccucccag\n", + "pcucccggupcagcggupapapccuggacauggcgcugapccgccccgcpaag\n", + "cugccugaccaucacccccuccucuugucgccccacccaggccucuucacccugcucguggaagauuucg\n", + "cccuguauauggauuuaucuuccuguucaaauggaucgaagagcgccggucccggcgaaaggucucuaccuugguggaugauacguccgugauugaugaugauauugugaauaac\n", + "cucggcagccgccugucgccgcpagcagccgcuaucucuguguguccgcgugugcgcccgguccccgccugccgcacc\n", + "gagcucccaccccgccccgcccccapcgccccpcccggcgcgagaggaggcagapcgucaggccgcpagaggaggcc\n", + "aaacgaagucucacuguguuguccaggcuggucucaagcuccupcucaagcaauacuuccaccucagccucccaaaaugcupauuacag\n", + "gaagguggacuuuuaaauauucuccacugaagcaaaugcugcaacaauuugcauuuccuucaccaaugucgucuugugccuuuucuuguuccuacuguaaaggagaupuuagauguu\n", + "gguugaaggaacpcaguccccugaggagcpcugguugaaacgcuapcpaucuggcggaguggaag\n", + "aagcgaaauauuaaaaapagccguuccccgcucuauccccaaucuagcggagguaaagaagaaaggcaaa\n", + "gaaggaacpcaguccccugaggagcpcugguugaaacgcuapcpaucuggcggaguggaag\n", + "gucpccpccggcugagugaaapupugauuaucccpagauaggccgaaapcag\n", + "puggagcugguugaaggaacpcaguccccugaggagcpcugguugaaacgcuapcpaucuggcggaguggaag\n", + "guacagcgcgucgacggcggaggcpaapcggaggccgaccgaaggcggcuapacuggcugaagagg\n", + "gucgccagaaacuugguggagcgagccaapcggaguuugagaaapcugcguccaaugaguggagcg\n", + "ggaguuaagugaaucguuaapuggagucgaaaccpucpccpccggcugagugaaapupugauuaucccpagauaggccgaaapcag\n", + "apuggagucgaaaccpucpccpccggcugagugaaapupugauuaucccpagauaggccgaaapcag\n", + "aaccgcggcapccaagccuccucaacuaugaccucaaccggccaggauuccaccacaaccaggcagcgaagaaguaggcagaacccccagucgcccccucaggacuccagugucacuucg\n", + "auaapuggaguuaagugaaucguuaapuggagucgaaaccpucpccpccggcugagugaaagg\n", + "guaguuccpcggaaugagagcagcacgccuggcuccgcuccuucuuacucaugcgcgacuccgagcuggccaaagaaguucguccccuuugugaggcccpaupag\n", + "guagccgagguuugcgcugccgccgccaggcccgguccgguuccagccucugcccggacgcuagccggccuggcc\n", + "agaucuuuuccagcagcugcugccugccagagaggcgccuucagagacccagcgcuuacacaauacccacc\n", + "agacgugaagccuagcagaggacuuuuuagcugcucacuggccccgcuugucuggccgacucauccgcccgcgaccccuaauccccucugccugccccaag\n", + "gaaaaugcauuuauguuuapugcgcauggcapapucucugcggcgcuuucggccggapcagcagcg\n", + "gcuggagugcacuagcgcaaucucggcucuccgcaaccuccaccuccuggauucaagcgauucuccugccuccaagcgauucuccugccucagccuccugaauagcuggaauuacag\n", + "gguguuacuaucguuaaaccaauaguuuacgguaauguugcucgguauuuuggaaagaaaagagaagaagaupcacacucaucaguggacaguauaugugaaaccauauagaaaugag\n", + "aaugcacugucagacuaagacagagaaccaucauuaauugaagugagauuuuucuggccugagacuugcapaggcaagaagacacucuggacaccacu\n", + "gucagacuaagacagagaaccaucauuaauugaagugagauuuuucuggccugagacuugcapaggcaagaagacacucuggacaccacu\n", + "cacacacaaacacacaccccgccaaccaaggugcauguaaaaagauguagauuccucugccuuucucaucuacacagcccaggagg\n", + "agagaaccaucauuaauugaagugagauuuuucuggccugagacuugcapaggcaagaagacacucuggacaccacu\n", + "auuuupaaccaguaggacauugacauacauccgagaacauucugugguggauccaguggaaaagaaa\n", + "cccgcccacgccgcgcccggagccgcgcggcccgaagcacccggcccggaucgcagagcccgcgcccugcgccggcggcaaugaagaucuggagcucggagcacguguuugg\n", + "cccgcccacgccgcgcccggagccgcgcggcccgaagcacccggcccggaucgcagagcccgcgcccugcgccggcggca\n", + "auaauucuaacaucuuugucaucaguguugacaucucuugauuguauccugucauuccauuugagaucuuccugguucugg\n", + "ggauaucuucuaaccauaccgaugauucuccguauagcuggucuuuuccaccuuaucauccuuccucugagaaguaugaaaacacuaag\n", + "acaugucgapccagauggagaacuccaugccaaccugcuuugcccuguggaugugcuggauguucccgapcaccuugccugacaaacagagcacugagcaagccauacaguuguuggaaaag\n", + "pccucggagcaagauggcggcggcpuccgugaggcgcpcggcggcgaccgcggcgccagugapcccupcccpcggcuccpccpccccgccgcpacggacc\n", + "guccguacugcagagccgcugccggapucguuuuaaapcccgcgcguugccgcccccucggcccgcc\n", + "guacugcagagccgcugccggapucguuuuaaapcccgcgcguugccgcccccucggcccgcc\n", + "cuuaaagcaauaaauguagaucuucaaagugaugcugcucugcagguggacauuucugaugcucuuagugagcpauaaaguaaaauucacuguucacacaaag\n", + "aguucauugccaaauuuuaaacaaaacgaguuuucaguuguucggcaacaugaggaauuuaucuggcuucaugauuccuuuguugaaaaugaagacuaugcagguuauauc\n", + "auuccaccagcaccaccaagaccugauuuugaugcuucaapaaaaacuacagaagcuuggugaaggagaapuca\n", + "pccuucugguggaccuccacucccacgcpcpugcagguggcgaaguggaaauggaggcpag\n", + "aaucucacucugucacccaggcuggagugcagagguguggucucggcucacugcaacuuccgccucccaggcucaagcgauucuccugccucagccuuccgaguagcupacuacag\n", + "ggacuaugucaccggupcuugccccagcaaggccaccaucccupaagacggucaucgugacpugccaacacaggcaucpaagcagaccgccuuggaacuggccaggagag\n", + "aauuucacucugucgccaggcuggaaugcaguapcaaucucggcucacugcaaccuccaccucccgaguucaagugaugcuccugcuucggccuccugaguagcupacuacag\n", + "gcgccuccgcucgccuguggcugcgucgcgcgcucuuccucggagcuacccaggcggcuggugugcagcaagcuccgcgccgaccccugacgccugacgccuguccccggcccggc\n", + "uacgaaccccgagccgccgccgccgccgccagcagcagcugcagcaguggcagcugcaguagcggcagcagccccagccucaaggccag\n", + "uuuaagcuaugaagaaggacaucccucacacucugaaacagaucuccuucagagacagaguuuugcagccucucaucagcuuccuggauaugcucccacaccucagccuacug\n", + "gucuuucuggaauauuugauacuagugugaacagugccagcaguaacacuaaagagucuucagug\n", + "gugccaagcucuccugaugaaauguguucugccccacupcuccapacagugucuggugcuguugaagcccuuauucgaacuuuccaga\n", + "agugcaguggugaguuggagcgcapccguupauupucauuapccguugacaguccaggccagapcgagugagcgagguupcccgaggcugccuguaagcag\n", + "paacuuccugugugccuucuauccugaugacacccccucacugaaauccugguguuguuuccacagagcugucuggccuuuuguccuugauccuugguuaaggaa\n", + "uapapcpccuguuuccpaggcgcgupcuugaggccgagaacggcccuugcugccaccaac\n", + "gccggcggagaaggaggacccpagccggcggcccggagcupagcgcpaaggcgguupuucugacagcugcgcgcg\n", + "ccccugcccgccuccpcgcccgucacuuccugcccggcccggugaaggcccugccpcggcggcggcggcgacagcgugcgagcc\n", + "gcgugcgcagaucapaucgcgauugcgaauccuccgcugaggugauuuggauaucccuagaacguugapcacgagucpuccugagaccag\n", + "gcgaauccuccgcugaggugauuuggauaucccuagaacguugapcacgagucpuccugagaccag\n", + "apaucgcgauugcgaauccuccgcugaggugauuuggauaucccuagaacguugapcacgagucpuccugagaccag\n", + "gguccgcggagcgucucuggcgcuuacccugcuuupccugcguugcugcugcugcuccuccgcucccccgucguaucgccugcccuggaucgaagug\n", + "aagugcgguccgcggagcgucucuggcgcuuacccugcuuupccugcguugcugcugcugcuccuccgcucccccgucguaucgccugcccuggaucgaagug\n", + "aaacgcugccagaaagcagcucucgcuucaccucugccpacuccgcccucucccccagcgcuccaagcggagaccgcag\n", + "gcacuacccagacugccucugcuucagccaucgaggacucpcggaacuaagcuacaaauccuucuucaaaccacaccaaaaaccuauugcaaacguaaaugcugccccauugg\n", + "gccuuguuccagugugaccacgugcaauauacgcugguuccaguuucupuggcaagaacuugaaacugcauuucuugagcauaaagaacag\n", + "acuacccagacugccucugcuucagccaucgaggacucpcggaacuaagcuacaaauccuucuucaaaccacaccaaaaaccuauugcaaacguaaaugcugccccauugg\n", + "agugugugccucagcgccuggugcgugcggagcuagugacpupcccggcupcccgucauuccuucagugaacauccc\n", + "aagcgaaugaagacggcagugugugccucagcgccuggugcgugcggagcuagugacpupcccggcupcccgucauuccuucagugaacauccc\n", + "pucagcggucgcguaggacccagcggacucggcagccupcgcccggcggagcugaaccgcggcccccgguggupcucagccggucgagcugcgcpag\n", + "gacpagccggcggcgcugcpucagcggucgcguaggacccagcggacucggcagccupcgcccggcggagcugaaccgcggcccccgguggupcucagccggucgagcugcgcpag\n", + "ggcggcgcugcpucagcggucgcguaggacccagcggacucggcagccupcgcccggcggagcugaaccgcggcccccgguggupcucagccggucgagcugcgcpag\n", + "agauuacggaaguaccgcgagcaaggagcgcggaaucpagcguccggagcuagcuggauccucuaggcag\n", + "agagcuuugugcugaacaucaguccuccacaucgacuccucuuguaagauguuguguccagguggaucaucacaguggcugccauccuuaaauaugucuugguccuguugcugcuaauugau\n", + "acguccgccauuuupcgcuucgcugauggugucggugagcgcguuucccgccugagcgcaacuagcggcpucgupcaccuccag\n", + "auaagaaaacaagcucagagagauguggugacuugcucaaauagugacagaacuuccucggccauauggapucauauaauacccuugugucuucaguuugagguaccucccauaauuuuaap\n", + "uuupcgcuucgcugauggugucggugagcgcguuucccgccugagcgcaacuagcggcpucgupcaccuccag\n", + "cgcuucgcugauggugucggugagcgcguuucccgccugagcgcaacuagcggcpucgupcaccuccag\n", + "pcgcuucgcugauggugucggugagcgcguuucccgccugagcgcaacuagcggcpucgupcaccuccag\n", + "uuuupcgcuucgcugauggugucggugagcgcguuucccgccugagcgcaacuagcggcpucgupcaccuccag\n", + "auuuupcgcuucgcugauggugucggugagcgcguuucccgccugagcgcaacuagcggcpucgupcaccuccag\n", + "auaagaaaacaagcucagagagauguggugacuugcucaaauagugacagaacuuccucggccauauggapucauauaauacccuugugucuucaguuugag\n", + "gcggagcagugacggcugcgauaauagcgaggcagcagugcagcuuucagapuccpcucagapuu\n", + "agguaaguagaaaccguugaupacugagaaaccagaguuaaaaccucuuuggagcuucugaggacucagcuggaaccaacpcacag\n", + "gacuuucagaagaugaagguaaguagaaaccguugaupacugagaaaccagaguuaaaaccucuuuggagcuucugaggacucagcuggaaccaacpcacag\n", + "guguugucucacauaauccuuaaaacucagaaaugauuuuaaauuaaauagcacagagaggaaaacugacuggagapagccuuugcuuag\n", + "auuagaaaacugaagcuucaagaacagacuugccuaacaacaggaaacuuguaugucucgaaguggcaauucacacauaaggcuccaugacuccugaacucucacaaauauuaguuggcucuuuuc\n", + "auuccgaapuucugugcuaggaaccuuacacguguugucucacauaauccuuaaaacucagaaaugauuuuaaauuaaauagcacagagaggaaaacugacuggagapagccuuugcuuag\n", + "gcuuccugccucagccuucugcugcuuugcucucupagauccagcuccuugcucugugucccaguagaac\n", + "gagucgauugccucacugcauguguauucgugaguucgcgguugaacaacuguuccuuuacucugcucccugucuuu\n", + "caauucupuacguacaacuucupccugcaaauuauuggagagugagugapcaacgaaagauagacauaaaapcgcgucucgaaag\n", + "caugcaauuuuuaaauacacggugcaagauaaccaguaaaggcgcguuccuucugaaaauugaggccggucucagaaccaucuccugagaaagcauccuuuuc\n", + "auuauuuggagcaacaagguuaccuacucgaaucacuggauccugaguugacacaaaacgcaucuguugacucapuuuguauaaccacgugcaguauuuacuaggcuauccaauucugg\n", + "gauccccgccucaggcucucaaccuccucuccugcagcuccagcucugugcucugccuccgaggagacc\n", + "auaaaggaagguggcacaaggaauauuauguggagauuacuucagaacacuacaagcagucccuaaucaagagaggcaagagcuaaag\n", + "acauacccccugcuugcucaauugaucaagacccucucaupacccccuuagaguuguaggcccuuaaaapacaggaauugcucacuupagcuugguuuuuagagau\n", + "cccccugcuugcucaauugaucaagacccucucaupacccccuuagaguuguaggcccuuaaaapacaggaauugcucacuupagcuugguuuuuagagau\n", + "ugaaacccaauggaaaaagcaugacauuuagaaguagaagacuuagcuucaaaucccuacuccuucacuuacuaauuuugugauuugg\n", + "ggccgccccggcgcagcugaaccpccgcgccugccaggccgacpucuggcccagccuggcgccaapuucgugcgcuguggagacgcggapucgaggcggcgcggccugag\n", + "cuuuguugcaagaauauaguacauuuggcuuggcacaguggcucacaccuguaauuccagcacuuupuggccaaagaaggaggauugcuucagaccaggaguuupaccugccugugcaacaua\n", + "aaauauccgcgcaagauguugacguugcagacuuggcuagugcaagccuuguuuauuuuccucaccacugaaucuacag\n", + "auuccuccugaagacacagcauccacccgaucuucauucacuguccaagaccuuaaaccuuuuacagaauauguguuuaggauucgcugu\n", + "ggaaaaagcaugacauuuagaaguagaagacuuagcuucaaaucccuacuccuucacuuacuaauuuugugauuugg\n", + "augcauuuuuguagaagcauuuugaggaugaauguuugcaaaucauuuugaaauugccaagugccacauaca\n", + "uggaauguauccugcuuucaucuuggaguucaccuguguggcuuggauuuaucacaguagcauuugucuucaaucuguguguuaacuagaaaucaaggaaagac\n", + "gaugaugucaggucauaggaugauauauauaaucagugagcaggcagaaugaggagacaguugaaaguucucuacaacagaagccaagaaggaagccgucuaucuuguggcgauc\n", + "agugacauuugugagaccagcuaauuugauuaaaauucucuuggaaucagcuuugcuaguaucauaccugugccagauuucauc\n", + "gapcccuccuggacccpagcggacccugguggcggugaagcccgauggcgugcaacggcggcucguupacgugauccagcgcuuugagaggcpcuucacgcuggup\n", + "cgcgcucacagcggcccgcpccpcgucaupcggccucuucuggcgcuccgcgcugcpcugcgcugcggcccgcpccccpcccgagccugcuagugcgccacggcucgg\n", + "auagaapagaggagcgaacauggcagcgcguuggcgguuuuggugugucucugugaccauggugguggcgcugcucaucguuugcgacguucccucagccucugcccaaagaaagaaggag\n", + "uagagacpuuucacgauguuggccaggcuguucucaaacuccugacaucaagugauccauccgacuugaccucccaaagcacugagaugacag\n", + "agagcucuauagapcagccgagagacagaucuucgaccgaaucgucuaaggaacuagcuucaaaauggcguucaaguuccacaagcuucg\n", + "aggacugguguuaapucacgcaagauggcggcgcccagaggcugcugaggcgcggaacggagg\n", + "ucuggcuagucuccuccccguccacucccuccacuuucugccgccpacccggcupagccggcuguggcaguggcaguggcaguggcagcgacagg\n", + "uuucagaacaagcuuccuggaacccaugacccaugaagucuugucgacauuuauaccgucugapuagcagcucgaaaguagaagaa\n", + "aguguugccapacggcaguaucucuuugugugacccuggcggcuuaupacguuggcuucagaccuuugugauacacc\n", + "uuagagauaguuuuucucauccucaaguauupaguccaacuuugaguggaaucuggacuaaacuucag\n", + "uuucagaacaagcuuccuggaacccaugacccaugaagucuugucgacauuuauaccgucugapuagcagcucgaaaguagaagaagugg\n", + "gagccgguaccgaggcccgagccgcpagucgagcgaaggcagcgccgaggccgcgguuucccccupccuccccagcagcagcc\n", + "gcgucpagccgguaccgaggcccgagccgcpagucgagcgaaggcagcgccgaggccgcgguuucccccupccuccccagcagcagcc\n", + "gcggagccugcgcpccgguaggaucgcgucpagccgguaccgaggcccgagccgcpagucgagcgaaggcagcgccgaggccgcgguuucccccupccuccccagcagcagcc\n", + "gcpccgguaggaucgcgucpagccgguaccgaggcccgagccgcpagucgagcgaaggcagcgccgaggccgcgguuucccccupccuccccagcagcagcc\n", + "agccgguaccgaggcccgagccgcpagucgagcgaaggcagcgccgaggccgcgguuucccccupccuccccagcagcagcc\n", + "pacugucagauuugccaggcauuguuugaaguucuucccagcccagaaaccugcauguguagauuuug\n", + "pcgupcpccupccggcgccpuccggccpcgcucagccagcugcguaaacuccgcuggagcgcggcggcagagcag\n", + "pccupccggcgccpuccggccpcgcucagccagcugcguaaacuccgcuggagcgcggcggcagagcag\n", + "caucuacacgccauucacugaggacacacccucggupccagcgccuccucaacuccgugcugaacacccucauc\n", + "pcpccupccggcgccpuccggccpcgcucagccagcugcguaaacuccgcuggagcgcggcggcagagcag\n", + "cugcuugaagccuaacuguccaccagaaaggacugcucuuupugaguugaacuucuuccauuauagaaagaauugaaggcugagaaacucag\n", + "pcugcucagcggcgugcacaguccugccggcuggcuupupuggupcugcpuapapauggaccgagucccggcuugucpaugapuuccggaagaucuggcca\n", + "gcacucccgcguuccacpcagcauccggcggcagcggagccuguggcucccccugcpcugcucagcggcgugcacaguccugccggcuggcuugg\n", + "accgauggagauggcggcugcggcugagugacggacgguggaggcccagagcccpccugaappacaaaccupugcccgcaggagcccggcapuacauacagagg\n", + "gauggagauggcggcugcggcugagugacggacgguggaggcccagagcccpccugaappacaaaccupugcccgcaggagcccggcagg\n", + "gaguuccgagcgaccgauggagauggcggcugcggcugagugacggacgguggaggcccagagcccpccugaappacaaaccupugcccgcaggagcccggcagg\n", + "ccgagcgaccgauggagauggcggcugcggcugagugacggacgguggaggcccagagcccpccugaappacaaaccupugcccgcaggagcccggcagg\n", + "uggaaaauggagaagcugugcuaauagappccagaaauccccacucuagaaugcuguagaauguupagacacccaggau\n", + "cucuccgccccggcgcucagapuaacucucacccaccucguccgcuucucugaaccagagugacccaggcugcgcuccgccccgcucuccuaccccgaguuggcacggag\n", + "gaagaccuuugugaguguccapaccggcugugccaaaacpccccuguaaugcauagacuccaaacuugacuucuguccuuugcuccugcaguuugccaucuuucugucucuuauc\n", + "aagcuaaggcagcaggaccuggagccuccugcuuuggagugguucuucaauacugcugcugcuuacgcgccpaaacupaaggcuggugagcgagaaggcaag\n", + "ggugcgccupcagcuuccguagcccccgagcpagcpcgcccuccugcgccugcccucggagcgccucgacuucucc\n", + "aagauuuggccapcagcugugcuggcuuaugcucuucuccuucugcugcugccauccuccagcaag\n", + "guaucugaagaaagauuuggccapcagcugugcuggcuuaugcucuucuccuucugcugcugccauccuccagcaag\n", + "aaguccaacagugcgcgacuccccaggucaggagaagccccgaugugugcagaaucugcagaupcugcucucggcccugccucuggcuguggaaacaggccuccaaguacccaag\n", + "gagcuuccuccacauuggucupacuaggcagaacaggcccugaccuccugagagapaaggaagaccaggcaggucugagccag\n", + "gcgugcgcgugcgcapauaagagagcggucuggacagcgcguggccggcgccgcugupacagc\n", + "gcugugucggagacugcaacagucagcacacauuccugauugaucaggcucccucccucaaguccucugcg\n", + "acacgcuuccacgcugcggagcugaggugaucucuucagacccuucggagagacccagauaucugacuucccacugagagacccggaauugcccagaguuugagaaa\n", + "gaguacacauccagaugccagcccagcuaccacapaucccucupagacugaaaguacagguucupcccagguugaagccgaccaacccugagccucaggccapa\n", + "gcugcgguggacagcgcpcuccggcuggcucgccuucccgccugccguguccugcugagcgacccug\n", + "ggacgccguggcgcccucugucgccccgaggcaagcagguggacccagcugagaagaagucugugucgcuguguggugagcucuccaggccaggugccgcgcggccuccaccucugcg\n", + "ccugccgcgccgccgccuucgccagcccggaccggaccggcccgccuucccuuccuccgcuccagccggccuccggccccgcaaccuccuccucggcgaagucucccuggccgcccc\n", + "gcccucggugcugcccacgccuacccagcucaauggucuguaccuaugaccaugccccugguguccugagcucagccuccuacccacuaagaaacucaacagucuggucuguguuuggcagg\n", + "ccuucccuuccuccgcuccagccggccuccggccccgcaaccuccuccucggcgaagucucccuggccgcccc\n", + "cggaccggcccgccuucccuuccuccgcuccagccggccuccggccccgcaaccuccuccucggcgaagucucccuggccgcccc\n", + "aaugcaaauguccccupapucaggucacagcgaapaggaagcccacccuaucaapcugugucuggaaccgcuucaucucgcuccacucagccgu\n", + "agcugagagaagcccuggcaggucaguggcaggcacugucacgcugaguccuaugcuggcagcpaaccuupagaacacpacaccgcggaagccpaaaug\n", + "ucaguccucacagagccucuggaagcacapaaggcagcugupauccuggcugaacagaguccag\n", + "gugugcauccucgagugugaagagaaggucuuccccagcccccucuggacuccaugcaccaagguc\n", + "agguagagguugagacuccacugaauaaacucuagguucccauuucuuucagccagauccucccapaaucacuacaggcugguuagccaaaaaguccugauuuucugcucaauagag\n", + "cagauccucccapaaucacuacaggcugguuagccaaaaaguccugauuuucugcucaauagag\n", + "cacugaauaaacucuagguucccauuucuuucagccagauccucccapaaucacuacaggcugguuagccaaaaaguccugauuuucugcucaauagag\n", + "gccccgcgagcgccgagacuuguuggccgcggagacugcgacccucuucucucagucugccuuacuacc\n", + "cggccccgccccgcgagcgccgagacuuguuggccgcggagacugcgacccucuucucucagucugccuuacuacc\n", + "aaaagcagcaucuguuauagcaaaauacccacacaaaauaaagaguggagcugaagcuaagaaauug\n", + "ccuggaguaggaacaaaaauugcugaaaagauugaugaguuuuuagcaacuggaaaauuacguaaacuggaaaag\n", + "gcucacagcuggauucaugcccaguaaapacaccugaauggaacugagucacuuuuagacuuaauaupauguu\n", + "guugauacccaaagaucaguauuacugugguguucucuauuucacupagugauauuuucaauaagaau\n", + "ucgcgccggagcupuugcuccugcucccgucuccaaguccugguaccuccuucaagcupagapcucuagucccugguucugaacacucupuucucpugcaggccgcc\n", + "agccugccugaccgcgcggaggaggapcpcgcggugccgccpcpaaggucgcpcggcugcuccggacugcagcucccgcggcgguggcggcguaucpacacggcgcp\n", + "uucguaguggaggaacpuuuggcgugupacgcagcugccucuguacupagucacggaguggccpcuccapac\n", + "aguggaggaacpuuuggcgugupacgcagcugccucuguacupagucacggaguggccpcuccapac\n", + "gacgguggccggcpucacgaggcuucguaguggaggaacpuuuggcgugupacgcagcugccucuguacupagucacggaguggccpcuccapac\n", + "acgaggcuucguaguggaggaacpuuuggcgugupacgcagcugccucuguacupagucacggaguggccpcuccapac\n", + "acagacccagccgccccggcucccccgccguccgcgucugcgccggccccpccuggucggcggcggcpccggucgauggcccpcggcggcggcggc\n", + "cggcucccccgccguccgcgucugcgccggccccpccuggucggcggcggcpccggucgauggcccpcggcggcggcggc\n", + "aucuugupaagagcugaagcaggcgcucuuggcucggcgcggcccgcugcaauccguggaggaacgcgccgccgagccaccauc\n", + "gaagacggccccccucucucggcccggccaucuugupaagagcugaagcaggcgcucuuggcucggcgcggcccgcugcaauccguggaggaacgcgccgccgagccaccauc\n", + "gcugaagcaggcgcucuuggcucggcgcggcccgcugcaauccguggaggaacgcgccgccgagccaccauc\n", + "cucucucggcccggccaucuugupaagagcugaagcaggcgcucuuggcucggcgcggcccgcugcaauccguggaggaacgcgccgccgagccaccauc\n", + "cucuccuucuuccccauuacccggaggccgaagcccccagccapcpcggcgcagcccgagcucccggacccggaagaagcgccaucucccgccuccacc\n", + "auucucucuucauuuugucagcaaacagcucacuguccucuggaucugcugcguccugcaggagcauugcgcuuaaacu\n", + "ccaggacuuguguucugauggaaggaccagccaacacccacacagccuuccuuuccuuggugugcag\n", + "cuucucccuuuuuuucggucgcaaguaggaagcuuuuugcacuccaccaccucuggccgcupaagacgucaucgcuuccgcccuacuuccuccuccuguuggcggcg\n", + "gcgaucuccggagaugugaagaappcgagcggacaggaagaugaapagcaaagcugcccgccgcpacaggcgucuaggugaacaagaaa\n", + "gappaaauuuugcaugaucgcauggagaauggauuuuguugcuuuaucugauauuguccucagcuccuccugaauuugccgagaucuuacagcagucaguaag\n", + "gucucugappaaauuuugcaugaucgcauggagaauggauuuuguugcuuuaucugauauuguccucagcuccuccugaauuugccgagaucuuacagcagucaguaag\n", + "agapagucaaaagugaggaacccaagccugagcacgupccagccccaupaaucugucuugucaucpcuggcuggaguagagacaagucuggaugcuggcuggccag\n", + "guagccgccccpaccgcccugcucaggcgccgupuucggcgcggcuacgugcagaauccgucuagcuaaaauguaauuucagauuggacaaguacu\n", + "aaaguuguacaapauugauuuaaaccaaauucgaggacuupuuugaugccacguguucucugguuguuuuggauaagcaguuucacccauuaccagucaaccaggaag\n", + "gucucucugcucccugguguguaaguggacauauucagcagagaaaggcupacgacaguuucuggaaa\n", + "caaggcpcuguagccgccccpaccgcccugcucaggcgccgupuucggcgcggcuacgugcagaauccgucuagcuaaaauguaauuucagauuggacaaguacu\n", + "augaucgcauggagaauggauuuuguugcuuuaucugauauuguccucagcuccuccugaauuugccgagaucuuacagcagucaguaag\n", + "gagugauupcagaugugagapcacggccucaucugugapcagccagugacgucacggcuggcugucaucuguggaacgucuucuugucac\n", + "gcacauccapcaguaccacacccugcaggcuggcuucagcucucgcucucapccugagupacaagaccucg\n", + "ccupugcaggagcaguggugccapucccagaagccagagapuuuuggaggccucuguapugapuccup\n", + "apagapccucgapacaggacgugaagauaguupuuuggaggcggccgccaggcccaggcccgguggaccugccgcc\n", + "auacaggucugugaagcaggcagguugcucagcugcccccggagcgguuccuccaccugaggcagacuccacgucggcuggc\n", + "accggcgcugcucggauccucccuuuucggagauuugaauuucccccagcgaggcgagugaggcgaaauacccguauggugauagcuggccuuuucgcgccaauacu\n", + "agucccagcccaapuagcuggaggcgcgcaggccggcuccgcuccggccccggacgaugcggcgcgcccagg\n", + "aguugaaaguuucucaacucuucagccacaaucucuuacuacaggagcaaauugccaauucugcuccagupagaaaacaag\n", + "gguugccuccgaccucggcgcupcpcgcgccpccupaapcpcgcpacccgaugcgcpagcggaggccgag\n", + "gccuccgaccucggcgcupcpcgcgccpccupaapcpcgcpacccgaugcgcpagcggaggccgag\n", + "ggaucggcuucgucacugagaccucaggccucugccagccacucccccuccccauaccccuagucauccucggcaggucucagucccggcuccaucugugcccucgccccagccgcagcu\n", + "gaaccuuuaacugaccagagugcucauuaaacgaugagaaguauucuuugucauagaaugauuuguuuguccaaguugaacuaaacaagagaaaguaaag\n", + "accauucugcacuacuucugcuccaagaauccaccacuaucuugguuccugagagauuaaggaugauguuuucuguuguauaaugaacagcaguauuauuugaacaaag\n", + "auguacagaucagcucucaaaaugucuucugugucuucugagcgucuucuaagacaauugcauuagccuccugcuaguugacuaauagaauuaauaauuguaaaaagcacucuaaagccac\n", + "aauucucuccuaccpcgcagcggaggagcuggaggugguuggacccgapccgccgccgccgccgccacugcaaguuuucupcucgugacaagcpcgcagacuaggcaccagc\n", + "aaacuucaaguggcuuccugcuuucuccaagugguccagccucaucaacupauucaagauucugucuuauuaaccuuggcaaccacgucuuccau\n", + "ggagcuggaggugguuggacccgapccgccgccgccgccgccacugcaaguuuucupcucgugacaagcpcgcagacuaggcaccagc\n", + "gaugugcgccpaapaccagagagccaggcuccpaggcgcaggcaccuacpccgaucccugguccgugccucgcgccgcgcccccgccggagcucggcugupaggagaaugug\n", + "agucauuagcagacaacccuuuugcaacaaaguaugcuuuaaaauguaaacuguggagccauuuuccuugcguuguccagaaggaacuucguccugcgugagccuggauuaauc\n", + "gcugacacaaacagucauuagcagacaacccuuuugcaacaaaguaugcuuuaaaauguaaacuguggagccauuuuccuugcguuguccagaaggaacuucguccugcgugagccuggauuaauc\n", + "cupcacaggccccacccuccuauacggcuccacacauacaacgcupccacgccccuagaccauugcaupccccgcccccgcacuccaagccccgccccag\n", + "ggccuggaguuguggagucggauaucgcagcucccgacugagcugcgccugcgcaacucauuggcgccaag\n", + "guaaaagauaccugcuuucuucagccuauguagacagccacaaaupaagcaagagaaaaagaacauuacugucuug\n", + "aauaaauaaauaaaagucacccaaggcpapauguuccugaagacgaacgucgccccaucugapagcacuacagccccaag\n", + "ccggcgcuuuugcaguugcuucugcggaaaggugguaguuaagaauuuguaaaggccagagaacuaccuacgauucucucagcpuaauuggcugcuccuag\n", + "cuuuucucugcacggagccggcgcuuuugcaguugcuucugcggaaaggugguaguuaagaauuuguaaaggccagagaacuaccuacgauucucucagcgg\n", + "cgcuuuugcaguugcuucugcggaaaggugguaguuaagaauuuguaaaggccagagaacuaccuacgauucucucagcgg\n", + "ggcuuuacuauggcgguuggaggaacggcagugaucacacgucggcugcupaagaucuggauucucguuucag\n", + "gucaccaucagaaaagcuaaguuugcuguauagugaggaucaggagaucugauccugauugcagaaccuucccugauuacagaaucuugg\n", + "auaccugccuuucuuucuagguuguaucucccacuucacccuucuagaccaucccagaagaucuauaagauuucaucupaaaucacuaggaguucuuggaapaaagaaggaagauugu\n", + "gaacuuucuggaaaauuaacagugcguauuugccugaagaaggucagugugcuugcuuggagaucaggacgcaaag\n", + "guuguaucucccacuucacccuucuagaccaucccagaagaucuauaagauuucaucupaaaucacuaggaguucuuggaapaaagaaggaagauugu\n", + "accuggcuuuacuauggcgguuggaggaacggcagugaucacacgucggcugcupaagaucuggauucucguuucag\n", + "acuauggcgguuggaggaacggcagugaucacacgucggcugcupaagaucuggauucucguuucag\n", + "acaagccggcggccagagccccagaccacacagaccgugcgcuccuccgcccucccggcgccgccggccucgccc\n", + "guucggcuucccguugccgccucpcgcuguacccagagcucgaagaggagcagcgcggccgcgcggacccggcaaggcupccggacucpcucccgapacgcc\n", + "gcgcucaggcgccugcgcuuuagcugcuaacucgcucuaguagcuguggucpcucpaccggcugccaucuuagucuapacugaggagucgccgccgccccgagucccg\n", + "agcuguggucpcucpaccggcugccaucuuagucuapacugaggagucgccgccgccccgagucccg\n", + "guuuuccaaccuauuggugguaugucugacaguggaucacaacuugguucaaupuagccucaccaugaaaucacagcuucagaucacug\n", + "uaucguuaccccugugaguaaauuacauuuucguguguggagucaccagacacugaaaucugauguuuuguupaacugcugcauuagauauuuaugaaacauuaaagucaaacaau\n", + "aguagcuguggucpcucpaccggcugccaucuuagucuapacugaggagucgccgccgccccgagucccg\n", + "guggucpcucpaccggcugccaucuuagucuapacugaggagucgccgccgccccgagucccg\n", + "ggucpcucpaccggcugccaucuuagucuapacugaggagucgccgccgccccgagucccg\n", + "gaaucuggaaacuguucuucaggaagaaacccauuaguuuggaacuggagaauuccuuugcaucagauacuaaa\n", + "gauuuauaccaucagcuccccugcuucucagaccuuuagacucaaauugaauuacaccacugguuucccupucuccagcuugcagacagcagauugupacuucuucgccuccauaucau\n", + "acacagucucacucugucacccaggcuggagugcaguggcucaauguccauucacugcgaccuccaccucccagguucaagcgauucucgugccucagccucccgaguagcupauuacag\n", + "ggucuuuguagguuucuaaaauuaucuugccauguuucauuagaugucagugcagaaacauaauuugguuuaguuuuguauuuauucuuugugugucc\n", + "agacgcucggapagcccggccggcucggacupcggccpapapcgccccpucacgacggcgcccgcaagccgagcgcggccpacgugcacc\n", + "cucgcgupagapccgcgucuguggaggagcuuggcuccgcaccugcupcuggcgaacccgaaauupcuuggaacccpagccagaucuuggacccugaacugcaccucugucaag\n", + "cucugcauucuccagacucugugcuuuccuaagauaggaacccagaagaggacugaucauuucuugcagcucuaaaaacc\n", + "acuugccuucaaggugugcaaguaaggacuuaucuccagaaaagaacacuuaugaaacagaauuaucccaaupaa\n", + "uacugucuucugugcuapaucacuuccuuguugagupccugaguuuuaagaggaucuucugcuccucuucaucuggucccuuuccuuccaaggccccagagaggaaggc\n", + "gcagucugucucccgccguccccacgcacgcgucccggcucacgcguccccccgcccgcccgcccgcccgcccgcccccgcuugugccgccccuaccagagacccccaggagcagg\n", + "agagcguucgcucggagauggcggagcagccgcgacgcggcccguggccccgaaagcapaagccpcagccccpacgcggcggagcccpacagcpacgccgcccaguccuccgg\n", + "guaugaagcuaaaaugcagcggcuaagaacgcggcucuggagcuugacaggccugacgucgaaucccagcccucccaccaacugagcugugugauccupcaag\n", + "guaaggauggcaugaaguucacaaupagcaugauaaacuagauaaacuucagcugcaagaaagacucag\n", + "agucgcuccggaggaggcgugaaucgcgcapauugacuaauuupuppugcggupcg\n", + "gaaguagauagcaauacucacccagacagaagagaccacgguaaagaucagcugacggccucugupaacaaagacapaaapaaaugaguucaccagaaaccaacaggcagcacaggag\n", + "caugcguggaguggcagugcuaacggcuggugucucgcacuguuggccugugaagguacgugaagcugaaagccugga\n", + "agacccagaaaucccuggagcgcggcggacccggcggccggapcgaccccgcccgauguaacgcgccccgcccgagccccggccccugcacpp\n", + "gcagacccagaaaucccuggagcgcggcggacccggcggccggapcgaccccgcccgauguaacgcgccccgcccgagccccggccccugcacpp\n", + "cagcgaaacuucucugcpuucuggcgcupcaccgaccccgcaacgacugcccpcugcpapaggagagcagagaacguccccag\n", + "agaggagaaaagcgcauggcccggcuagcagugagccucucaaaagcagcapaagcccaagccacaag\n", + "puugugguugaggccpucuccgcuccugugcccpaagauggugcuaggugguugcccg\n", + "aguucuupucugugcugcuggccupuugugguugaggccpucuccgcuccugugcccpaag\n", + "aguucuupucugugcugcuggccupuugugguugaggccpucuccgcuccugugcccpaagauggugcuaggugguugcccg\n", + "gaccaggaaugaaaguuacupagauaacuucgaaggauuuugcaacaaauucgagcuguccgacucugagaaug\n", + "uuuuuuuaaagaaaaagacgacuuucaccuuucacuauguugcucuugaaccaggaccaggaaugaaaguuacupagauaacuucgaaggauuuugcaacaaauucgagcuguccgacucugaga\n", + "ugcagcagccpupaaggcucaagauggcgugcuuguuggagaccccaauccgcaugagcguccuuucg\n", + "cggugccuagcguuggccaauaguuggcugucgaaagugccggcccccgcgccggcgccugcagcagccpupaaggcucaag\n", + "gaccaggaaugaaaguuacupagauaacuucgaaggauuuugcaacaaauucgagcuguccgacucugaga\n", + "gcagcagccpupaaggcucaagauggcgugcuuguuggagaccccaauccgcaugagcguccuuucg\n", + "gupcucgaggccgacgcgaccaucguuugucgacgccgcugccaccgccugccugagagaagucgucgcggccgaccccgucgccuccgccggcuacc\n", + "guucaguguaucuuugccugccuacaucaaucugcaapaguugcagaaagccucauguucaucgagcc\n", + "gagacgaaaccagacagapucaaguuuacagaugaccgugucugcaagagucaccuucuggacugcugcccccaugacauccuggcupacg\n", + "aaagagccgagupcucgaggccgacgcgaccaucguuugucgacgccgcugccaccgccugccugagagaagucgucgcggccgaccccgucgccuccgccggcuacc\n", + "ucccccgcggcpaaagagccgagupcucgaggccgacgcgaccaucguuugucgacgccgcugccaccgccugccugagagaagucgucgcggccgaccccgucgccuccgccggcuacc\n", + "gaaagagccgagupcucgaggccgacgcgaccaucguuugucgacgccgcugccaccgccugccugagagaagucgucgcggccgaccccgucgccuccgccggcuacc\n", + "cucgaggccgacgcgaccaucguuugucgacgccgcugccaccgccugccugagagaagucgucgcggccgaccccgucgccuccgccggcuacc\n", + "cgcauggauuuaggagaauguaccaaaauccacgacuuggcccuccgagcagauuaugagauugcaaguaaagaaagagaccuguuuuuugaauuagau\n", + "uaggucagaccucguccugcccggcacggccpacuucagccugagcgccagccugucggccuguacgcugcucuacgag\n", + "agcgacggcuucgcugccccggaaguggacggcacgccgcggcpupugcaagaugccgcugccgguucagguguuuaacuugcag\n", + "caguaggucagaccucguccugcccggcacggccpacuucagccugagcgccagccugucggccuguacgcugcucuacgag\n", + "gcuaacgcucuuucucccuucagcagccagccagcucugugucapucppugcagaaagucaggacaga\n", + "aaguggacggcacgccgcggcpupugcaagaugccgcugccgguucagguguuuaacuugcag\n", + "cuuucucccuucagcagccagccagcucugugucapucppugcagaaagucaggacaga\n", + "acuuccggucccgccgccpagccggugcggcugugapccgcgucucgcagcagccgcccggaccpcaugguguupcgccpcccgccucgccugucucpagcccag\n", + "gugcggcugugapccgcgucucgcagcagccgcccggaccpcaugguguupcgccpcccgccucgccugucucpagcccag\n", + "ccggucccgccgccpagccggugcggcugugapccgcgucucgcagcagccgcccggaccpcaugguguupcgccpcccgccucgccugucucpagcccag\n", + "guuaccgaaaugcugccuuagagcguaauuugcaggaaagaggaaguuuuguuuuaaaccagaucuucaagaguugaagcauauugaagaaggaaaagaauucugaagcaacugcag\n", + "gccgccpagccggugcggcugugapccgcgucucgcagcagccgcccggaccpcaugguguupcgccpcccgccucgccugucucpagcccag\n", + "gucucgcagcagccgcccggaccpcaugguguupcgccpcccgccucgccugucucpagcccag\n", + "aaaggccagcugguggaggucgaggaucucpaaggaacagcugguuuaggapacgacuggccupuaguupaggcuggauucaggauugaccuggagcccuggcuu\n", + "aaguaagauggcggcgaacgcacuuccggcguguguccuuacpugcguccpcggcugcuugcaggugccacccagcpuuccagcuuguuugcugcauagauuacaacggug\n", + "agcacaaagcacuggcucuggagcuuuaugaaagcuucaagcggaagcccugagagcucuggcuguga\n", + "agaaucacaagauuucugcagcacaaagcacuggcucuggagcuuuaugaaagcuucaagcggaagcccugagagcucuggcuguga\n", + "ggucagcgucgcugccggucuccggcggagacggacucuggaguuupcggcccpcggccacuagguacucugauauuccguacuaaacacgucugcaagucaag\n", + "ggcacauccacacaugapaaaaacacugccaggacaucucapcacucucaggaaaugaggaagcugcuggagaaguuucuagccuupag\n", + "gcagaguggcuccucacagccugaagcucauccuucugcacpccagccaggccagcacagaggcaccapcagcagugcacacagguccccpaccccacc\n", + "gugccucuccuggcaggcagaguggcuccucacagccugaagcucauccuucugcacpccagccaggccagcacagaggcaccapcagcagugcacacagguccccpaccccacc\n", + "agcccagcugugagccuggcgupagcugccuaggccpcccugccapagcaagucugcaucgcagaggccagg\n", + "gcucgcgcgugcgcaccagaagccagcagupuugcacacgcgccucuucacgagguggaaacaag\n", + "guuagaaaggcaguggacgcucucuugacgcauugcaaguccaggaaaaacaauuaupuugcuuuugaaugagaaugaaaguuuauuuuua\n", + "cuuuguaguuuaucauucuuupcugcgguugucaaggauucagagcagaugugaucugcgcuagguggcaucuccucucacggaugccucg\n", + "aucucpuuuccagaagaaaagaucaapagaauuaucaagaauagauuauuuuucugaauaguuaaaccuuug\n", + "aucauucuuupcugcgguugucaaggauucagagcagaugugaucugcgcuagguggcaucuccucucacggaugccucg\n", + "cguuccaggucgccaucuuggaccaugagucaagauggcgcccccuggucccapcacagcccaggcacgcuagcgaggcuacgcacgcacguauucgg\n", + "cuucpcucagaaucagguucugaaaaaagguguuguggaugaacaagcaaauucugcagcuuuaaag\n", + "agaguaggcuggcagcuguccuaacugccuacuaaagccaaaugcuugaggagagagagagaguaaggagccagcc\n", + "acaaucuguggcuccaacuauccacugagcauugccuucauuguggugaaugaauucugcgagcgcuuuuccuauuaugga\n", + "aagaggcgaggcggugccuccpcpccuccuucgguuggcggccucpcuucpaguccuccaagaggccag\n", + "gacacuuuacuucggccgaagacuuaaaccuguugauugccaaaaacacgagauuagagaucuauguggucaccgccgapcuucggcccgucaaagaggupc\n", + "agccagaagapuuuapaccagugcuaucccugguuucaguggccugaaaggauggaaaaggaaaggaagucaagugaggccuccaggacucugcuugaucaacaccacacaaccacuggag\n", + "gcuguupccaccugucuuuucgcuugugucccucuuucuagugucgcgcucgagucccgacpccgcuccaagccucgac\n", + "ggaguucgcugcgcgcuguupccaccugucuuuucgcuugugucccucuuucuagugucgcgcucgagucccgacpccgcuccaagccucgac\n", + "gcaccuuccggcucagcuccuccguggcugccguggucggcuggccpcggcuaggaguucccggaagugcccgcgcagccgguuuccggugcaggupaaa\n", + "ugagaacucaggcuggcacapauucccapcaucuaccaccacgcagcuggagcapcugagcccaggagc\n", + "aacuguggacaacggaaggcugagccccauccauugaguuccupccccacuggapcugcuguggccapugcacg\n", + "guupacagcgucuucgcugcugcuggauagucguguuuucpaucgaggauacucaccagaaaccgaaa\n", + "ggucugucaccgcuggaagaggcugguggacgaccgguggcuguggcgacaugucgaccugacgcucuacacg\n", + "gucccuggagccupaagacggupugaccagagaguccugucuauccuaggaggagaacauucagcccaaaucccagccccauc\n", + "ggupugaccagagaguccugucuauccuaggaggagaacauucagcccaaaucccagccccauc\n", + "aucuuuccgucccpcagccagcgccagucggagccagcgcgagccgccgccgccaucacugccgcugccaaguccuccacccgcugcccccgcc\n", + "cucucucucucgauuuuuccacagaguacgcacgcucugauuguuucgauucuuccaaaaucaga\n", + "cucuuucgauucuuccauacucaagaguacgcacggucugauuuucucuuuggauucuuccaaaaucaga\n", + "cucucucuuucgauucuuccauacucaagaguacgcacggucugauuuucucuuuggauucuuccaaaaucaga\n", + "uuuuuuuaagugccuuaaugaucuucaccguuaauuuggauucagaugapugguagaauaaaguaccpauuuguaguauuaaaacacgguugugcuuaacuaag\n", + "gcgcgauuagupaggucucgcggcuucuggcuacuugguggcgaggugaagagcuucugcag\n", + "guuggcccaggcaggacpcagccgagagcacucpccgcgucgccaggagccgcccapugagcc\n", + "accacgcccuccacguguuccacugccucuucucuucucgcuupaacuccagucucaccucggcuugca\n", + "gguccccpapccgguccgcuccucccggacgccgaggaccuaccaccgcgacuucgccccgcccggcgcpcccag\n", + "gccgcuuccggcccacccucuugcccgguccccpapccgguccgcuccucccggacgccgaggaccuaccaccgcgacuucgccccgcccggcgcpcccag\n", + "gcgccagccccgccugcccuuccucgccaccpcugcucuggucucgucgguccccuccuccgccccgucguccugacucucucucccuccuuuccucagagg\n", + "agcacuucuuucaguacauuuuccuguuagacucpuauuagagacccaaagauacccaaggaggagugagagcgucccugccuucgaggagcagacapcaccgcgagg\n", + "gugcupauuauaggugugagccaucgcacccggcccacacacacacccccccuuuaaugguggaguugccaacaguuguccg\n", + "cagcccgccgcccgguugccauggcgacgccgucgcgccacggcccgcagaaccggccaagcgacccpcgcggcgcpaggcugaapacgcucpuaggcaag\n", + "agcgaugcuuggcucagugaagaucugcpucaugcugucccuaaugcgcugauugcauuaaguggauucuggcugcag\n", + "gaccagccccuuccuucccgucaaggagcgcgcuugccuguguaacucaccuguaaagcccacccapaaggccapccuc\n", + "gaaugugcucgcccugugucugaaaugccccauguccgguggugccagcacuagcccccaugucggucucagagaaccuucuccccaccucugag\n", + "uuauucucucaguguaucgaagauaucagucaacuaucuucuggauugcauugaugcuauugagaaggcagccugcagucuaaaaguc\n", + "gaggcaagccccgugugauuguugaggaggaguuagcccauugccagccugugacgugacugacucgaaugaacccug\n", + "cpcccgguagcupcccgcguccgccgcccgcauccccgcgccgccgcaucuccucgccgccucccpcuucggacccccggucucgcccccgaaac\n", + "guuucaccgagcugcccuacuccuuguaccccuucuagcuggccuuagcauagcuacgucagcagcuauuggcacgacugcccugauucaaggagaaacuggacuaauaucacuaucucaacag\n", + "aggaaaccguupupccaggagagcguupupccaggaaaccgucuggupaucuccgcagcugcuuuucaccugcuguuccuccugcgcuuccuaagaggaagaauca\n", + "gccucuccuuauaaguuuucacaggcuguaggacuugccugguuccuccucugcuagauugauuuuugaauugacuuuaucagagcacagaccuuagcupacagcccucacuggcuuccag\n", + "acagucguuccgccaccucccagucpuugcggcggaggccguuccuggcuuuguagcucgcucaag\n", + "cgguccuccuuucgcagauuggaaaccgcpcuauccugcupagguuguggccgaggcaguagcucgcuacug\n", + "ggaggugaaccagaauggagagaupcgugaugagugcapauuguguapacggacccacaaaauuaucaacaccauacggagucacag\n", + "aguugacagcaaguaggapcccuauggaaggagaaaaaaagacaacacgagaaaaauuaguauuuucuaccuucugaaauua\n", + "gcggcgcgcucugcagacuccpucgccgcuccgccpacgcguuggccpcgcgcggugcuuggcugcggugcucacacuc\n", + "gugcagugcggucuucagcgcgcuugaaagcacgaaguuguucggcagccagguuggccucugcccaggaaguugcugguuccacgucugccaagacagcaugucug\n", + "agacuccpucgccgcuccgccpacgcguuggccpcgcgcggugcuuggcugcggugcucacacuc\n", + "gcagacuccpucgccgcuccgccpacgcguuggccpcgcgcggugcuuggcugcggugcucacacuc\n", + "pucgccgcuccgccpacgcguuggccpcgcgcggugcuuggcugcggugcucacacuc\n", + "gccgccgcggcgcgcucugcagacuccpucgccgcuccgccpacgcguuggccpcgcgcggugcuuggcugcggugcucacacuc\n", + "ugcccccacucccaacucccgccccaagccgcccaccagcccccuuccccuccggccggagccugaaccgagcccggcuggcugugcugcgcggugccgccpaaag\n", + "acagccgcugcugccgcagcaucggcaucgcagacgcgcucpcggcpuccgaggccggcgugcgcggaggcupcpcagcccgagcgguggccgcagcgcag\n", + "gaacuccaggcagaaccugagaacugacaggcaggugugcapcacaugugcapcaccgcuggagguucccuucucaag\n", + "caucggcaucgcagacgcgcucpcggcpuccgaggccggcgugcgcggaggcupcpcagcccgagcgguggccgcagcgcag\n", + "ggcggugccpcpuugucpugucaupcgguggcgacggcaccgcccccgcgucucccugagcpacggcappcuucugcgcugagccpcg\n", + "aagaagaauugacuuccuucucugcagagccggcucuggucucuucucuugaagcagaugcgaag\n", + "gcuccccgaaugagaaagaauacucggaaucagcggugaauugcagugaucuuucagagaaagcgccuguucaacuuuguccucucucag\n", + "agacucagagccuupcacugapaugccaguucugccuguucaucuggaaccuggaucuaaggapaagaggcguugccccugcuggcauagucagguaccagcccagccag\n", + "cauuaaapcaguauuuaaagucaguuggcaagcaguggaauaagauuuuuguaaagaaaccuugugcagc\n", + "acucagcugugcgcucugauuucgugcgcuuccucguccuucauguuggauggccaguuuuucguuugugcgucauccucuaccugagaaauggucgcuugccccuagucuagacacg\n", + "gcucugauuucgugcgcuuccucguccuucauguuggauggccaguuuuucguuugugcgucauccucuaccugagaaauggucgcuugccccuagucuagacacg\n", + "gcauccugcuguggaggaucagaggaaggaagaaacugagaauaagcuagaaaaaucaucuggucaacug\n", + "guuuagcuccupaaaugaugagauugaugauucuuucuccuggaaaaccuuucaucacagagauucaucucag\n", + "aaggaaagaccaagaugcagagagaugucuaaaaggugccagaaggugacuauccagcccugguaucacugccuggugauuucguuucuuugaucuucacgaauggccucacugg\n", + "paccaagagcggaagupugugacpacpcccggupcccgcggaggaaagauacupagupagccgcpuucagagcg\n", + "gacaaacaggauucgucaaaagagagguguauuaaagugccgaucaaauguaauuuaacagcuaaacuuucccuccuuggaaaacag\n", + "aacaguuuguaugcuggaagaguucugaaaagaucucugapcuggaagugcuaaggacaauuucauaaagaag\n", + "gaaaaacuacaaauauguaucuuucugcaagccuuuccagaucgaucugccucauuccaggauggccag\n", + "gauccupcuguucaaaccagagagcuguaagucuagaacaggaaaaggaaggaaaggcuaaaucauucauaccauaaaaua\n", + "cucagcaagcccgauuuaaaacuuuuaacaagaaagaagaggcpuggaucaccuuaagucaggaguucpaccagccuggccaauacg\n", + "agaagccucucuccugcaauuaaaggagucpucucuaacuguugaucuguuuuuuucccuucugagca\n", + "augcggacagaagcugaggcccagaaaapaagucuuauguccaaagucacacaaggagcagcugagcupacaacuccccugguuuccauuuccuucaccguaaa\n", + "ccaggaagcaggcgcugcapacggaapucggagcccacagccpaggccaaggagcupcggaggcacuccaggccagcccpagaa\n", + "acucgcapagcucacuccucggcggugccgcagcccuguccggacuccacugcgccucugapcucaaauacgaauucaag\n", + "ccaggcguaguggcaugcuucuguagucccagcuaucugapaagagaguuccaggcagapcacagcccguacgaaggccccaaggaaggacugcaccug\n", + "ugcuguggagcaugguuucugcacaccuggaaugacuggaaccccaaagacucaagaaggagcuaaagaucuugaaguagacaugaauaaaacagaag\n", + "gcuguggaccaccugucgagauggagaaguccuucugaggcuauccaaacacggaccaggccaugagaccccg\n", + "gaagaagaaaacaccugagugaccagaugucccagcuccaggugccuugccagauggccagaaccacaccucuugaagagugacag\n", + "caagacucccgucucaaaaaacgaaagaaaagaaagaaaccacucccagacucccugccupcpauccuuugaucaagcccucaacaugccuupcucucuucacaaug\n", + "pcuccgcuggcugcggucgccupagcugccgccapccaggapagcggcaccuggaag\n", + "cuuccugacccapcuccgcuggcugcggucgccupagcugccgccapccaggapagcggcaccuggaag\n", + "acuccgccuuccacgugcacccacugccucuucccuucucgcuupaacucuagucucgccucpuugca\n", + "ggcacagugacuuuugaagacguggcugugaaauuuacccaggaggaauggaaucuccuuagugaggcucagagaugccuguaccgugaugugacucuggagaaccuggcacuuauguccucccugg\n", + "aaugaacccagaagguggagaggaaccguucucggugcacagaggcggcucugcagcccggugapcgccugcugcucccpcagugcuuuccccaaguaguccg\n", + "gguuccagcgacagcagcacuggacucguccagapcggcpugagcggcupccccguggagccacc\n", + "pugugcapuuccagcgacagcagcacuggacucguccagapcggcpugagcggcupccccguggagccacc\n", + "cuguuugcaaggccucccagagagcpccaaupcggcagaugcuggcuapcuuuggucucuapugccp\n", + "auucuuggugccaccauugagaacuccaggauuguccugcagaucgacaaugcccgucuggcugcagaugacuuccgaaccaa\n", + "caggauccuaaggccuuuguaguccuucagccacugupcccugccucugccuguucuucuggaaugucuupuuuugauccugucacugug\n", + "agucuugcucugucgcccaggcuggagugcaguggcacgaucucagcucauugcaaccucugucucccagguucaagcgauucuccugccucagccucuggaguagcupauuacag\n", + "cgcgcgcugucccccggaggcgucupugugcggagcgcgcgcgcgcgcggcucggaggcgcaccugugaggugucccugaggagapag\n", + "gauccuaaggccuuuguaguccuucagccacugupcccugccucugccuguucuucuggaaugucuupuuuugauccugucacugug\n", + "cugguuccguaacaacaucccguuggcuucccucaggcggcpaccagugcagccgccgccucccaggaucguccgccggucapcccuugcccuccccggcacaggccacc\n", + "aguacuaugacucucuucuccuuagucccaccuauuuuuucuuuuuucuuuuuugaagcuucucaaguugagagaaauuugugccuuugaacucc\n", + "guggcucccgucgucuggccaagucucagcgcagcgcaccggccggcgucucguuggccuggagcccacacccaccpucccugaccccgcgccccccgcgcccgguucccggc\n", + "gcuuuggaggccgcgugaccagcggcpucacgugacgcggugccuggcgccgagccucccaagauggcggugugcaucgcggugauugccaaggag\n", + "uuaacuuuccpccaggcauugauucaugaagapugagguguuccagacagacagacucggagucuaggugguucggcuccuggagugugaacugg\n", + "guugccacauuucuccaaagugapcccacagapcccuccaccggcagucccuguguuacgagugccuucccuaaccagcugugcagauacggcuacgucaccaacuccaaggugaaguuuguc\n", + "gcuuuggaggccgcgugaccagcggcpucacgugacgcggugccuggcgccgagccucccaag\n", + "gauucgucuaguuaaacccugguguuccugacacaaacuucaggaaaggauuuugcacuugugcagaccpcgagcagaguaagaagcag\n", + "gugaagucuggagcaggacuucugaggcuuucuauccuccaugcugcucacuagaaaapcugugaacu\n", + "gugcuuuggcucuagcagacaggaagaaauucuggcccagcuggaaguagaaagapagugagucuccugaggaccaucucagaggccccpaucacccgaaca\n", + "auugcaucuacagacagucagagugcccgcaagaaaucaggcaaugagcguaaaaacaacagacucgauccaccccgcucgaccagaucuugaupaaccuaugcucgaagg\n", + "uaugccaugauaapcuggaucuguuauggugagauupccccaacuccaaaggaccuugcccaggauuuu\n", + "gcupaggaagcccaggucacacpaggcuacaugcapucuccauucacagucccagcugagcccagguuuupcccuccugccuaggagccacacuu\n", + "aaaauagacaapaaguaucuugaauuucauauuucagaagcgcaucaugcauguuuuagcuuucuuucuucccgagaggauuaaauauucauggaaauuccuacaagaau\n", + "guuccuaucccagguuaucccucagcuuuaagcuuaagagaaacauuggcuacuuuauccugcaaacauac\n", + "acauuagaauuacugcacupcagacuaaguuggaucuccucucuucagugaaacccucaauuccaucaaaaacuaaap\n", + "gaguccccupcgcpaapaagaagaggacgagguggcgcggagaccgcpagaacacagugccuccggag\n", + "guccccccguggcugupaugaacauugacauugccagcaucgauaugguuucugaagucaauaug\n", + "gagugcgcggcggccggaccpcpcggagccpcccgcpcugcugcpcgaucpccpccgcugccgcgccaug\n", + "gacucccguguccagccugaguuccagccucacugaguggccacccccaaagugcugccagccgaggaagcccccagcacugacc\n", + "acuucgucuuuagcuccuggcgcugcuggcuucupcgguuuuugucuuuugauuucaagaguuaggagcucgagaaccguuuggcaauauguacgacgcggaugagg\n", + "acuucgucuuuagcuccuggcgcugcuggcuucupcgguuuuugucuuuugauuucaagaguuaggagcucgagaaccguuuggcaau\n", + "auaugcaauaugaugaggaugaugaugaaaucaccccggauuuguggcaagaagcaugcuggauuguaaucag\n", + "ccacgauauuugcugaaguuugaacaaauuuaucuuuccaagccuacccauupaaagagauggugcuccuucacca\n", + "cucgcgauuuaagcucugagacugagaaccuacuuaaagcuauggcaaaggcacuggaggauugagcuag\n", + "acugagaaccuacuuaaagcuauggcaaaggcacuggaggauugagcuaggupcagaaaagagca\n", + "pugaaucuggapccpccgagcccpcgcuuucgcacgcgaagcaaccgcuagagcaggaccuggucucccgagag\n", + "cpacuacuuguugauauuugaggapaagugucuuaccugagagccuggcuggagaagacugagguccaaggcuugaagccuaagugauugccccaggacugugg\n", + "guucucggugccccacpcuugagccpugaaucuggapccpccgagcccpcgcuuucgcacgcgaagcaaccgcuagagcaggaccuggucucccgagag\n", + "ccauuguucucggugccccacpcuugagccpugaaucuggapccpccgagcccpcgcuuucgcacgcgaagcaaccgcuagagcaggaccuggucucccgagag\n", + "cucucccguccauuguucucggugccccacpcuugagccpugaaucuggapccpccgagcccpcgcuuucgcacgcgaagcaaccgcuagagcaggaccuggucucccgagag\n", + "auuguucucggugccccacpcuugagccpugaaucuggapccpccgagcccpcgcuuucgcacgcgaagcaaccgcuagagcaggaccuggucucccgagag\n", + "guccauuguucucggugccccacpcuugagccpugaaucuggapccpccgagcccpcgcuuucgcacgcgaagcaaccgcuagagcaggaccuggucucccgagag\n", + "ccggccacagguuuccgcuugccucuggccpucggcaacugcaggcgucaguuucccucaag\n", + "gucgucccugucucuccgaccggccacagguuuccgcuugccucuggccpucggcaacugcaggcgucaguuucccucaag\n", + "aaaagugucgucccugucucuccgaccggccacagguuuccgcuugccucuggccpucggcaacugcaggcgucaguuucccucaag\n", + "agugccucagcgguapccpaagugucuguagcgucccucccucucaaccacaauaacaggcggapucggcguag\n", + "augcgagcggcggcggaagcggaagugccucagcgguapccpaagugucuguagcgucccucccucucaaccacaauaacaggcggapucggcguag\n", + "agguacuuugaacucaaguaaacaaaapaagauuuucucguugauacuggagacugcacaaca\n", + "guggagaagccgaggccuggagapcaccuggcaaguuguugacupccupcucuggagacagacagccuggauugcuggccug\n", + "gcapcggugcgcpaapaccccggacccggaggucgcggagagcupcaguguuggccgcuggcggagcgcupcagc\n", + "gacaacgccauccccagcacacauccaccupcagccagaaagcacugguuugcaggaacugapcugcagcucugaaacapacccaggccag\n", + "aapaccccggacccggaggucgcggagagcupcaguguuggccgcuggcggagcgcupcagc\n", + "cgcgagagcucccpccguupuagcgucuucgcuguugcccuuapacggcugupccugcupupcccgaagcgccagag\n", + "gagagcucccpccguupuagcgucuucgcuguugcccuuapacggcugupccugcupupcccgaagcgccagag\n", + "aaacugucacugcgcuaguaggagugugaggaugaccagaggucacucucaucaccaucuugguuuug\n", + "agagcapccugacaucuccccagaacagacguuugaacagagcaggcuucugaggucuccaaa\n", + "agagucgcacuaggaguugcagcggccgcagccccpagcuucccgcucgcggagacccagacggcugcaggagcccpcagccucpucagcggcacc\n", + "paaggcggagcuuggacgagccgagaggcpcucaaaguuccuacccgcgagapaagaagcagguaag\n", + "pcacacagguggacpaaggcggagcuuggacgagccgagaggcpcucaaaguuccuacccgcgagapaagaagcag\n", + "upcacacagguggacpaaggcggagcuuggacgagccgagaggcpcucaaaguuccuacccgcgagapaagaagcag\n", + "ggcacacagguggacpaaggcggagcuuggacgagccgagaggcpcucaaaguuccuacccgcgagapaagaagcag\n", + "cpcaggcucuggaucucggcpaucaggccaggcagcugaucauagaucuggagacucgapagucaggcucuuccuuuguucaucuccugcuuagaggacacaggccaggac\n", + "ggucuugcucugucacccaggcugaagugcaguggugcuaucacagcucacugcagccuuaucuccupcucgagccauccucuupagccucagccuccugaguagcupacuacag\n", + "aaacccagccccaccuccugccgucugcccucccpccugaaapacacgguguccgagucuuuaggucugcgcpagccgaggcugcgcaccup\n", + "cugcgcauguguaaacccagccccaccuccugccgucugcccucccpccugaaapacacgguguccgagucuuuaggucugcgcpagccgaggcugcgcaccup\n", + "gacgugacuguggaauucacccpaggaguggcagcaccupcccugucgagaggacgcuguacagagaugug\n", + "aacccagccccaccuccugccgucugcccucccpccugaaapacacgguguccgagucuuuaggucugcgcpagccgaggcugcgcaccup\n", + "acccuagaggcccaggccccccaacggcugaccccugcacacuccacccuggccccccagccaguccagca\n", + "gcgcccagacaccaugucacaacccuccagaacugacguuggcaggaaguagagacuuuguugccugugucccccauccucacc\n", + "auggcguccuuugcagcaaaccguaaguuauaaggaugapaagaagaguagapccaaaaggauuccauuuugaggaaaaacuacaguuugccuugccagguagaagaaucag\n", + "ugcccagacuggucuugaacuccupcucaagcgauccucccaaagcccugagauuacaggcgugagccagcgcgccggacacaaccuccuacuuucaugaaagagupcacuuccaacaggagga\n", + "gcccgccccupacccuccpccpcgguuuggccccuuagcgcccpcgucpcgguaaaaggccggcagaapaggcacuugag\n", + "cucagcccgucgguucccgagcgccuucccggugaccccgcagupugugugapaggacggacagacccagacgccgccggaccaggaggacgcugacgaggcacc\n", + "gccgucccugccauuagcgcguaacgagagacugcuugcugcggcagagacgccagaggugcagcuccagcagca\n", + "ugacacagagaacacuggacagagagagccaagccgaguacaacaucaccaucacugucaccgac\n", + "ggcggcggccgcggcggcugcugcugcugcagupacagguggcggcgaccggcggcguccgaggag\n", + "auuuaauccagagacugacuucacuauagaacccacaguuguaucaaugguupaaagauaguggcaacaggcaaaggagaaacagcucugacauacaaagaaa\n", + "gucacgcucucccccgccccgagccgacgagccpaggcpaggcggcggccgcggcggcugcugcugcugcagupacagguggcggcgaccggcggcguccgaggag\n", + "agauuuaauccagagacugacuucacuauagaacccacaguuguaucaaugguupaaagauaguggcaacaggcaaaggagaaacagcucugacauacaaagaaa\n", + "gauuuaauccagagacugacuucacuauagaacccacaguuguaucaaugguupaaagauaguggcaacaggcaaaggagaaacagcucugacauacaaagaaa\n", + "gagccgacgagccpaggcpaggcggcggccgcggcggcugcugcugcugcagupacagguggcggcgaccggcggcguccgaggag\n", + "ucucuucuguauauacagaaauaugaaugugaaugaaguggaaggaagaaaaucaaauagcuugcccuuucuuaapaaacaagucaauuuggaaaggucccagcguugu\n", + "ucgguapucugccpcauaaapccuucggaaccccaccagagucacagccapapcagcpcgcaccaggccgaaggcucacgccacapapcagcuaggac\n", + "auguuucgugcgcucccauuacggaucauaccucgcaccucaccgcguggccucuguaguuccagagcucgcgapccapccguuggcggcgguuggaacgaaacg\n", + "uaaapccuucggaaccccaccagagucacagccapapcagcpcgcaccaggccgaaggcucacgccacapapcagcuaggac\n", + "aacuuccpacagaggcuguggcuggaaggagcupcauccggccugaggcgcagcggucgcguuaguucggccca\n", + "caapcuagaagcgcgacggcgguagcagcuaggcuuggcccccggcguggagcagacgcggaccccuccuuccuggcggcggcggcgcpcucagagcccggcaacpcpcpcag\n", + "gcgacggcgguagcagcuaggcuuggcccccggcguggagcagacgcggaccccuccuuccuggcggcggcggcgcpcucagagcccggcaacpcpcpcag\n", + "aauaaugaaagauuucaaaccccaaacagugcaacugaaacuuuuguauuagcauacuacugagaauaucuaac\n", + "aaugaaagauuucaaaccccaaacagugcaacugaaacuuuuguauuagcauacuacugagaauaucuaac\n", + "gcacuugaacuuggaaucuuauaacuugaagaacugcccuggagaaaggaagaaacuuauaauaa\n", + "gcuuccuucuuggaauuguucguuucucggagauaauuguauaaaagaaggagaaauaaccccacaucucuugacacuagagcuccag\n", + "caguaagagcuaugucggugcugupaaacagacagaggagcugugacuucuacccaggagauguggag\n", + "guaaaguaaaagauggcucaaccaaagaggacaggccuuauaagaucuuuuucagagaucucuuucuugucaaagaaaaugaa\n", + "aguugaaguauugauaacaccaaggaacucuaucacaauuugaaaagauaagcaaaaguuugauuuccagacacuacagaagaaguaaaa\n", + "auagaguugaaguauugauaacaccaaggaacucuaucacaauuugaaaagauaagcaaaaguuugauuuccagacacuacagaagaaguaaaa\n", + "aaggaacucuaucacaauuugaaaagauaagcaaaaguuugauuuccagacacuacagaagaaguaaaa\n", + "cuucucgccauugcaguuggacccagcagcccggcgcgcaccgcguggcuuuupcagaccccggcpcuguggcaggapcggcggcggcggcugcggucgaagaapacgccgacaag\n", + "cccagcagcccggcgcgcaccgcguggcuuuupcagaccccggcpcuguggcaggapcggcggcggcggcugcggucgaagaapacgccgacaag\n", + "acauuuccaacauuguuugccaguugcugcuuaggugacauggaucagcaacgaagcgucgguuucagugguuucuuuuucuggacuccg\n", + "ggcpaaaagucgccuccuuuguccucacaggucgcggagaggcggacccccuccuuggaagccccuucccacgcggauugcugaggaagccuuugugg\n", + "guaguagguccgucuccuccucccgccgapacgccagaguuaaggagcuucuugcupaapucccuccuuucagccggaaccugacccgcagaauguaucggaaau\n", + "cccuggccucccgcgagcugcgcaccgccggccgcugccccagcugcccgagcccgcgcccucguccgcgcgacccggcppcuccaggccggcagc\n", + "gaaauuuugagaaguggupaugaagaagaucccugaagagaggaguaacugagacaaaggcgaggcuagcaauagagagacaagugapaauuagaccuuugguaucaucaugaaaag\n", + "uaccuucugucugacuucaaccccacaucugcuugacaagaauuaacucaaauaucucuucuuaacaccuaccugauucuggcauaca\n", + "ggcgcuuccgcaggaagaaggaagcggcgccgccaucgccucccggcgcucccuccccgacuccuaaguccuucggccgccacc\n", + "gaaggaagcggcgccgccaucgccucccggcgcucccuccccgacuccuaaguccuucggccgccacc\n", + "aaguccuucggccgccaccauguccgccucggcugucuucauucuggacguuaapcaaggugaggcupcaugaggaguupagacggacag\n", + "gcuuccgcaggaagaaggaagcggcgccgccaucgccucccggcgcucccuccccgacuccuaaguccuucggccgccacc\n", + "aucuacgcccaucaapcugupccuapacaguucucaaagccucuuuggcucggacugcucccagaggcauccaggcuggcuaagcguucuucaucuuupuccuggagga\n", + "gugacgcugacccugacuguccccgaguacagcaacaagapuuucccggccaguccaggucuacuuuuaugucuccaaupcggaggaaacgcaguccuacccagaguuucagguuucugccug\n", + "ugaucugcaaagaggagccccuaccggacucaucucugcpuuucccuucagcaucggcaacccccuuuggcacugac\n", + "aaccguuuaguugcupaupcggcguupugcggcccugaaccggapauuuagagacuggagacgcggccucuaagagagguugaaacugugugugugupagaaa\n", + "gaagaggapaacccacapuccggagguuucaggccccuaguaaaccuggcaaggauuuuuagaagagccggagup\n", + "acgguugcgauggcaacupcuccugccagcgccguuupuuupaaccgcugcuaauupuucaugu\n", + "aacuggacucagaggaugccccgccaugcugccgucuggccuupagagcccccucccuauggcgcugcaccuaucgguauuccccgaccuccacccccucggccuggc\n", + "uuucccaucucaucccuggaggapcuggagcauccccggcagccaaucapacaggcupppaccgcuuugaagaaguuupaaaaaa\n", + "aguucucaaagccucuuuggcucggacugcucccagaggcauccaggcuggcuaagcguucuucaucuuupuccuggagga\n", + "aguugcguucpcguggccpagcacguuggcuccgcccccuggcggcugccucagcggcggcggcggcgcaggcucagagcagaccccgcccggcgaggaggapagg\n", + "cugccacgucccuauaugaacpugugugcccgccugcccuccgacguccgccggcugugcuggucugcagagcugccgccagcugcacccuccucgcc\n", + "gcugaauagaacpcguggaggcaggaggaggagcaggacgccpcacugcugaugcugcuuucgcup\n", + "aacaagagcugguaccgcgucaagcaccacaccaguggacaggapcugcuggcagcupcgcugcpagcpaggcccucuccgcagaccccaagcucagccuc\n", + "ggagcaacucgcuccaaguugugcagccpaccgccucpugugcagccggcucgcggaggcccuccupcpcgcpcgcggcucpcgcccccugagcag\n", + "pcgugaauacuuuuucucccgaaggaagauuauuucaaguggaauaugccauugaggcuaucaag\n", + "cuugguucuacagccauupauccagacaucagapugugugccuagcuguggagaagagaauuacuuccccacug\n", + "aguugguccuuaguacugcggccgugupugaguuggcugccggugaguupugccgguggagucguguugguccucagaauccccgcguagccgcugccuccuccuacccucgcc\n", + "cauaauuagcaucaucauuauucuggcuggagcaauugcacucaucauuggcuuugguauuucag\n", + "acacuauuuaaggccaauacacpagcugguugugagucaccaaggaaggcagcggcagcuccacucagccaguacccagauacgcupaaccuuccccagcc\n", + "gugagucaccaaggaaggcagcggcagcuccacucagccaguacccagauacgcupaaccuuccccagcc\n", + "gccpcguguuagugucuucgcpaaaacugccaauaaaguuuuucuucuucucgcucccaagauccccgccuccccuuaagcaccgcgagaucugacggcgcggcuacc\n", + "aagaugaauugaaucuucugguuauuguaguugaugccaacccaauuuggupaaagcaagcauuaaaggaaucucag\n", + "gaagaugaauugaaucuucugguuauuguaguugaugccaacccaauuuggupaaagcaagcauuaaaggaaucucag\n", + "uucacuuuauccaaaugcauagaugccgugauggugcupaaauucgcauuuauucaugaaucguuccaacaaacuugcugugauagcaagucacauucaagaaag\n", + "gaacugcggcggcggcgagcgccggccgcaucugagcagagcugcagcggcggccgcpcaccagagugccgagcccaggacgcccccggcccaggcccuugg\n", + "gaggagcgaupcagaaccagcacuucccucaggcacuagaccugucacgagugaacuuaguucccuccuauacuccuucacucuacccuaag\n", + "guuaauaccucugccaaccgaggccacccucccucggacccccauucggaggaagcagacccaaguucgaauucugacauugccacugagcagccguacaacuuuug\n", + "gcugacaccuccuuagcgcuggccgcpccgccucugcggcagcgcuagucgccuucuccgaaucggcuccgcacag\n", + "ggcgcccguucuacggagaguucacagccuucgugagupacagaaggcggcucggcccggugauucaggucgaaauucaagcugaacagccugcugagag\n", + "acacaaagauggcgcgugcagaauuugugaaagcgaaaaagaagacgaaggagaagcaaagapacggaauacugcagugcuapug\n", + "cuggaguccagaaaugauuuuuucgaugaauuuaggauuuugccgcaguauacaucugcagucccagaauccuccg\n", + "aggucgaggacggucggacucccgcggcpaggagccuguuccccugaggugcuupcgcuccuuuccuuauccuuccpcugcucccgcuuccucucggagccaaacuucguagcag\n", + "gugcagaauuugugaaagcgaaaaagaagacgaaggagaagcaaagapacggaauacugcagugcuapug\n", + "gccuucgugagupacagaaggcggcucggcccggugauucaggucgaaauucaagcugaacagccugcugagag\n", + "guagcaggcgcgcgguccpcggcpcupcgcagccpaggccupuupagcpagcucag\n", + "pcugcucccgcuuccucucggagccaaacuucguagcaggcgcgcgguccpcggcpcupcgcagccpaggccupuupagcpagcucag\n", + "agcaaagaaucaccccacacaaagauggcgcgugcagaauuugugaaagcgaaaaagaagacgaaggagaagcaaagapacggaauacugcagugcuapug\n", + "cagcuggaguccagaaaugauuuuuucgaugaauuuaggauuuugccgcaguauacaucugcagucccagaauccuccg\n", + "gcuuccucucggagccaaacuucguagcaggcgcgcgguccpcggcpcupcgcagccpaggccupuupagcpagcucag\n", + "accccacacaaagauggcgcgugcagaauuugugaaagcgaaaaagaagacgaaggagaagcaaagapacggaauacugcagugcuapug\n", + "guggaccuguccugaggcagaggccgagaugcgcgcaaccgcpagcagccaaguggacuggacucuuuucuugacuuagcuaccag\n", + "aguagcuacgagucugaguucgugucugccuaagcggucgcggaagagcgcgcaggccugccpcgg\n", + "auucuupccuguggaccuguccugaggcagaggccgagaugcgcgcaaccgcpagcagccaaguggacuggacucuuuucuugacuuagcuaccag\n", + "acugcuuucucccccauucuupccuguggaccuguccugaggcagaggccgagaugcgcgcaaccgcpagcagccaaguggacuggacucuuuucuugacuuagcuaccag\n", + "uaacucucucucacuugcuuugcauuaauagauucucugcugugupaugauccuucaaauagcapcaggaucaaauaaccucaccuuccagacccaagaauucugugcacaag\n", + "aguuucuuacaaaaucguccuauccagcaugcacuuuuggauacucuuucaacucagaagucaacauaaagg\n", + "ggcuauuuccaucaauuuuuccugaccaagaaggagucgccacuccuuacccaggagacacaaacacagcuccugcaacaauuccaucggaaupacagaccuacuugac\n", + "cuuccccucaguguucuuugcugucuucaucgcagaagccccacugugaggaguagagucugcagapuccacuuaccugagcgacugcuagapaaggaagacaacag\n", + "auucccaccpaccugcpcugagugcccuucucgguugcugccgcugaggagcccgcccagccagccapccgcgaggccgaggccaggccgcagcccaggagccgccccaccgcagcuggcg\n", + "uggaaauguaacuggaacugacucugaugauaaaaucaaggaccaucaagcaagaucaugcaguaggcaacuuugcuuccaaaagaaguuaccaacauuuagaauuucuacuuauucugag\n", + "guuccaguuacagcuauaucagagaaugaguuaaucuccucagaaaucacuaaauacuacucugapcuuagaaauuaacagg\n", + "gugugaaguuuuucaacaugaguggccucpacaguucauccgacccugcuaacccagacucacauaagaggaaaggaucgccaugugacacacuggcaucaag\n", + "agaaaucaacaacugaugacgauguacagaaaucagacaucucaucaaguagucaaggagugauagaaaaggaauccuupaccucuucuuuuggag\n", + "gcuuuggauggauuuuucuuuguugugaacugugaapagaauuguauuugugucagagaauguaaccagcuacuuagguuacaaucaggaggaauua\n", + "uuccaguuacagcuauaucagagaaugaguuaaucuccucagaaaucacuaaauacuacucugapcuuagaaauuaacagg\n", + "acccgcccucgccgccaccuggcccuccugaucgacgacacacgcacuugaaacuuguucucapuguguggaaucaacuuuccggaagcaaccagcccaccagaggagguagacagacagcu\n", + "auuucccccuucagaucuaacgauuacauuapcuccugcaucuuuuuggaaggauucuuuuuauaaaucagaaaguguucgagguucaaag\n", + "ggagaguccagacugacacucpucccauucccuucuguugcaggucccgagcgcgagcggagacg\n", + "cacacugccagcgcucacacugcacucccaggcccugcuguaggugcuaaucugaupcagccuuapapcucuguccccagcaggaggacccuug\n", + "cccccucgccggugaccuuggccgccucggaugcucugauuccacgcggcucgcucuaacuugcccccgcgccggccpccc\n", + "accuuucapagauuugagagaaagacuccagaagcccgcpagagcapuucupaagauaaagcccuucauccaggaucccucugugaccauaag\n", + "gaaugcccuggaguugugapugugapucgcguuccugcugucuggacuuuuucugucccacugagacgcagcug\n", + "auggagucuugcacugucgcccaggcuggagugccguggcaugaucucaacucacugcaaucuccgccucccagguucaagcuauucuccugccucagccucccgaguaucupauuacag\n", + "gcggcgacgacgucgucgacpuggccgupagcugagcacggagaagacucccucucucggaagccggaucccgagccpcagg\n", + "ggaggcggaapcccugcggcgacgacgucgucgacpuggccgupagcugagcacggagaagacucccucucucggaagccggaucccgagccpcagg\n", + "gaggcpaggucgcucgacucgccggcgcuguggccucccgcggagccgcucagacuuucccugccggcac\n", + "aucgcaguugcuccggaucuuugcacacacuccacpcaguuggaggugagcugcugccggccacgccagaggcugcaacaccag\n", + "cgguuaaguccuguaccuaggaaagapcgagcucupcgguaaggccggaapacucgugagcgugg\n", + "gguuacauuuuggauccucgcggaguacuggucaggcgguuaaguccuguaccuaggaaagapcgagcucupcg\n", + "gucaggcugaaguccugcgagcgacgcgcggcpcggcgagaggaaacgcggcgccpccpcccggcccuggag\n", + "gucguggaagcaggacugcgccgcgucuuccucaaggupuucppccaccgaaucgcugucacgccggcag\n", + "cgguucccguagccuuagcucucggccccpcccuuuuuccuccucggcugcgccgcguguccucggagcgcggucccuguauuggucuccugcuccuagag\n", + "cacguccggcugccggucuuggaucacgaggccuccgcuucccggacuccggaccccgcgccuccucpccgacpccagucccuggcgug\n", + "uggacugacgccgcapcgagcuagccggcuccgcgccucuccgcpauccagacgccuccupcugcuggcggapucugaggcggcgcggcc\n", + "acggcuuccagcagcagucacuguccupcgcgucccgcgcucuagcccaggupucccacaacggugugaccaaggacguccuaugaccaccccuugacag\n", + "gucgccuccpcuuucuccggucgcugccgccaccaccguugcuucgcpcupaggcccpuccccpcgaacagaggcugcgg\n", + "caugcccuuccucuugcugccaaaugcugaupuuugucuccggucccagagcaccaagcuauggaucauc\n", + "guugcuucgcpcupaggcccpuccccpcgaacagaggcugcpupagccuucgcpcgcugcagagcpccpaggccpauggagccccgcggag\n", + "gcuuucuccggucgcugccgccaccaccguugcuucgcpcupaggcccpuccccpcgaacagaggcugcgg\n", + "pcuuucuccggucgcugccgccaccaccguugcuucgcpcupaggcccpuccccpcgaacagaggcugcpupagccuucgcpcgcugcagagcpccpaggccp\n", + "gaacucugaggccucucgccauugucuccgagucggccagcuggagcguuuucpcuguaaapagaauggcgcaugcgcauauucapcggaaggcgcgcuaagagcag\n", + "gccgaacucugaggccucucgccauugucuccgagucggccagcuggagcguuuucpcuguaaapagaauggcgcaugcgcauauucapcggaaggcgcgcuaagagcag\n", + "auugucuccgagucggccagcuggagcguuuucpcuguaaapagaauggcgcaugcgcauauucapcggaaggcgcgcuaagagcag\n", + "acagauuuccccacgcagacgcugugugucacapaaupcagcgucacuuuuuacauccagucauauuguaugaaauugcaacaaauucaaaaagaugccaucgupagugug\n", + "aagacacuauuguaauagcauggcuaggaaggaaacacagcuaauuauuaagaugaaucauuuagcaag\n", + "agaaucugcuguucacaucccggcugugacgucguguccggugapcagagccaccgccugcggcug\n", + "cpaacagcuuccacguguucgaccapccaguuugccaaggaggugcugcccaaguacuucaagcacaacaac\n", + "agugcaguccaauuuacaggcuggagcagcagcugcauccugcauuuccccgaaguauuacaugauuuucacuccuugcaaacuuugccaucuuuguugcagagaaucgg\n", + "gucuggagcucggcagccgcagaagcggcagcggcggcggcgcggcgcaggcaccggcccpagaggcacc\n", + "uggagcucggcagccgcagaagcggcagcggcggcggcgcggcgcaggcaccggcccpagaggcacc\n", + "auagcaacpagcgcupcgcccccgcccuacpagcuguuucccapaacggugccucc\n", + "gcupagcuccugucaccgcupccpccpcpagugcapacgugapcgcaapccpac\n", + "aaauuuauaacpaapagaguuuuggagaggcggaauagaggaaaaggcpccuaaaggagg\n", + "ggccccggaggacucggcuuccccgcuaacccgacccgccgcaccccacccaggccaggucagagcagcccacc\n", + "gcggcgugccuggugcccuguuccgcgucugugcgaccguccgucccgagcgcgcagccgcggcag\n", + "agcugcccccgcucggcgcccgcugcacccuuagcagccacugccaccupcccggagccuccacgaucucgcccggcgauugupcapcgccuccgg\n", + "cgcucggcgcccgcugcacccuuagcagccacugccaccupcccggagccuccacgaucucgcccggcgauugupcapcgccuccgg\n", + "cugucaucagcuguggacpagccuucugaapaagcacuupagccugcaggacgaauaccuacaccagacuuggaauugaaaagaccucacuggagaaagagacauuugau\n", + "uagcaacugccpccccuapcguccagcggcccaacuggaguggagccgagugucgcccuupaaagcag\n", + "agaupucugacuguguugucuaggcugaucucaaacuccuggccucaagugauccuccugccucagccucccaaagugcupauuacag\n", + "pcgaagccgaggaagagcguuuupacpcuggugaggcucacguuggapcuucgcgucugcuucggagaccguaagg\n", + "pcpcgaagccgaggaagagcguuuupacpcuggugaggcucacguuggapcuucgcgucugcuucggagaccguaagg\n", + "cgaagccgaggaagagcguuuupacpcuggugaggcucacguuggapcuucgcgucugcuucggagaccguaagg\n", + "gaaaauaauuuugcugagauuuguuccugugguguuacugaaagauauaguaguaapcccaagauuuaag\n", + "guucagacuucugcugauucauaaccauuuggcucugagcuaugacaagagaggaaacaaaaaguuaaacaagcaagccugccauaagugagaag\n", + "gacupuagucuaccccacagaugccuaacucucacuauuucuucuuucagcaaacuuccuugauaac\n", + "agaaguugacggcgcagccpcgcpcgcggagucggcpccucgcpacgccpcagugcggagaccgcggcgcugaggacgcpagccpagcgcagccgcgg\n", + "gguggaguucagccuacucuuucuuagaugugaaaggaaaggaagaucauuucaugccuuguugauaaag\n", + "ccuucaucccgcguggagucuacccccaagcccuucuccucuucccaauucuugucaccuucgaggaggcc\n", + "gcacuuggcgacgguguccggcpaggcggcggcuuccggucupacggagcuguagcggcacuguaacugcgapcagcgccgc\n", + "agapaggacacagagccgcgccgcccgcaccacagaccuucgccucgccccgccgguuccucacccucpagcaac\n", + "gcpagagacggagguagapaggacacagagccgcgccgcccgcaccacagaccuucgccucgccccgccgguuccucacccucpagcaac\n", + "cccuggcugcpagagacggagguagapaggacacagagccgcgccgcccgcaccacagaccuucgccucgccccgccgguuccucacccucpagcaac\n", + "gcpucccucccuggcugcpagagacggagguagapaggacacagagccgcgccgcccgcaccacagaccuucgccucgccccgccgguuccucacccucpagcaac\n", + "gcaaaacgcacucgccccagaggcagcgcggccgagcccgagccgcugccggagcggagccggagaguggcggcggcggcggcagcggcacc\n", + "acapucuggcucuguuggcagacuagaguacaguggugagaucacaguucauugcagccuugacuucucaacgccaagucauccucccaccucagccuccugaguagcuaugacuacag\n", + "aucccuaccuguuucaaggaccugccagucugagaagcuucuugucauaaggccauccapccacgcaccccuaccuugccagccuccagc\n", + "uccaggcauuuaggacccugacupcagaugagucagcccagupcapcuccuggaacgaggaucuacaguuggaguugccccacuguc\n", + "gagcaggucgccgcuggcuggcagucgccacccggucccagaguaaauaapagagacacucccgagcgccguaaauagaguccaagupcggagagccgucccgcgccgcccgcuc\n", + "ggcgaccgcpcpccagcgccpucguggccpacacgugguacggaaccggcgccgcgcuugcugcugguaacapccuugccuagupccuuccuucccag\n", + "gcaugguggcucauguguguaaccucggcacuuupagaccaaggcggacagaucgcuugaguccaggaguucgagaccagccuga\n", + "gucgccccucagucuccacuagagacaggacugaccaguugcucuuccuuccaagaaccuucgagaucugcggucupucugguugaaag\n", + "gacacgugguacggaaccggcgccgcgcuugcugcugguaacapccuugccuagupccuuccuucccag\n", + "cgugguacggaaccggcgccgcgcuugcugcugguaacapccuugccuagupccuuccuucccag\n", + "guugguggccapcgaccgcpcpccagcgccpucguggccpacacgugguacggaaccggcgccgcgcuugcugcugguaacapccuugccuagupccuuccuucccag\n", + "apcgaccgcpcpccagcgccpucguggccpacacgugguacggaaccggcgccgcgcuugcugcugguaacapccuugccuagupccuuccuucccag\n", + "agugcuggaugcgcaapaaupagcgucgupaccuccggagccupagaucagapuggagucapcccccuaguuuuggacuccauugccgcacugcag\n", + "gaacacgugcuuucupcaggucgccccucagucuccacuagagacaggacugaccaguugcucuuccuuccaagaaccuucgagaucugcggucupucugguugaaag\n", + "ugauaacacacgccggapucgcacgcpuuccaguugugauugcuggaguuguguauugccaggaggcucuccgagauupucpucacugccucauccaccggagcg\n", + "cgaacccaccugcaggaaccaacuccggacacaacaccagcauuaaaacaauuuuuuuuugucuguucagac\n", + "agucgucggcgcgcgcggcupagcgguagcugugccucggcguccccgagcuggugccgagcgcagcgccccaggagcccccccauccccgcgccggcccacg\n", + "ucagucgucggcgcgcgcggcupagcgguagcugugccucggcguccccgagcuggugccgagcgcagcgccccaggagcccccccauccccgcgccggcccacg\n", + "gaaaaaccuugcuggaacuugugauugagcaguuugaagacuugcuaguuaggauuuuauuacuggcagcauguauaucuuuu\n", + "guuuuggcuugguuugaagaaggugaagaaacaauuacagccuuuguagaaccuuuuguaauuuuacucauauuaguagccaaugcaauugupuguauggcag\n", + "pcucaccpuagugaacugugagccuguuugcguccucugugcccpaauacuguaccugcuuacucgcagaucggcugcuuggaaaccuguggcaccaggucacgugauuguugcu\n", + "gaacugugagccuguuugcguccucugugcccpaauacuguaccugcuuacucgcagaucggcugcuuggaaaccuguggcaccaggucacgugauuguugcu\n", + "gcagaagccuaugaguugauuaauucuaacaacuggauacugugguuuapcuuggaagaugaaaaggaggccucugagaaugaaacagac\n", + "gcaggaccgccgugacgaccagaguagcgacccgcpagcggcacpugacgcuggcugcpacccagugacagcgugagag\n", + "acuuucacucuccgucagccgcauugcccgcucggcguccggcccccgacccgcgcucguccgcccgcccgcccgcccgcccgcgcc\n", + "gccgcacuuucacucuccgucagccgcauugcccgcucggcguccggcccccgacccgcgcucguccgcccgcccgcccgcccgcccgcgcc\n", + "guuggcggcgguuggcucggcgcpagucggcugcacgugcpcpcgaugcgucacugaucggugaggcgcggccgapucggcuuuccucgcgagccugcggcupcuucuucuca\n", + "ggcuguuggcggcgguuggcucggcgcpagucggcugcacgugcpcpcgaugcgucacugaucg\n", + "gcgcucugcuccaucccugaccpccgaggcugcuggaugccgcgucuccgcuucugcugccugccpcpcuccgguggccg\n", + "cagcaaagupcaccaaggcccugugcuaagcacucauaauccucupugcuaccccuacaaacagcacccccacc\n", + "uuuugagcugcuaacggagccagagcagcaucagagcggagucuccuugcucupcugcuccaggccaggcc\n", + "uguuuauccuggcagguucuggccuuupaagacucagagacacugagagacccugccccccauuucuucucugacccapcacagguuaccuucagcgcc\n", + "ggagugugucugaggaaacacaucccggacaccacuuapuuagucuuucugagcucuucacaucucugacuaauuaucaucauuacc\n", + "aggccgaacuuccggcucucacugcuapcuuaagcggapagucgagccagcgucgccgcg\n", + "augacggucgaaccaaacccauuccaaagaapuacuguggapcuuugagcccgcagacaacaagugucuguuaagagcuaccgaupaagaagaagaucagcacugug\n", + "caaccccpcaggaagagcucgucgcgguagcagcggucgaapaccaagcuccagapcpcgcccgagccgugcp\n", + "aacucccaagccccaccccupcuuggccugccuugcccugccpaagugauccccaaggcapugagaguuccccaucugaggcguuuguugcagcuaccugcacuucuagau\n", + "gcuccccagguucauccugugucgucucccccaccuaccagucaucuucuugugagcccupcuuaggagucacc\n", + "agcacupucggcccucpuguggcuguuupcaggacagcccucuguauguagccuugagcag\n", + "cugupaaggucupcapccgcaucaccgaccuuacguccaaccucaggacugccuggagcaagagcccupuupacaaaggaggcugccuggaccugg\n", + "gagcggagcpcggagcpccggcupcggagcggagucguccgcagagcagccccucccggccgcggccgccgaccccggaccccggcccccggccaggcucu\n", + "aagcgcggcgccgagcggagcpcggagcpccggcupcggagcggagucguccgcagagcagccccucccggccgcggccgccgaccccggaccccggcccccggccaggcucu\n", + "pagcuaagccagacccpuggcgguggcagcugcgaaacccapagccgaugccacgugacccaauguggacuucuuuuaaaccuuucuaaugcccauaacccagccucagaccc\n", + "ggagcuaagccagacccpuggcgguggcagcugcgaaacccapagccgaugccacgugacccaauguggacuucuuuuaaaccuuucuaaugcccauaacccagccucagaccc\n", + "agccagacccpuggcgguggcagcugcgaaacccapagccgaugccacgugacccaauguggacuucuuuuaaaccuuucuaaugcccauaacccagccucagaccc\n", + "ggaaagcuaccgccaagccacagccgaaggcaagcccgagcggcgccauccccaaccccgcgccgccgaccgccggcccgupcgacpc\n", + "gcpacagguggcuccpacccucagucccucggaccagccpuuuuguuuuccuguggccacagcccgaggugccag\n", + "caacugcuccgaccgucgcggugapccccaggacagaagcagacagacacggcuccugcugucgauuccgauccag\n", + "cuucugcacucacagccgaapaaagcagcagguupcuucuuguggccaacuucagagccugucaccaggaaag\n", + "ggcugaagaacaacaugaaaaauacaggcccagucaggaccapcucccugcuucccggugcuugcgcugcugugaccccgguaccucc\n", + "agccupcaaggcagupcauugugcuugcacccucuucuuccucuccuuuuugauucuuuucaucuguccaguuguuggugcggcggaupaggacacuccaggcapaaag\n", + "acacugcugcacuccagccupugacagagcaagacuccaucucaaaaaaaaaaaaaaaaagcccgcuacagacaucccccgcagaggcuccaaagcccccgagcgacg\n", + "gcuuuuggucauupugccucauauugccagacaagagcucagaccugaggagagugacuagcuucucugugucccag\n", + "augauauucuguucucuupacauuacaguuuugcauagacaaggugaacauuucucaaaacacc\n", + "acucgcucgcucagapaggagaaaguggcgaguuccggaucccugccuagcgcggcccaaccuuuacuccagagauc\n", + "uccccggcuagucuuuggccgccgccgaaccccgcgcgccacucgcucgcucagapaggagaaaguggcgaguuccggaucccugccuagcgcggcccaaccuuuacuccagagauc\n", + "aaugccpagagcaaagccgcugagaguuugucccguuagauccaggcgugaaggacggacuguacuacapagcag\n", + "aauccucuuggupugcugaaacaaugccpagagcaaagccgcugagaguuugucccguuagauccaggcgugaaggacggacuguacuacapagcag\n", + "gugaagcuuuguucuaagaauauuuguuucaucuaguuuaugaguccaaaugauauagacuguaaaugucacagcaguggugaaagacug\n", + "gcgcggcggcggcggcagcggcgucggcucpuucuccpagapagugcgcggcggccgcagcugccacaaaccag\n", + "agcggcgucggcucpuucuccpagapagugcgcggcggccgcagcugccacaaaccag\n", + "gcgcuuugacuuccguccaaaaccugauccuuauugucaagcuaaguauacuuucuguccaacuggcucaccuaucccaguu\n", + "aaaccaagagccacgacuagcugaggacacaagaauuuucacaaaacaaaguagagugauuccauagaucacuauuauagcugcauuaccag\n", + "uccuaggacagaauauggaugcugaaaaaugauucuuucaaagugcugaguuguugccucacgcccaguugucuggcaucucuucacugaaacuauuacaguuagaucucaucucuaupuggaag\n", + "gaaaaaauucugagaaugauauagucgaagugauaccuugaagguagaacugugcacugugguaauaacagaaacagaaagacauuucuucuauauaaacccagg\n", + "acugcgcgcaugcgcggcggccgccgaapcpauccgaggcaagcguugguucugugcgccucag\n", + "puuauagcucuauuugcacucgcuguuuagcugguccgaauuucuuguccugcguccaagaauaaugagguuaggcugacaaccgaapaaaapcggag\n", + "gcacuuuccgcggcuuugacgagcccgcagcggccpcccgagcgcagagccpccgagacugcacc\n", + "acuuuccgcggcuuugacgagcccgcagcggccpcccgagcgcagagccpccgagacugcacc\n", + "cacuuuccgcggcuuugacgagcccgcagcggccpcccgagcgcagagccpccgagacugcacc\n", + "ggucuugcuguguugcccaggcuggagugcaguggcpaucauagaucacugcagccccgaccuggucucauucgaucuucccaccucagccaccuuagccucccaaguagcugaaacuacaa\n", + "gcuagagugcaguggcgcgaucucggcucacugcaacccgccucccpuucaapauuucuccugccucagccucccaagagcupauuacaggugccugccaccacgcccag\n", + "pcapucacucguccgaacagaguccuauccuacgcggcggaagagugugcccuuugacuugcaucgucuaccuaccucugccauccucuaccagccgcaacugcgapcuggag\n", + "guugguccgcagucauucaccugguucuuaaggccagcuagauuucgugguuaucuccauccuggaggcugcguggacgcccuucuggaagcacgcaucccauguccucupaguaguagag\n", + "ggucuuauuuuugugguagauagcaacgaucgugaaagaauucaggaaguagcagaugagcugcagaaa\n", + "uuugccupagcuugaaaggagaaagcacpucgccccaaaccccuucugcuucugcccaucacaagugccacuaccgcc\n", + "gupaaggauacgagcaagauaaagcagcgapauuuaagucuggcaacaguuggacugcuggauuuucagagaaguguuccccaaagcaaauuauagugcuaauuucca\n", + "gacgcccuccacguguuccacugccucuucucuucucgcuupaacgccggucucaccucggcuugca\n", + "auuacucgccauuucaaaaugcugccgaggcccuaggaucugugacugccaccccuccccccacccpcucggcpagcgacucauggagcugccguaag\n", + "cucuuagugcuggcuguuupccugaggcugaupagagaccugguuguguccagcagccuup\n", + "guugcuguauaaagccaucgacucgaauggagagaacaucggcccaaucuacaaccaccgcguggagaucuccaucuucuucaucaucuacaucaucauuguagcuuucuuc\n", + "acauccuaugcucagcuccuugcagcaacaugucuuucaaaacuugucagccgagucaguccuuuaccuguugagcagagg\n", + "gaccccgcpcgucupcuuccgcggcgcccgccucugcucccuccccucpcgcupugccgaccggccggcuggccggcgccgccuccupaag\n", + "gucccggugaagcgaauacacgucaccaccggaaguagugucaaapaagaggapaaagacaggaagapaguccuuuggacg\n", + "ccucuccugccacucpcccccguucccccucccggcggcppcugcccccppcuggcggagcupccgcpccccpccggcggugccpucaucp\n", + "cuuccuccucpugaaacpccgagcacucpcguccucccaccauuaagaccuaacauagucuggaaugagag\n", + "guaauucaguaccaaacuguucgauaugauauccuccccuuaucuccugugucccggaaucggcuag\n", + "cccaggugaagaggaagauccuggugcuggaucuggaugagacacuuauucacucccaccaugaupuccugaggcccacaguccggccugguacgccuccugacuucauccucaag\n", + "gugguaauagacaaacauccuguccgguuuuuuguacauaagaggccccauguggauuucuuccuggaagug\n", + "cgccauagaccgcgcaggaggaacuuagucccggugaagcgaauacacgucaccaccggaaguagugucaaapaagaggapaaagacaggaagapaguccuuuggacg\n", + "aaaaugaaacugaagccguggucacgugacaggacauguaguauauagcaggcugccagcgacuccugcucuugcuucuggaucugcapcagucccagcaggaccc\n", + "uucucacggucccgccggcgccaccaccgcggucacucaccgccgccgccgccaccacugccaccacggucgccugccacag\n", + "acagaggacagaggucucgcucucucacccaggccggaugguucacuauagccuugacuucccpcucaagugauccuccccgcucagccccuugaguagcupaccacag\n", + "ggucuuacucuguugcccaggcuggagugcaguggcacaaucuuggcucacugcaaccucugccucccpuucaagcaauucuccugccucagccucccgaguagcupauuacag\n", + "gacgucgupuguuuggugugaggcugcgagccgccgcgaguucucacggucccgccggcgccaccaccgcggucacucaccgccgccgccgccaccacugccaccacggucgccugccacag\n", + "gguguuuggugugaggcugcgagccgccgcgaguucucacggucccgccggcgccaccaccgcggucacucaccgccgccgccgccaccacugccaccacggucgccugccacag\n", + "cpuaguggagccgcaagccaccggcaucuugcuuuuucuucccccuccuccugugugccccgcgccgcucccucuuucccuuuuauucccggccccacccgccaaa\n", + "guuugcccuccaaucaguggucugccuucauuuuccagauugaugaagucugccucagagaap\n", + "agacagagccccgcgcggcgcggcggcagcuucacucugguucaagcgcapaucggcpaagcucuuucacccccgcuucugccpcuguaacugcaaugg\n", + "apcagcgcgugucggcguccggaggaggugaccuagccgccgcgguccuagaapagaaguggagagagaccgcu\n", + "apauaaccaauuggcuggcaaaguaacaaaugaaaaguaaccugacucuauugaccugcuuaacccugcauppaaggauggaaaggagcagcuguuugcuuugaaacgguggaacag\n", + "augcgcapapagaccuuggcggagcggcggaggcgcccagcggaggugaaaguauuggcggaaaggaaaauacagcggaaaa\n", + "ggcggagcggcggaggcgcccagcggaggugaaaguauuggcggaaaggaaaauacagcggaaaa\n", + "apagaccuuggcggagcggcggaggcgcccagcggaggugaaaguauuggcggaaaggaaaauacagcggaaaa\n", + "cuuggcggagcggcggaggcgcccagcggaggugaaaguauuggcggaaaggaaaauacagcggaaaa\n", + "gapagaccuuggcggagcggcggaggcgcccagcggaggugaaaguauuggcggaaaggaaaauacagcggaaaa\n", + "aaaaugccccuccuuuccuccacaggaccagaugccugagcuaggaaaggccucauuccugcugugauccugcc\n", + "caacaggaagccgagaggaaaccagcaagcggcugcuguucuguguucccccauccagccagcaaguucagcuccggcaagucauuugauucacccggugaugaa\n", + "gcuuupuggccugccaccuuggcguccuuacagaccugccguguguupuggccaagaaacuucugcagguggaupcuggagaacaacgcccugcacaaggagaag\n", + "auccgacuccugcagacucgaggagacucauucccucugcupagacucupacuguccupa\n", + "aguuugucuggccugcgcuugcgcpucuccgccgccupcuccuapacuguggccucggcg\n", + "caguuugucuggccugcgcuugcgcpucuccgccgccupcuccuapacuguggccucggcg\n", + "cgccupcuccuapacuguggccucggcgguaugucccuugcuuucccuugaagcpagaagacccggcagaggcgcucuguccgcugcagccgcgcpuggaggaggcagagucugag\n", + "ccuagacgccguacgugccagaugguguuaccuggagcuuaaaaagcugcacgcaaguguuaaacuucug\n", + "acggcucgugagcggaauccugacugguucauccuccccggaacuuccuagacgccguacgugccagaugguguuaccuggagcuuaaaaagcugcacgcaaguguuaaacuucug\n", + "uaggaggaauacuguuggcguucaaaagcauugcuguuucaguuaaguaguuccuuaauuacuuacaauguaguaaggcuacauugaaggaagauauaaauuucagucaagacuacgacugagcaaag\n", + "ccggaacuuccuagacgccguacgugccagaugguguuaccuggagcuuaaaaagcugcacgcaaguguuaaacuucug\n", + "cuagacgccguacgugccagaugguguuaccuggagcuuaaaaagcugcacgcaaguguuaaacuucug\n", + "gaggaauacuguuggcguucaaaagcauugcuguuucaguuaaguaguuccuuaauuacuuacaauguaguaaggcuacauugaaggaagauauaaauuucagucaagacuacgacugagcaaag\n", + "augcacagucucugacaucagcucuccupacccuccaagagcacuagugucuagaaggcacuaagg\n", + "agacgcgccgcgguccccgccugccgcugcuccgccgcagucgccgcuccagucuauccggcacuaggaacagccccgagcggcgagacgguccccgcc\n", + "agcccggccccgccgcucccacagcuccucucaguuccgcuaucagagcaaccagcaagagcucacaccgcugccccugcucaaag\n", + "uuccuccagcagugugaccpaggaucugguggaauuggcucugccucagcuggcucagguugugaccguguaugaguuucuucug\n", + "agaupuggaggcacupccaccucagapccagugucuugcugapccggagcaguccugugccugcagccuccggagcc\n", + "agaagcaggcggugauugaaauguguugccggccuugupuucccuaggucugcggaacggcaccgucpacgguuggauaacaggaugauacuggapauucuugugguuggagaucag\n", + "aggagcpcccccggaggccgapuucggcgacgcggapapagagucupccgcgcpagccgcapcgcccuagccuucgcagaaacg\n", + "gucaggaagupcgcggcggccaggagcpcccccggaggccgapuucggcgacgcggapapagagucupccgcgcpagccgcapcgcccuagccuucgcagaaacg\n", + "aguccugaggcpcugaaagcccaggupcucggagaagaggaagcuccgccucgcuucccg\n", + "acugaccaaauauggaagugugcaagucuugaacacauuaguuuauacaauguggccugaaaguuucccuccucuuuccaaaucaaccauaauauucugag\n", + "gguuupaggcccaggcggcggagccuccpacggcgagcggcpcggcggaggaggagacggcaggucgg\n", + "ccgguuguuugagugauaucuugcaaacuagugccuauacguagupuagaaagugaaaaauupaaaaaguuagaugaguuuuacuacugagaagaaucacauacugcaag\n", + "gcacupcucccucugcuccccgupccgcuccccgcgupccacugcccccggcccccgcc\n", + "ggcgcccgccaggagcgccccccacucccaggccagcccaccccggcggaccpccccgcgcgcccaggcgag\n", + "pagaggucuggccuauccgcgccuggcagcugucggaacuccggagaccacaaapuuuaugguuuacccccuccacggaag\n", + "gcggcccuuuccucpucccgccugguaccapacccccucagcupacugcgccuggaagcuguc\n", + "gccccuggaggaacugaacccacuaucggucaupccgagacuaaauguggcpuugucuuuaaucugcugccaag\n", + "aguuugccuaccucuguccuagagcgaagccugagccuupcgcgcagcacaccacaaguaucuguuacuguguuuugcagaagcuucag\n", + "gcpauauaagccccacaaggaaagcgcugagcagaggaggccucagcuugaccugcggcagugcagcccuupacuucccucgccuuccaccuccugcucgucugcuucacaagcuaucgcu\n", + "agaggaggccucagcuugaccugcggcagugcagcccuupacuucccucgccuuccaccuccugcucgucugcuucacaagcuaucgcu\n", + "gagcgacpccaauuggaggaguuguuguuaggccgucccggagacccggucpapaggaagguggcaag\n", + "ugagcagcauagaagaaauaaugccuuuugapacaguugcauuuaacagacagccuuacuaag\n", + "gucccugcccagcugguguggcacagagcccuucggccugguacagccuaugugcugacagaacugcgaguguccaagauccguggucagcgccagcauguuugg\n", + "guagcggaaagaucugcucgaggccupugcuuuggugucggagauccgagagucggagaucggagagucggacacaggacagucggacaccggacagucaaacaccggaga\n", + "gaguagcggaaagaucugcucgaggccupugcuuuggugucggagauccgagagucggagaucggagagucggacacaggacagucggacaccggacagucaaacaccggaga\n", + "gcucuccaggcagcaagacaacuucuuuuacagcagcaaacaaguggauugaaaucuccuaagagcagugauaaacagagaccacugcag\n", + "gucuacucuaaugugaugcupauugaauuuuccuaggacuccguuucaagguuaauucgaaagucuuguggaagaucuggaagaaacag\n", + "guguggacccucacuugcugupuguupccucucuagagcapaggaaaaguuacccucacuauucucagacucuggaaucucuuag\n", + "gugaugcupauugaauuuuccuaggacuccguuucaagguuaauucgaaagucuuguggaagaucuggaagaaacag\n", + "gcaguugcpuuucgcgccgccggagucugagaggccggaagugccccuuagcpupaagcugguaggcacpcggcuccgcagugaccggacucpag\n", + "auuugugaucaccuggucacacaccupcaggaggcugccccuccucccugguuugaggaagcaggaaaagguacccgcgagagacagccagcaguucuguggagcagcgguggccggcuagg\n", + "gagccaggugcaaacauuucccgucaauuggcagaaaacaaccuugaggaaccuugacgaguguccggaguuuagaaaacuuap\n", + "aaacauuucccgucaauuggcagaaaacaaccuugaggaaccuugacgaguguccggaguuuagaaaacuuap\n", + "paucugucagccgcucccucupcuuccguccuccgcccgcgcccgacggagccuguucgcgucgacugcccagaguccgcgaauccuccgcuccgagcccguccggacucccccgaucccag\n", + "gagcuuaaacugaagcaaguucgguggacgccggcggcgcccugaucuaaagaaacgacucapacugcggcgcuugcacgucaacpag\n", + "agcuuaaacugaagcaaguucgguggacgccggcggcgcccugaucuaaagaaacgacucapacugcggcgcuugcacgucaacpag\n", + "agaaccaggaaggcgcugagcuuaaacugaagcaaguucgguggacgccggcggcgcccugaucuaaagaaacgacucapacugcggcgcuugcacgucaacpaggugugagcccaaag\n", + "guggacgccggcggcgcccugaucuaaagaaacgacucapacugcggcgcuugcacgucaacpaggugugagcccaaag\n", + "aguaggcaccgaacccagcauuuucggcaaccgcugcuggcaguuuugccagguguuuguuaccuug\n", + "auugaugcgcaugcgcapcuucagccugcacguacucggauugugcagcgacuccccguggcgguugapcagugguggcggcggaagcccaagucg\n", + "gcgugccguccpucgccuaggccupucpagcgcgcacgcugugcgcccupcgcgcucpauucucgccuggcgcggcupaaggugaacaguguggcccgcc\n", + "caaggugcauaagauuuuuccugaagguaauacuaacagauupcaupuccgapuauucuagguggaaaggacaacuuaaagucuuguuggcaagaaaaagaucgguaugu\n", + "agcugugapuuccpaagauggugcugaucaaggaauugugagupucugupcgcgagcgaggccgupacggcagug\n", + "gugagaggcgguagcggcggcggcggcggugguaucggcggcagcugugapuuccpaag\n", + "ccpaagauggugcugaucaaggaauugugagupucugupcgcgagcgaggccgupacggcagug\n", + "aaggauggccauguucgccaaagcauaauggaagauguugaugaaaccgcacuguugaaacaaauggagcpagaaaaugccuccuccuccaaagccaaag\n", + "auccucaguguucuguguccugugcuuauagaggcccguccucuguggccgugugaccugcaaguauupagagccacagcuaaaccccpaccccuggaagccuagaaaug\n", + "guuuauccucaguguucuguguccugugcuuauagaggcccguccucuguggccgugugaccugcaaguauupagagccacagcuaaaccccpaccccuggaagccuagaa\n", + "gugcuuauagaggcccguccucuguggccgugugaccugcaaguauupagagccacagcuaaaccccpaccccuggaagccuagaaaug\n", + "agagcaggcugugugcgagcccagcgucaagugauuccggccuccucgagucagcgguggupaugaggcucugccgapacuggcugugaaggaugaguucapup\n", + "gcaggcauuugcuuagagcaggcugugugcgagcccagcgucaagugauuccggccuccucgagucagcgguggupaugaggcucugccgapacuggcugugaaggaugaguucapup\n", + "aggcugugugcgagcccagcgucaagugauuccggccuccucgagucagcgguggupaugaggcucugccgapacuggcugugaaggaugaguucapup\n", + "gcuuagagcaggcugugugcgagcccagcgucaagugauuccggccuccucgagucagcgguggupaugaggcucugccgapacuggcugugaaggaugaguucapup\n", + "acuauaaauagcagccaccucucccuggcagacapacccgcagcucagcuacagcacagaucag\n", + "ggacuggagcgcagcauccuucgaggcugcagccgccacggcuguugccguaagcaauccuccugccucagccucccgaguagcupacucpaccagccucccgaguauuggucag\n", + "gccugguggcaucacguuuuucacaucuccgcaucuggacccugcccaagcgaaggcugaucuag\n", + "cucauugcuggagaugacugucagcugcuuucucugcauagccaccaucacaugccucaccacuggagccupaagccugaccacaaaccggcaucuccaaggcaugaauaauuagguaggcaua\n", + "gacacaugcauugguggccaaaagagagaggagacaaaaccgcugcagauggcugaugugaaucuaguggaaagagcuacupaugagagaaagaggaggaggcag\n", + "guugugucugcagcucuggcagaggacuguuccacuagacacgcugaapacupuacguguuuuccuucaggaccagagcugagaggagcupaucgcggcggca\n", + "acacucuuggagagagagcgcgaggcapagaugaucuccuccuccuuuuuccaaggcugcacuucuuggaagugaagccg\n", + "gcaggcaccauuuucugcuucgcucaggacaggcacauaaaaggaaggcggcugccgcccgucgccguccucuuuuccucagaugcccucugcugcag\n", + "gugugucugagcgcggcuccgcgccgccgcaggcaccauuuucugcuucgcucaggacaggcacauaaaaggaaggcggcugccgcccgucgccguccucuuuuccucagaugcccucugcugcag\n", + "cpcgcpugcpugucpcgcgcgcgccuguuggccgcucgccgacpcccagagccgccgauuccugccga\n", + "agacacacacacucuuggagagagagcgcgaggcapagaugaucuccuccuccuuuuuccaaggcugcacuucuuggaa\n", + "apcgcgcugcccggagcugccupuugcgcugccggccacguccccgcgccpccucaggcuccuuccuacuguccgapccaccaggccgccpccugcugcgcccgg\n", + "aucccuuggccaagcaggapaaccauuagcagccugaggagcuggcuggcupagccucpaccgcccagccuugcucccagcucacccacaag\n", + "uucccauuuggccggcgcuugccuugugacaucuacuggcauggaguuucauuucacgacaaugacauauucuccggucaagugaacaaguuuccag\n", + "pcgcgaggcggccaccguggagagcagagcgcggcggcuggaagcugcuaagucagagccgcg\n", + "gaguuccpcgcgaggcggccaccguggagagcagagcgcggcggcuggaagcugcuaagucagagccgcg\n", + "aucuucacuuuuuccguugcuagcaguggaapucacagaccaaacacuaaggccugagcggugacaaccgaggcgagaugauggucaacapaaugccucgupagaaaaaagacaauuuu\n", + "agucucacucuguugcccccaggcuggagugcaguggcgcgaucucgacucacugcaaccucugccucccpuucaagugauucuucugccucagccucccgaguagcuaggacuacag\n", + "accuuguaaaacaaagccpaaaaugccugcccgugcagcucggagcgcgcagcccgucucugaauaaga\n", + "gacaagaaaccuuggaggaagaacggcauuaaagaucaaaagcaugaugacuccugaugaaaacaucaccaa\n", + "uggcggcaccugacuugcuggauccuaaaucugccgcucagaacuccaaaccgaggcucucguuuuccacgaaacccacagugcuugcuucccpuggagagugacacgaccauuaauguu\n", + "gaaaccuuggaggaagaacggcauuaaagaucaaaagcaugaugacuccugaugaaaacaucaccaa\n", + "guguuguuagagaauucgccuauuacgacgacagcaacgucugaucuccuggcuuucuuccccuccuug\n", + "aaauaacuccaauguuuugcugaugcuuggauguaacaggccuuuguagcugacacauuucaagcaaugcuguucagcugccuguuugaagaaaguuuauuuuuuaaaaacuauguuugcaguug\n", + "ggaaaugguccaggagugcupugugagccucccuucuccucaagccggagacugcgguugucauugaucaauugaagaagcaaggacccgaaaucacagacauuag\n", + "aauuuguuuuggcugcagguacauaagagauagcagupagaupaapagagccagaggccgaccaggacaucag\n", + "gaauuugcugcacugacaaaagaauuaaaugccugcapaacaacuucuagaaaaggaagaagaaaucucugaacuuaaagcugaaagaaacaacacaaga\n", + "aagaugcuguagcguccucaccggcugccagcagguugguucuuccggccaauugaagcaagcaaagaggcuugcagaaaggccpaggagaaaaaugg\n", + "auugcucauaaauaacuccaauguuuugcugaugcuuggauguaacaggccuuuguagcugacacauuucaagcaaugcuguucagcugccuguuugaagaaaguuuauuuuuuaaaaacu\n", + "gcugaagagagacauggaaauauugaagaacguaugagacauuuagapucaacuugaagagaagaaucaagaacuucaaaga\n", + "gaaagauuagcagaagaaauugaaaagcugagaucugaacuugaccaauugaaaaugagaacuggcucuuuaauugaacccacaauaccaag\n", + "gcuaauucaggaagaaaaagaaucuacagaguugcgugcugaagaaauugaaaauagaguggcuagugugagccucgaaggccugaauuuggcaapuccacccag\n", + "auugcaguuguggaagaagauggucgagaggacaaagcaacaauuaaaugugaaacuucuccuccuccuaccccuagagcccucaga\n", + "aggaguagcagccaccgcacgaggcaagugaggagagaagaugcuguagcguccucaccggcugccagcag\n", + "ccccuuagaguugccaguaacggacauggcugcggcccccggaggapacgugaagugaggapuupapagaggacgcpcgaggaagaccagccccpccccg\n", + "auguugugacugugacagacucacupuuuguacaugcupaggagccuuccuuucapugaccacauucaucupcaugccugcaguacucuuggccc\n", + "aguaacggacauggcugcggcccccggaggapacgugaagugaggapuupapagaggacgcpcgaggaagaccagccccpccccg\n", + "gugaauggcguccugcccauccucccccugcucuuuccaguccucupuucuggcaacugccuguggagaggcccguguccuggcccag\n", + "auucugauccugaaaauguccuggagaapcauucuggcugupaauagcugcugcaaagguccugaagaaggaaugcaccag\n", + "agaguugccaguaacggacauggcugcggcccccggaggapacgugaagugaggapuupapagaggacgcpcgaggaagaccagccccpccccg\n", + "ggcgagccucccucagcccupccuguccacgcggaaggcccucagcguccugaaggagcagcuggaggcagugcuggaaggacaucucapagcggaagaagugucugacguggaag\n", + "gagguguggagaagcagcuuccuccaccacaguaaccgcugcuccugcuuccacuggccpccucacuc\n", + "pugccccccaccauccccagcccgcagcauaaucggugaapagccugcgguuucuccgccgcgccuucgcccguugcguccugcgaagccaguggaaucgguggucacaag\n", + "gagaacccagcagagcugguugagcuuucaaaugugcgguugupuucpuuuauugguugaauuccgcuggcucaggagccucugcagagaaagcgugagag\n", + "guccapcaaguucauccuacucucgagucuaaugaugaugcucuucaguauguugaagaauuaauuuugcaauuauuaaau\n", + "agacgagguuucaccauguuauccaggauggucuugaucuccugaccucgugaucugcccaccucagccuaggauuacag\n", + "augaucacgucucuucgcuuccaguccucagauaccuuagauacuuuguuucuuuuucuugccuuguaacaucacucacgacuuucagcucc\n", + "acgcuacucuuacgacgucacggucagguggugcagagcuggacggcaacgacgucggacgcgccccuucuuggaaca\n", + "gauaugauuggccggcgaaucgugguucucuuuuccuccuuggcugucugaagauagaucgccauc\n", + "uccggcgcggaaguuggcgucacgucauggcgcgccucgguggcgucagagcggcgucpccuggcpaaagucgaaaacuacpcggcgacggcuucucg\n", + "gucucucgaggccccgcuccccugcggccuaaucucuaaguccpccgcggucggcguucuccucupcuccgcgccccgaaccuuggcuuccucaucugcccugagaupauaauccccacag\n", + "caucuugguccugcccugacagauucuccuaucpucacapacgcuaagauugcuaccuggacuuucguugacc\n", + "agaggugcaccacgupuuugcugccggagcggagucuccggccggcguccaguuugagucuagguuggaguuggaaccguggag\n", + "gcugcgcpcggcgguugguaaccggucagaccagcccgagapaccuggugccuguacccaggcuucugucgcucugucgccugcgcu\n", + "accuuccucgcugcgcpcggcgguugguaaccggucagaccagcccgagapaccuggugccuguacccaggcuucugucgcucugucgccugcgcu\n", + "cgcccccgaccccgcgcgaagagugcgcaggcgcgccgacagccgaguuuucugcgcuuccuucucccucucuccagacgucguggucguucgguccu\n", + "gugcgcaggcgcgccgacagccgaguuuucugcgcuuccuucucccucucuccagacgucguggucguucgguccu\n", + "ucucaugcaaguggcaaacuccggaagaagaaaaaaaaacagaaaaacaagaaaagcagcacpagaagcaucg\n", + "gaaaacggacuagaagauaucgaucgcauccuagagaggauugaggacagcacupuugaaccgucccggcccagcuccccugagcuccaggaagcacguucucuacguggagcacag\n", + "acacuugaauccagacacagaacugaaaagguauuuuggugcccpcaauccupagcaaag\n", + "gccacggcagagacaacguguguaccccaagugcacauggcugaccaccccuaaaagcaccuggccccgcuacagcaaaccag\n", + "auuuuggaagaugcugcugucaucagaaccuuuucucugcugugguaacuugcauccugcuccugaauuccugcuuucucaucagcaguuuua\n", + "gcguuccuguuuuaaauccugccuuggucccucaccuggcacaaggacaagugcuacuggugucagacccaucgcccaacacugauccugcuaaguacucug\n", + "cuccpccgcgucugupucgagacugcgcggccguupcgugcagcggcgccagucggcggacgapcccccpag\n", + "gucugupucgagacugcgcggccguupcgugcagcggcgccagucggcggacgapcccccpag\n", + "gcagcagcagccucccgcgucgcugucgcuguugccuccgccaccuccuccgccgccgcgcgccccucggaguuccgcgccccacc\n", + "gcucccgcagcagcagccucccgcgucgcugucgcuguugccuccgccaccuccuccgccgccgcgcgccccucggaguuccgcgccccacc\n", + "cgcagauaaagugagcccggaaapaaggapcpacaccauugcccugaaagaauaaauaaguaaauaaacaaacuggcuccucgccgcagcuggacgcggucgguugaguccag\n", + "apcuggcuapagcugccgccgccgccaccgapcucggacuccaggcagcugcaggcuccgcucgcgacgcucggaaa\n", + "aguuucucuucucggccaccuccugcauagapuaccauucugcgcugcugcaaguuacggaaugaaaaauuagaacaacagaaac\n", + "cuccugcauagapuaccauucugcgcugcugcaaguuacggaaugaaaaauuagaacaacagaaacaug\n", + "guucucuugacacuucaguguuapaacaucagcaagacccaucccaggagaccuugaaggaagccuuugaaapaga\n", + "gacggcggcagugcgagaaagccgaagauggcgguccccgcggcgcugauccuacpagagccccag\n", + "cuggcaggcagcucucacuccagaucugagcuguccgcagaagcagcuggaggccapagaaacuccagaaggagag\n", + "ggcagauugacgguguppagucaaguggaaggugugguccagcaggcggcgagaagucugupcaacagaccpaag\n", + "gaaaccaucaagaucucauuuuacagcupauucucugguucacagagguaacggagcuugcccgaggccag\n", + "gacgguguppagucaaguggaaggugugguccagcaggcggcgagaagucugupcaacagaccpaag\n", + "uccccugcgccugcgcggcgagcagcuggcggaaccggcaucuucuggcgccagcuuccggcuuagcggcugagcuucaggcuugacgucag\n", + "gccugcgcggcgagcagcuggcggaaccggcaucuucuggcgccagcuuccggcuuagcggcugagcuucaggcuugacgucag\n", + "gcgcggcgagcagcuggcggaaccggcaucuucuggcgccagcuuccggcuuagcggcugagcuucaggcuugacgucag\n", + "gcagcuggcggaaccggcaucuucuggcgccagcuuccggcuuagcggcugagcuucaggcuugacgucag\n", + "pcagapacccggcuacccuggacagcgcaucgccgcccgcccpucgccgcgccacagccgcugcggauc\n", + "aacaccuucaaagacaggcccucugaguccgacgagcuccagaccauccaagaagacagugcagccaccuccgagagccuggaugug\n", + "aaagacaggcccucugaguccgacgagcuccagaccauccaagaagacagugcagccaccuccgagagccuggaugug\n", + "ccaccugcccaagaaacuuguugguuguugcccucaggucgcucccpcpacacggaacccggcc\n", + "cucuccacugccugcccgccaccgugcaagcucuggccggcgcugcccacaguccccauggupcagcccccgcggcpaccccugaucggcagcggc\n", + "gauuuacugccucaagaugguuauguuggaggauuccaauaguucuacuggauguggagccagaaauuguguggaaugccugguguuucuuucaguucuuggaugccaaucugag\n", + "aaugacaaauaugagccugaaggaagaugagcugauggcauucccagcuuauuaccacuccuupccuuaucuuacauacauggauucaauucguagauucagcugg\n", + "acaagagacaaugacaaauaugagccugaaggaagaugagcugauggcauucccagcuuauuaccacuccuupccuuaucuuacauacauggauucaauucguagauucagcugg\n", + "aggaaaggccagaugaggacacagcaagcaggcagauggcugcgagcuggaapaagcgucaucagaaaccaacccugapuaccuugaucuuggacuuccagucuccagaacu\n", + "agacaaugacaaauaugagccugaaggaagaugagcugauggcauucccagcuuauuaccacuccuupccuuaucuuacauacauggauucaauucguagauucagcugg\n", + "ccacgaggcccapcccgagugccgagcccuuugcucccucggccgcgcpacapcugcugagcagccuccgccucucccggcugupccccacugagu\n", + "aggaauuggauggaggugcccuucagaacucauggagaaaagcacugcucccaguaaaauaucucucauucuaaugaaugg\n", + "cugcgcgguugacuacgcuuaucaauccaucguauuccuuugucuucuugucacaaaaagaauuucgucagucuggaapaguuuuacuuacguaaauggauguagaccagacucaagcau\n", + "aagugagaaccucugaggauagaggaauuggauggaggugcccuucagaacucauggagaaaagcacugcucccaguaaaauaucucucauucuaaugaaugg\n", + "gaggaggaccpagcuggcucuggaggcugcggaggcgacgccggagagaacgaagccucggcupagcg\n", + "augauccucagcgacguuapucucuugccacauggapaagcucggcccuccuccucpcugaaggucucucucccugagaaggcggaagcugaggag\n", + "cagcugccaggcagaggccacupaacaacaacaaugacuaaucacacuggccagcpuggacagcgcucacugcaagccaagcccuccuucauacucacaaaagcccauuuugcag\n", + "ucuuuucuccuugcucagcuucaauguguuccggagupacpuggcugaaccucgcagguggcagagaggcuccccupcugupcucuacguggauccg\n", + "agucuuuucuccuugcucagcuucaauguguuccggagupacpuggcugaaccucgcagguggcagagaggcuccccupcugupcucuacguggauccg\n", + "ggccaacaggcaguggaaagacgacauucaucagugaguaugcccuggauuuguguucccapugaacacacugupuagcuucgagaucagcaaugugagacuagcccpuc\n", + "pccuapcaaapacuacaaaaaggaugcagaugacuauagaaaugaggacgacgaggagaugcuguggaggagcaguagag\n", + "ggcgucacugapcuacaauggcaccaucuuugccuacggccagacaggcagcpaaguccuucacc\n", + "gugccaccguacaggcaguacuucuccaggcaaguaguauuaaacaccagccgcccupccaggcauuguacugupacccaguaugcauuaapaagaauccag\n", + "papcccggcggcgacagcggaggcagagaggaaggcgguucugagagcuucagagagcgauggaaagc\n", + "apcccggcggcgacagcggaggcagagaggaaggcgguucugagagcuucagagagcgauggaaagc\n", + "acagccuugcagcgucuccggaaguggaggcpagcggcacggcagccacugcuupuagcpapcagacucupcgccacucccpccgguc\n", + "pagcggcacggcagccacugcuupuagcpapcagacucupcgccacucccpccgguc\n", + "cggcacggcagccacugcuupuagcpapcagacucupcgccacucccpccgguc\n", + "agcggcacggcagccacugcuupuagcpapcagacucupcgccacucccpccgguc\n", + "acagaggcugcagcacccapaggaacgccguggucccupacggccaccaggccaggaggcugcagcaccag\n", + "agaggcugcagcacccapaggaacgccguggucccupacggccaccaggccaggaggcugcagcaccag\n", + "cccugcggccapcgaggacggaucugagcagcupcagcaggugccaccgccugupacccagapcuugaggacaucugca\n", + "acccggccugugccagcuugcagagcucaccaggugcagaccccugcggccapcgaggacggaucugagcagcupcagcaggugccaccgccugupacccagapcuugaggacaucugca\n", + "guucugucauauguugaagaauccauacaccauuaagaaacagccucugcaucaguuuguacaaagaccacuuuucccacuaccugcagccuuuuaucacccag\n", + "gcaguuauuuaggauugaaggaguaaaaagugucuucuuuggaccagauuucaucacugucacaaag\n", + "cuccggacuaagauggcggcgacggccaggcpcupagcugcggcuguugccgccpcugcgcaggcg\n", + "gcagugugcguccgcgucugapapaugupaagcgacggcccccgguuuguuupcugupcggugcgcagcggagagcccpaaaagcpaa\n", + "gacguaccuguccucaggagccgcggcggcgacugcgccucggacggccgucpccgagaacc\n", + "ucggcuuauuuguuuucccuccucuuaggauugcccccugupucacuuucucagucauuuugagcucagccuaaucaaagacugagguu\n", + "uuagcuuaucaggagaacuuacuguaaaccgacucuuuuuguuucaaagaugucucccacuccaggcgaggagcgcucuuggcugag\n", + "caguugcauaaagaacauagaugagagcuuucauucccugcugaaaaggaugccaugccuccaccagu\n", + "agccugagccggaaucgcagcgugagcagguggagccgcguupagcccgccpucgagcugaguaaggcggcpcucggcpcc\n", + "pcapcapagaggapcggcpagccugagccggaaucgcagcgugagcagguggagccgcguupagcccgccpucgagcugaguaaggcggcpcucggcpcc\n", + "gacaaaaaaaaaggucucuccgauuuccucugcucaaccaguucccuggcuaccugaggcccugcuucaccuggaggaagacagug\n", + "gcucaucccggaaggaccggugucuaggucacccuggagcgcucaccccaccggcacccgugcccaagcccgccccugcaaaggcag\n", + "ucccggaaggaccggugucuaggucacccuggagcgcucaccccaccggcacccgugcccaagcccgccccugcaaaggcag\n", + "aacaauaacgucauuauuuaauaagucaucggugauugguccgccccugagguuaaucuuaaaagcccagguuacccgcggaaauuuaugcuguccggucaccgugaca\n", + "apagagcgcacgguggagccgccaguugagaaggacucugauccggcucagcuuuccaaucagcugcggaaggagccacgcuuucpuugcaag\n", + "gccaguugagaaggacucugauccggcucagcuuuccaaucagcugcggaaggagccacgcuuucpuugcaag\n", + "auagguggucuugcucuguggcccugcuggagugcaguggugccaucauggcucacuucagucuugaacuccugagcucaagugauccuccuacuucagccuccugaguagcupacuacag\n", + "agagccucgcggapugagcggccggcggcuucgaccuuggagucccaggcugugupacuug\n", + "gauucucugugaauugaucgugapaaggaugccugucacugugcugaugaccugcpcagupccuguugug\n", + "pcuacugugauuucucugcaguuggccgcagucaacaauugcacuaagacaggaggaaaaaagugaupuacaagcaagaaacgugguauuug\n", + "agaaagucgacpcguggcpapacgcugapcccaugugcugaaaauccgaagugccgcggaaaguggag\n", + "augugcugaaaauccgaagugccgcggaaaguggaggugapccgcccgcccuagaggugcccguccgagaggcag\n", + "cuggugcuguugccgccgcugcucuagcugccgucagucaggcugcgcccgcgucuucapcccagucccucggacccaucgccgcuucuagacccuacugcggucucggauauugccgg\n", + "auauucacccuucaugaggaugagcacagagcaagaagcuagccacgcupcuccucauugccuagcucag\n", + "auugccaucugcagaauuucugcagaaagugucgaccaggcuggcaugapaagaaggapaaaucacagcaaggagaaggaaaaacaccucagcauggcgupaagcaaag\n", + "agaauugccaucugcagaauuucugcagaaagugucgaccaggcuggcaugapaagaaggapaaaucacagcaaggagaaggaaaaacaccucagcauggcgupaagcaaag\n", + "gaauucapcupaaaauuuagccgagucaucacauuuggcuacuacccpaaagcagcccucccgagucaggaacpcuccgguucaucacguggcagccgccugcaggagccgcag\n", + "cccagaauugccaucugcagaauuucugcagaaagugucgaccaggcuggcaugapaagaaggapaaaucacagcaaggagaaggaaaaacaccucagc\n", + "auucauauucacccuucaugaggaugagcacagagcaagaagcuagccacgcupcuccucauugccuagcucag\n", + "agagauguuucuagauugauucauauucacccuucaugaggaugagcacagagcaagaagcuagccacgcupcuccucauugccuagcucag\n", + "agaacgcgugupcggcccpcggcgucuggcccucuccccauccucgcgcgccgcgccccagccccp\n", + "acaagaauauauauggccaggcgcaguggcucacgccuguaaucccagcacuuupaggcugaggcaggcagaucaucugaggucaggaguuugagaccagcccgaucaacaag\n", + "gguguacuacagaccuccacauguuggacaguaggauucagcagagaaugagucccacauccucuuuucauccauaagccacucuucccaacuacucuuccgccuuccauugucccu\n", + "guaggaaggcgccggccguggaggcgccacgucccuugcggcggcpagagaaaucgcuuggacuucpcggccucggacggcc\n", + "aggaaggcgccggccguggaggcgccacgucccuugcggcggcpagagaaaucgcuuggacuucpcggccucggacggcc\n", + "agcaggagcaggacagccggacaggaagcccagacpuucgagcaccucaacuucucuccupacacuguucaaacuccpccauaggccaagcugagcg\n", + "cuccuaguucaccacugucugcugccacacgauguupaggccupaaagcuggcugccgapccuggcccaccgcaccgagaaggccaccgapagcca\n", + "auucgaagacggagccaggcuggcagagcaggacuccgagagapaccagcucuuggcaaucaaupucucuugcaccaaccucucccaugccagugcc\n", + "gaugaacccagugaugaggccccaauggagcupacugaaggaaccugaggapacguugaccuucccagcucagagccucag\n", + "ggaaaggaucugcuacugcagcuggaggaugagacacuaaagcuaguggagccacagagccaggcacugcugcacgcccaacccaucaucagcauccgcgugupcgucpcpacaguggaag\n", + "gauguugugauggagaagccgcggcggagcccgaaccccgcagccugagccaccuccgucaucupcccpccucaccgcgcag\n", + "ggcccgcgcgcuccupcpauguugugauggagaagccgcggcggagcccgaaccccgcagccugagccaccuccgucaucupcccpccucaccgcgcag\n", + "auguugugauggagaagccgcggcggagcccgaaccccgcagccugagccaccuccgucaucupcccpccucaccgcgcag\n", + "uguggccacauuagccaccaacapcccaggaggagaccugagccauguccccuacugguggccccacauguggugacuccagacuauaggcucuaggcagaagcaggaacuguguugug\n", + "gcgcgcuccupcpauguugugauggagaagccgcggcggagcccgaaccccgcagccugagccaccuccgucaucupcccpccucaccgcgcag\n", + "gcuuuucucugcagcccagcaccaggcugugagcccagcuggcupcuggapcugugaggapapuggaggcaggapccpa\n", + "ucpcuccagccccguccgcgcgucucccggcgupugcpaccapcgcugcpcgcgcagg\n", + "cccagagacacauupcugaccugccgcugcugucagupaggccaguggugcuggccaagaaguguc\n", + "aguuuugccguuguugcccaggccagagugcgguggcacaaucucgacucacugcaaccucucucuccaggauucaagcgauucuucugccucagccucccaaguagcupauuacag\n", + "agaguauuaugapaggccgaggacuucaugcuccggacagagaaacggcgcupauuapauugccacuucugagagg\n", + "auggaaagcccgugucucugucaccgcuggagucccaggcacacagccccagguacacggccuccagccagcpagcgcgagagccuggaggugcgc\n", + "agauuugacagucaaggauccucauggcagcauggagaggccaggcgugucugcguggccauucugugg\n", + "agguuuagcaaagcuuucccagaggaaagaacacaucauuugugupuggcucugcuucacugaaaugaccagaacguagcuguuaagccupaggaupucaggccacaggaucag\n", + "gcaguuaacuuaucccgaagcuccaaagcaaacgucuuuuacuucuucgccpacgcugcuguaccaccgcugccucccuuucgcauucugcupcucggucagccgcugagauuag\n", + "agaaacaacaugaaaggcaaaugacuuuucaaacauucugcagcupaugacuucuuuuuuuaauuuuuuaaaauaugucaaggugauuuguaauccacagcaaa\n", + "augaaaggcaaaugacuuuucaaacauucugcagcupaugacuucuuuuuuuaauuuuuuaaaauaugucaaggugauuuguaauccacagcaaa\n", + "aagaaucuuuuccauuucuguugaaugapcuugagaaaaagcucacgaaauuaaaaggagaaugaagacgcuucugaapagcucg\n", + "cuuuuacuucuucgccpacgcugcuguaccaccgcugccucccuuucgcauucugcupcucggucagccgcugagauuag\n", + "acccucaucccucccgupagcccccuuuggacacucuaugacccuggacccucpaccugaacuugaugcgaupaggcugugcaggcucgcggcggcgcuuuucggauuccgagg\n", + "cccuuuggacacucuaugacccuggacccucpaccugaacuugaugcgaupaggcugugcaggcucgcggcggcgcuuuucggauuccgagg\n", + "cucaucccucccgupagcccccuuuggacacucuaugacccuggacccucpaccugaacuugaugcg\n", + "gcugcupccuuugcaacaacuucucuuauguggugaugcugagugccgcccacgacauccuuagccacaagaggacaucpaaaccagagccau\n", + "cuauuucuuguugcucacaucuccugaggcccaggacccuggapaagaagaagcagagagcgcagcccggcagccccucauaagaaccgaggccccggagucgaagccag\n", + "ggucugcugugguacauuguucccuuggucguaguuuacuuugccgaguauuucauuaaccapacuu\n", + "ggcaggcacagaagagauugcuccagaugaguucuccuugccucacuucucuuccuuagaacuuaggacacaacucag\n", + "agccgcaguucucccgugagapccuucgcgguggaacaaacacucgcuuagcagcggaagacuccgaguucucgguacucuucap\n", + "uuuucagugacuccauugaugaugcaugcgguuuggccguaucauacugagcuuuaaacacaagauuuauaaac\n", + "agagccgcaguucucccgugagapccuucgcgguggaacaaacacucgcuuagcagcggaagacuccgaguucucgguacucuucap\n", + "ggaacucuuuucuggaggcaacacupauuaauuuugagaaauacgaugacauuccaguugaggcaacaggcaacaacuguccuccacauauugaaagu\n", + "ggagauagagguuggacguggcpagguuapagccagcgaggcccuuucuccuccuugcuugccccagauugucccugugug\n", + "ucccgugagapccuucgcgguggaacaaacacucgcuuagcagcggaagacuccgaguucucgguacucuucap\n", + "cpuauauuagauccguggccgcgcggugcgcuccagagccgcaguucucccgugagapccuucgcgguggaacaaacacucgcuuagcagcggaagacuccgaguucucgguacucuucap\n", + "acccucucuupaccugucauaagucggaccccpcgcccggcugcgcagucccagccgccuuccccaggcaguggaaccuucpcuccu\n", + "guuccuuggagagcuuggagccgcgcgccggapaauaggaaagcuugguuacaacccpacacccg\n", + "caaaacaaaggagcggcggccpagcggacuuaccuuaccuucucugccuucggcgcgcuucucagccpccgccgacccaaaggagccguccgacu\n", + "aaauugcggaacgcgapcgagcgcgapagccccccuccggaaccccugcccacccccggagcgccggcagcggcggccccgcgaggaucggcuccag\n", + "gagaugauagaaagugacaccucauccauaaugucaggaauuauucgaaacucapcaaaaucaccaccccucuccacaggaauacag\n", + "ccucugaccucugcaggucaguucccaggacaguggagccaaacacagaccaagcpaaguucaccucccugguacaaaguucggcccugcuacucauuaaccuucag\n", + "gaguugcugccuuggccagaguccggagcagccgccgcccgaccacgccgagcucaguucgcuguccgcgccggcucccaccccggcccgaccccgacccggcccggucaggccccauacucag\n", + "ugaguugcugccuuggccagaguccggagcagccgccgcccgaccacgccgagcucaguucgcuguccgcgccggcucccaccccggcccgaccccgacccggcccggucaggccccauacucag\n", + "ggccagaguccggagcagccgccgcccgaccacgccgagcucaguucgcuguccgcgccggcucccaccccggcccgaccccgacccggcccggucaggccccauacucag\n", + "cccapaccucagaagcugcuagaagcccugagugccuucucuugccccupagaguupucapcagcaag\n", + "gcacuuccgcccpcgcauuguagccccgcggacagcupccapugcpccugcgccucccucggcuccuggcgcpccucpagagg\n", + "ggagagaggaccuauuucuaccuaaggacauucccggaaggcaaupuuucaaacaauauccugaagagacucaucucpaacuaagcag\n", + "augcpcccuggcccccaggccagcagcupccuuuuugaggupcuccccggacucaggaguuccuccuuggccgcggcuguagcugagagaapacaggagguagg\n", + "gaggccucucggagccucaguuuccccaucugcagacupcucugacuucuucuggcaugagapugugugagaguaaaaggaggcagcuagccccgugccpagacac\n", + "caggccccccaguccupugcaggcuugugacagcugcucapauccaaacguggcgcuugagcucucugcgacguguuccacaguucccuggaggcggacacugcgugagg\n", + "pcccuggcccccaggccagcagcupccuuuuugaggupcuccccggacucaggaguuccuccuuggccgcggcuguagcugagagaapacaggag\n", + "ggugcapccpcauggucguucacgccuguaaucccagcacuuuaggaggcugaggcagguggaucacgag\n", + "cagugacaguccuugugcucugguuagauuccauaucccugaacuucaaccugaaaacuuccauca\n", + "acucugcgagacucugcugaacuggcugcaucapagaaauuucaucucccagaapuguugcucaucguuucuucccggaaacaucugcagagacuagcuuuucag\n", + "cuuuuccpucucgaggcugcugaaaccgaaaccgcugugcugupcgcagcgccgagauugauucaccuucaccugugcugcacuccagcugacccaaguaggaagccagacgagcuguaaaac\n", + "gaaaugacuuaaucgucuuuuuggcagaccagaaugcacccuauuuuaaacccaaaguaaagguaucuuucaa\n", + "guaguggugccgacuuccuguuguuugaggccpuupugugcgauugugupacggucupcagcccagcagcggcugacccucugccugcpaapagucgccaggcggccguc\n", + "gugcaugaccgugugacugugccgugcguguacaggcpuccuggauauucgcgccgaacccagcacuccgguucgacpcugcaguuugcapcccggauaaccgag\n", + "gguccaccccggccuggccuagcggagcccccgcguccgcccgccgcagccgccgcuccauccccagccccggccccgcauccag\n", + "agaacccagcucuucccuacacggucggcacaugcgcggcagcucuuuuccuucuuccuccacuuccccuacccuccaccguccpagccgccgccaccgccgccgaggagucaggaaguucaag\n", + "cauuguccaggccuucgccaacagcggcaacgccaucaagcccgucuccuucauccgagaccugaaaa\n", + "agaucgcccgacacuuccgcuuupaaccaggaggacgcgcaugaguuccugcgguacaccaucgacgccaugcagaaagccugccugaauggcugugccaa\n", + "gugcgcgugcupccgcpccgaaggagucgccapcugcguaggcuuguggcgcgcccgcggagaggccp\n", + "auggugcgcgugcupccgcpccgaaggagucgccapcugcguaggcuuguggcgcgcccgcggagaggccp\n", + "ggauggugcgcgugcupccgcpccgaaggagucgccapcugcguaggcuuguggcgcgcccgcggagaggccp\n", + "gguuggauugcucaagaguugugcugagacccagaaggcuagaggcuaguuucgaagcuguagcucaggcugagucucaaggcpcggcgacuggacggccagaccggcgagcucuugacgg\n", + "gaaggcgaccggcagccucpcapagacaggacuguaugucagagaagagacggcgcuuggacgccaggaauccucugaagcaggagacugcccuauccag\n", + "ggcaggcacccagaguaguaggucuuuggcauuaggagcuugagcccagacggcccuagcapaccccagcgcccgagagacc\n", + "guaguaggucuuuggcauuaggagcuugagcccagacggcccuagcapaccccagcgcccgagagacc\n", + "aggucagagaaaaapuugagcggcaggcacccagaguaguaggucuuuggcauuaggagcuugagcccagacggcccuagcapaccccagcgcccgagagacc\n", + "uacguguccuaagauuucugugccacccuuggaguucacucaccuaaaccugaaacuaauaaagcuugguucuuuucuccgacacgcaaaggaagcgcuaag\n", + "cuggaccagaccaauuuugaggaaaggauacagacagcgccuggaauugucagacauauaccaaaucccuucuguugauucugcugacaaucuaucugaaaaauuggaaag\n", + "agaaupauagagagcuggcuucaaagaaaaauccuaaacucauuaaugcccuucggcgauguuuuuucuggagauuu\n", + "guaguaggucuuuggcauuaggagcuugagcccagacggcccuagcapaccccagcgcccgagagaccaugcagaggucgccucuggaaaaggccagcguugucuccaaacuuuuuuucag\n", + "uguuauguuucugaaaucgagaugccuuuuauaauugaugucaaaagaaacuugucagccacaaggcccaggaauaaguuguaauaupaacuuagcaauacauaaag\n", + "guguuggacaaugauuugaggucuuagccugaacuuuugaaugagaggugccccaucaacuggacuucuccugaguguugaaaag\n", + "acugagcgcucpccuuuucaaaucpauccguuaccgcuuccccggcagccgccauugucgcgcucggagccccucagcucaggcggccgaggcggaggcagcggcggcp\n", + "accgcuuccccggcagccgccauugucgcgcucggagccccucagcucaggcggccgaggcggaggcagcggcggcp\n", + "pauccguuaccgcuuccccggcagccgccauugucgcgcucggagccccucagcucaggcggccgaggcggaggcagcggcggcp\n", + "gagccgcaccccgcggaggcggagaagcagcagccgcagcacagcagcagcuccaauggcguuaaa\n", + "ggaggagcuucccagacguguagagcuuaugaaguuuaggaagcagcuucccagacauguagagcuuauggagaggugapagccaaucucagccacauucagcuuccuggagaga\n", + "aaugugaaagauguugcagaaguguuccagaaguggcugaagauagaaggaaaaaagugccacugccuaucagaaaaaacaaaacaaaac\n", + "agaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "aapacagaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "gaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "pccpcggcggagcugcaapacagaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "gcaapacagaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "gacggccpccpcggcggagcugcaapacagaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "pcpccugacggccpccpcggcggagcugcaapacagaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "gcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "aggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "gcugcaapacagaggcgcggcaggcgcgcggagccagcggagccagcugagcccgagcccagcccgcgcccgcgccgcc\n", + "gcgagacagagcgagcaacgcaaucugaccgagcaggucguacgccgccgccuccuccuccucucugcucuucgcuacccag\n", + "gacucupcggagcpcucgaggcugcuggagucgcucgcugacucgcccugcgcccucgccgcggacaccggagcugcggccgcuccccgcugucccccag\n", + "uggagucgcucgcugacucgcccugcgcccucgccgcggacaccggagcugcggccgcuccccgcugucccccag\n", + "acucupcggagcpcucgaggcugcuggagucgcucgcugacucgcccugcgcccucgccgcggacaccggagcugcggccgcuccccgcugucccccag\n", + "ggacaaaaguggcucucaauccagcacaugcacauugaagcaaguuaaaggauuuaauaugaagcacagaagcagauagugccaaauagcaagcaguaguuguuacacauuu\n", + "cuggaaaagcaguguccguguuguuauguacaccuccaaaaaaaguucaaauguguapaauuguuguguaaaguaaacugaacugcagg\n", + "uucccgacccgcgaccugccgcccgagcuggcugccaggccuaucgccgccgccgagacccuccggccaacapacccgcgguggccccggcccccccg\n", + "agacacggucgccuccacauccaggucuuugugcuccucgcuugccuguuccuuuuccacgcauuuuccaggauaacugugacuccag\n", + "ucccupcugcuggucuucuuuaccuuccagcugcucacagaacagagaguuucuacauacaagcagaagaugugaaaauauupaauaaauaaaguau\n", + "cguuaaauuuuaaccagaagauupauaaaaggcaacauaguaccaugcaagcauagccacuuugacaacguuucugagccapugacc\n", + "uagcgguuccuccuggcccuguuaaugucpccaggccpaggauggcgcccuagaacccggccuugcupuapcpapacpupaccggcc\n", + "gapcgcggacgcaggcccpaggacgcggcggcpaaccupcgcapcuapcagcpcccgacccgcacggcuuuccuggaaagcgcugccccucgccgcggcg\n", + "gauucacguguuuuucaapcuaacggaaaugcugagaucuaaaagcauguuuauugcugccaaggccugacgaugaaacuucaagucaaauua\n", + "ggaaggacagcacagccuacagccgugcucaggaaguuucuggauccuaggcucagcuccacagaggagaacacgcaggcgcagagacc\n", + "ggacagcacagccuacagccgugcucaggaaguuucuggauccuaggcucagcuccacagaggagaacacgcaggcgcagagacc\n", + "agaaggaggaaggacagcacagccuacagccgugcucaggaaguuucuggauccuaggcucagcuccacagaggagaacacgcaggcgcagagacc\n", + "gcgcccggccggcucugccuuupccagcapcuguaccupaguupuupcggagcggapaggccgugccaggcapccgguucgugcggaaccgcc\n", + "cuuupccagcapcuguaccupaguupuupcggagcggapaggccgugccaggcapccgguucgugcggaaccgcc\n", + "cccggcaguagcucucagguuaggcpucccgcuccgcuuccgccgucgcugccgcgccgccccpcccgacaggccpuccapacugcaacccagcgapacgcpcagcc\n", + "ugcuuucaggagcugcuggcugucagugucccugugcuguuuguuuugcgguguugauggcacauuu\n", + "ugagaaucagagcgucuacugcaccuuucagaugaccpugccguggcucaacaccuauaaucccagcacuupaupaggcuaag\n", + "auccuagcaauupcgcpccugugagccaguuggaguugcggcggcpaacgauupcugagcagaggacgac\n", + "cuuauccuagcaauupcgcpccugugagccaguuggaguugcggcggcpaacgauupcugagcagaggacgac\n", + "gcucacaacacucuaggaagcuaupaggugaggcccguaguggagaagaauugaaggagaaaaacggapcuguucugguguggcg\n", + "acpcucacuuuguuaccccggcuggagugcggugucacgaucucggcucacuguaaccuccaccucccagguucaagcauuccuccugucucagcucuccaaguggcupacuacag\n", + "acuuuccpccguacacgccgcggaaccggcagauaggcugacacagcaccupccgagcaggccugcagcuucccucugcgcgcucacaacacucuaggaagcuaupag\n", + "augacaaaaccgagccccagagguuaaaguaacuuuacuuaguaaaaguaaaguaguuuaacupauuuagauccaggucaugcugaugucaaauc\n", + "cpccugugagccaguuggaguugcggcggcpaacgauupcugagcagaggacgacauguugcuuuucguggag\n", + "gcgguaaaugauuccgaagaaaacuccgagaugcaagaaagaacgaugaacaaagaaaauggucaacauucaucauguaaauuuaaguaaauguugacag\n", + "pcaaggcgaguguguguccuuauccuagcaauupcgcpccugugagccaguuggaguugcggcggcpaacgauupcugagcagaggacgac\n", + "agccpuccacugccpuggapcaaggcgaguguguguccuuauccuagcaauupcgcpccugugagccaguuggaguugcggcggcpaacgauupcugagcagaggacgac\n", + "ugugagccaguuggaguugcggcggcpaacgauupcugagcagaggacgacauguugcuuuucguggag\n", + "upauuacgguccauggagcaggaggagaccuaccuggagcucuaccuggaccagugcgccgcucag\n", + "gupagaauuuuuuuauaaagacaaugaucagcacugagguagaaauggugacuuucccuagcauuuaacacagcaaagaagagcccagacaggaaagguucugagaaag\n", + "guaguuugagucauuuccacaucuugcgaguccuuccgaacgagucuccuuuccuupcucgcaaccacccaaugaucgauucaggagaaaagaagccupcggagagcagag\n", + "guugcuauuucauuuaccacaguaguuugagucauuuccacaucuugcgaguccuuccgaacgagucuccuuuccuupcucgcaaccaccca\n", + "gcucgcgugcgcgugcgcguupcggccggccaaugccggaccgcuucggcaccgcccgcccgaucccuccacccgupccggca\n", + "gugcgcguupcggccggccaaugccggaccgcuucggcaccgcccgcccgaucccuccacccgupccggca\n", + "pcggccggccaaugccggaccgcuucggcaccgcccgcccgaucccuccacccgupccggca\n", + "cugcucgcgugcgcgugcgcguupcggccggccaaugccggaccgcuucggcaccgcccgcccgaucccuccacccgupccggca\n", + "acuacccgcugcggagugaacgguguggagcggaggccgcggaggcuccucgguccuucagcaccccucggcccgacgcacccacgccccucaccccccgagagccg\n", + "acccgcugcggagugaacgguguggagcggaggccgcggaggcuccucgguccuucagcaccccucggcccgacgcacccacgccccucaccccccgagagccg\n", + "gccacuacccgcugcggagugaacgguguggagcggaggccgcggaggcuccucgguccuucagcaccccucggcccgacgcacccacgccccucaccccccgagagccg\n", + "aaggugguggugguggagaagaaagcuupupuugguagccagauggagacgcaacuguuccgcggcggcagaucuucaguugcggugcggagcugagcag\n", + "ccuucccgccucccgucuccgagcuucuuaaacacaggccuupccuacggcucupuacuuppcpcaggucug\n", + "apaugaggcapcggagacpaguacugaggugagagaaggagaacuugauuggugguaacagaggaagcauaaapuugugaaugcggugaaaag\n", + "ccgccucccgucuccgagcuucuuaaacacaggccuupccuacggcucupuacuuppcpcaggucug\n", + "acagagguaggaaggacagcagagcugacagucacagcagcccugacaagagaguuccuggagcccaagcucuucuccacagaggacaagcaggcagcagagacc\n", + "ggcacugcacuuggcugugauucaucagcaugaacccuuccuggauuuucuucuaggcuucucggccggcacugaguac\n", + "gcaaagcccagcuacaggcpcgacugcppccccugaggcggcpccauggcupucgcgugcuupaaaagcugccgacgcag\n", + "gcapcggaagcuccagaacucccggcaaagcccagcuacaggcpcgacugcppccccugaggcggcpcc\n", + "gagaacuacgaugacccgcacaaaaccccugccuccccaguuguccacaucapccugauugacggugugguggaagcagaccuuguggaggccuugcaggaguuuggacccaucag\n", + "uuauagcagauguaggacpapcuauccpucacgaapcccgaguccccuaaauucap\n", + "agucgcpaggcuuccccgcgccggccgcgucccgcccgcuccccggcaccagaaguuccucugcgcguccgacggcgac\n", + "acggcggccgcgcgcuccaggccggucgcuccaccccccggcucccpacuguggacuccacgacccuguccucggcccuguccgcgccgaagcagcccpacugcgcagcgccccgcgugccg\n", + "guccgacacccggupacucagaaggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "aggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "ggcgcucgguccggucgcguccgacacccggupacucagaaggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "cucgguccggucgcguccgacacccggupacucagaaggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "cgcgccgcugcpcggcccggccggcpcuccpagugcgaaccpcggcggcggcggcgccaggaccuccccgccacugcugugccggucccgg\n", + "gguuacuuuuugaaagcpaggaaucgagaagcacgaucuuuuggaaaacuuggugaacgccua\n", + "guuuggcgcucgguccggucgcguccgacacccggupacucagaaggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "gguccggucgcguccgacacccggupacucagaaggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "uguucggugaccagugacuuggauuuuccaacacaagucaucccauuaaagacucugaaugcaguugcuucaguacccaua\n", + "agaaggcaguggagccccggcggcggcggcggcggcgcgcpcgacgcgcpaacaacgcgagucggcgcgcpacgaag\n", + "auuuugupagcgaagcgguggcupcugcgcuupuccgucgcugcuucggugucccugucpcuucccagcagcggccuagcgg\n", + "gcgcuuugaaagugcgcgagcuccgaccgagaccupccggcgguuggucggccgaaaccaucugcuacguuacguppag\n", + "cauuuugupagcgaagcgguggcupcugcgcuupuccgucgcugcuucggugucccugucpcuucccagcagcggccuagcgg\n", + "ggagcgaagcgguggcupcugcgcuupuccgucgcugcuucggugucccugucpcuucccagcagcggccuagcgg\n", + "ggupcppaggaggcggcccuagcgccauuuugupagcgaagcgguggcupcugcgcuupuccgucgcugcuucggugucccugucpcuucccagcagcggccuagcgg\n", + "gcgguggcupcugcgcuupuccgucgcugcuucggugucccugucpcuucccagcagcggccuagcgg\n", + "ggcuguucccgacacagcagugcccacagaggccuacugacugcaggaagcagugugagccugacuacuaccuggaugaggccgaccgcuguacagccugcgugacuuguucucgag\n", + "acgaccucguggagaagacgccgugugcauggaacuccucccgugucugcgaaugucgacccggc\n", + "ccucccagcccgccccgugccccgcccgcccggcugcuuccgcggcggcgcugcccgcacaupcuaggcugccagg\n", + "guauuagcaagacaugaaaaucuguapcaccagaaccuuuaaucaagcucauguuuuauuguaaaauauuaggauguag\n", + "acaauacaauggupugaagagaagaugucucuaagaaaccggcugucaaaguccapaaaauccugaggaagaugaagaccagagaaacccugcaaaggagucccuagagacaccuagua\n", + "accupacacucgaggaggcacacgaggcggaaaaguggacpugccccgcgccaccgccucucccgapcgcguacugaccagg\n", + "ggucuaauuuuagguuapaccugcgcaauuuuguggaugcaacucugucucuaugcacguuaagaaagguuuauuugaagucauacaacagg\n", + "gucuaauuuuagguuapaccugcgcaauuuuguggaugcaacucugucucuaugcacguuaagaaagguuuauuugaagucauacaacagg\n", + "guuugaguacaagcucagcuucaaaggcccaaggcuggcauugccupcuggaauacccuucuggagccaucauggag\n", + "acacaugcucacacacuaagucccaggcacacagaaggcaauguggaccagcacaaaccuccacucucccggcuccaucccagcpccuguggcuggcc\n", + "guucccgcccpacuaagccpagcgcaucccggcuacugcpuccupucuucaccugcggagccuuacggcagcugagcggupag\n", + "guggcgcgcuccgcgguuccggcgccugaaguuuuagcugcgguggcggcggcagucpaccgacugcaag\n", + "gccccgacagguuugucuugugaccgcpcggccgcugcuucuuucccgagcuuggaacuucguuauccgcg\n", + "agguuugucuugugaccgcpcggccgcugcuucuuucccgagcuuggaacuucguuauccgcg\n", + "gcagcacuuagaugaguugaucccuucacaccccacccagcaguucguucuaccuggcaaaacuuaacagcuucggugaagaaaccuccacauuacugaacauuuggaggugucccaaugaaaag\n", + "uuucccaagguggauguagaagcpcuccggcgucccacucucccuuccauaupcuuagcgucupucacugagaacgacgucugaauapcccupuccuugcc\n", + "cuuugaacpuacucgagcccacapaagagcagcggaapccuuucggaacgauuuggaacgaaaggaaguggaagaaacgcggaacc\n", + "cccaggcaaguggcugccucuggcuagguucugcucacucacuuuguagcacaguuaggcuuagagauccagccaaggcagacagacapcccagaaccucaguccugcc\n", + "acucuccuguaaaacgcuagagcggcgaguuguuaccugcguccucugaccugagagcgaapaaagcggcgag\n", + "ggcgcggcgcgccupcgcuaagauggcggcggcgugaguugcauguugugugaggaucccpccgccgcgucgcucpccccgcc\n", + "gcggcgcgccupcgcuaagauggcggcggcgugaguugcauguugugugaggaucccpccgccgcgucgcucpccccgcc\n", + "gcgcggcgcggcgcgccupcgcuaagauggcggcggcgugaguugcauguugugugaggaucccpccgccgcgucgcucpccccgcc\n", + "cgcuaagauggcggcggcgugaguugcauguugugugaggaucccpccgccgcgucgcucpccccgcc\n", + "acaggaagaggcuggagcggaaagupaagcgaaccucgaaggaagagcagccaggcccpcacugucacuugccguccccucugcagcuccag\n", + "gauuggcaggauuaccgacucaacuacagcaaggacgacuuupuauagaaacccugcgagucccuucagaacucguguggcugccagagauugugcuggaaaacaa\n", + "cucucagacguacaaugccgaagagguggaguucacuuuugccguagacaacgacggcaagaccaucaacaagaucgacaucgacacagaggccuauacug\n", + "ccggcggccagaaaugcacggucuccaucaacguccugcucgcccagaccgucuucuuguuccucauugcccagaaaaucccagagacuucucugagcgugccgcuccupcag\n", + "pcgugguuguucgugauccuugcaucuguuacuuapucaaggcuupucuugccccgcagacccuupacgacccggccccagcgcagcu\n", + "aaagaagacuacaaucuccapaaaccupcgucucgcgcaaacguccauaacugaaaguagcuaaggcaccccagccggaggaagugagcucuccug\n", + "apaaaccupcgucucgcgcaaacguccauaacugaaaguagcuaaggcaccccagccggaggaagugagcucuccug\n", + "guucccagcaggaugccccggcucugcaggaagcugaagugagaggcccggagapcccagcccgcccpcagg\n", + "ggauccccagcucccgapcccccgugugccugcugucaccugaacpcuccccggccccgccgaccgcagcccuggagccugcagacgccagcagcaccggcag\n", + "agapccgucgcucuuccpcgcaugcgugcggcagcggcgccaggacugacugcgccguggaggcugcugcaguguugugaguuggaagcupagcucggc\n", + "gcagcggcgccaggacugacugcgccguggaggcugcugcaguguugugaguuggaagcupagcucggc\n", + "cuggcugugugccccagauucuacuguuuccugucugaucccacaccuucugcauucuccuuuuucuucuggagaaugagccccucccguggaggagccauggc\n", + "gcagucccggaagcggcgapaaacugcuccgcgcgcgccgcpaggaggaaccgcccgguccuuuapuccpcccggccpcc\n", + "agcgcggagccccgccccgcaggcugccpcccaccgccgcccaggcaaggccgcccugccuupcgcagcgcugcc\n", + "gcagapcgccuugcuccpugcgaccgcggcucccuggaggccupcggcpccccgcgagcgcgccgccaccucpagcaguguuggccaaggaccccgacgcccuac\n", + "aggcuacgccaagccugugugcucccuccugccucaggagcaggcccccagcacccagcugcccggcugcc\n", + "uccgcccugcccguacuaggccccgcccaccccggcpucugcggcucacgcggcucccpcucccuucccgcagcgcug\n", + "gupacgccauucccauaaugcucupcgugccgccgccgucgcugccaccuccccuaccgcuaguggaagaag\n", + "auuaugcagugcaugacuguauacagaugguccucaacuuaaugauggaguuacagccugcuaaacucauuagaaauugaaaauauu\n", + "guaccuagucgauagucgcugguucaaacaguggaaaaaauauguuggcuuugacaguupacaaauaccag\n", + "guacggcuucagguccagagcguggagaagccucaguaccgcpacguugcacugcuucaaguccaucaucaagcaagagagc\n", + "uuuguguugcuuuaaccgccuuuacuuucugagcuapcugucuccauccauagcaaaaguguaacuuuguuguagaupcguaagccucacccuggagagcgcua\n", + "gugagcuccpccuguuugccugcugaaguagagucuuapugaccccapacguaauguuuccgagaagaaggacagaaagaagacupagacaccggaacucgaaagaaaaucg\n", + "cauacagaaaggcuguaccuggaggaaggaagugcggagccagccugaguupagaagagcuccagaga\n", + "auaacucguugcpcuccgcgcggucccacuucccggcucccuucgccuccaggaugcgcugagcccuacaacacccccagcggccgccggcucccccacgag\n", + "guacccagacucaugguaucgugauaucacauccaacaagaaguucuuuucccuugcugcaaccuacagaggugccauugupa\n", + "cauaacucguugcpcuccgcgcggucccacuucccggcucccuucgccuccaggaugcgcugagcccuacaacacccccagcggccgccggcucccccacgag\n", + "uaacucguugcpcuccgcgcggucccacuucccggcucccuucgccuccaggaugcgcugagcccuacaacacccccagcggccgccggcucccccacgag\n", + "aaaagugcacugcuugaugaguugacauggcaugaacauaaccuguacauccccaacgccagaagacccaupcccccuuaccag\n", + "cgguuacauaacucguugcpcuccgcgcggucccacuucccggcucccuucgccuccaggaugcgcugagcccuacaacacccccagcggccgccggcucccccacgag\n", + "acauaacucguugcpcuccgcgcggucccacuucccggcucccuucgccuccaggaugcgcugagcccuacaacacccccagcggccgccggcucccccacgag\n", + "gccugcugaaguagagucuuapugaccccapacguaauguuuccgagaagaaggacagaaagaagacupagacaccggaacucgaaagaaaaucgguaacaaaau\n", + "auggaguuuugcuuuugucgcgcaggcuggagugcaguggcgcaaucucggcucacugcagccuccaccuccapuucaaacgauucuccugccucagccucccag\n", + "gcuuccgcuggcpucuccuccgugagcuccpccuguuugccugcugaaguagagucuuapugaccccapacgua\n", + "ggccgccgagcgccuggaaggagcugcuggacaggccgapagccuccgcccgagaccgcgcagccgccgccgcc\n", + "gcagcpccuggcugcagaugcggugguggccgccgagcgccuggaaggagcugcuggacaggccgapagccuccgcccgagaccgcgcagccgccgccgcc\n", + "agaugcggugguggccgccgagcgccuggaaggagcugcuggacaggccgapagccuccgcccgagaccgcgcagccgccgccgcc\n", + "gaugaggccacuaagcccacccccaacccaaggccccagucugccaggcgucuggaguuuauauugaug\n", + "uggcugaucagagcgcguapcuucgccpccpagcupcgcgguccugcucagcccagcucaccgcgcgccggcccucggcgcccugguucugcggaucag\n", + "cggcugcugccuggcggccaacpccagguaggauuuccpagaggcugcuguggaggcugaggaggcggcggcggagaucugg\n", + "ugcugccuggcggccaacpccagguaggauuuccpagaggcugcuguggaggcugaggaggcggcggcggagaucugg\n", + "uuuuucccccuccccpccaapcuccggcugcugccuggcggccaacpccagguaggauuuccpagaggcugcuguggaggcugaggaggcggcggcggagaucugg\n", + "aaggaacuugaucccaguucagugucugupuccauaugcugcccacagucaaagapagucccagguucuuggcagcuugcuuuuccucagg\n", + "aguccccgcgacgccgcgcugguuggugcuccugcgccggaggaguucugcgucucpuggugacupuccaga\n", + "aagaagcugagagugacgccucugagccgcggaggauugupaggagguugucuccaauuucuccucccccucccggccaag\n", + "aguggucagagugaccccaacagagugucccpacucaggccucugaucaaguuacccccagaggaucagagag\n", + "puugacgaaggagaagcauucagapcacuggcuucuggacagcaaugagugcccpccacgcggccccgaagccggcgapaggc\n", + "guaacucuacggccuagcaaccguugccaaggagcucgacucupagcggucuagagcccpcgccuccuppupaaacgguuucgugaggagaauuugag\n", + "acggcuuuggcpccgaggaaggaccugguguuuugaugaccgcuguccugucuagcagauacuugcacgguuuacagaaauucggucccupucgugucaggaaacuggaaaaaag\n", + "aaauucgaacggcuuuggcpccgaggaaggaccugguguuuugaugaccgcuguccugucuagcagauacuugcacgguuuacagaaauucggucccupucgugucaggaaacuggaaaaaag\n", + "gucacuuuggaacuucuupugaagcacuacuguacauaucaacpauuccaaacaaaucacc\n", + "pupaggacgccggagacguuccaagaugcacuuaguggagcaugugcguucggaaggcccacgg\n", + "uuucuggaaugugaauaggaaguuguuuuucuaaacagccugacacugapaggcagugagacuguaagcagucupuupcagaaggcagaaaaccagcagagucacagaggag\n", + "gaacagacuuugacccagaacacagaaccucacuugucaacaagaaccuucuggaagagaagacuggcagaauauuuuuuaaguacuaagacuugccugcg\n", + "acccagaacacagaaccucacuugucaacaagaaccuucuggaagagaagacuggcagaauauuuuuuaaguacuaagacuugccugcg\n", + "ccaggcapagcagaugapaggagccuuagagcuggagcaaagugaggaagcugucuccauapaagaggccug\n", + "guuapcgccaggacgupcgugcaggacgccagagcupucagagcucgagccagcggcgcccggagagauucggag\n", + "cgcaaccguccgccgcccggugcacuguggacgaugagucapuuapcgccaggacgupcgugcaggacgccagagcupucagagcucgagccagcggcgcccggagagauucggag\n", + "aaccguccgccgcccggugcacuguggacgaugagucapuuapcgccaggacgupcgugcaggacgccagagcupucagagcucgagccagcggcgcccggagagauucggag\n", + "pccggaagcgcgcgccgccacugccacgccgugucagucpapapagcgagcaggcgaagccgcggaggacpugaagauggcggccuucuccg\n", + "uaacuaaaauucuucaaauaugauucuuuuagccucccaacugauauccaggcugaaucuaucccauugaucuuaggaggaggugauguacuu\n", + "acugccacgccgugucagucpapapagcgagcaggcgaagccgcggaggacpugaag\n", + "acugccacgccgugucagucpapapagcgagcaggcgaagccgcggaggacpugaagauggcggccuucuccg\n", + "gcuuuuaguauuccaguuauccagauaguuuaugaaacucugaaagaccaacaggaaggcaaaaaaggaaaaacaacaauuaaaacuggugcuucag\n", + "ggcucagaucccacgcugccauucgguagauaugugucuuuagauaagugacuuaacuuucccgaauuuuagaguccucaucuaaagauucuaauaccuuccugacaga\n", + "ggaagcgcgcgccgccacugccacgccgugucagucpapapagcgagcaggcgaagccgcggaggacpugaagauggcggccuucuccg\n", + "cugccacgccgugucagucpapapagcgagcaggcgaagccgcggaggacpugaag\n", + "uuuuuggcuuucacccccaaccagugaccaaagacuugaccacucaaaguccagcuccccagaacacugcucgac\n", + "uuucacccccaaccagugaccaaagacuugaccacucaaaguccagcuccccagaacacugcucgac\n", + "ccugcucacccucpcugugguggagcagcuguccccaagcccacacccaguccugcagccgccuccaggucc\n", + "pcuccaucccacacagaggacapcucugcaguccuucacccccacccuaacuaucuaaucacpccaccggugupcaugguccagaagaccucaccgcccucccag\n", + "cuuaacagcapccaccaggcagagcpacagccaggaggaapcagcuuggcagagccucag\n", + "guguuuggcaaucaacucauuccucccaaugcacaagugaagaaggccacuguuuuucucaauccugcagcuugcaaagg\n", + "ggugagugcagcggcgcccaggcpagcgcagugcpucgcupacugagcgcgcgagcp\n", + "caaaucucuagaagaugacgguguucuuuaaaacgcuucgaaaucacuggaagaaaacuacagcupcucugccugcugaccupaggccauuggcucuauggaaaacacug\n", + "acgagucucgcccuguugcccaggcuggagugcaauggcacaaucucagcucacugcaaccuccgccucccagguucaagugauucucuugccucagccuccugaguagcuggaauuacaggcac\n", + "guggugagugcagcggcgcccaggcpagcgcagugcpucgcupacugagcgcgcgagcp\n", + "caaaucucuagaagaugacgguguucuuuaaaacgcuucgaaaucacuggaagaaaacuacagcupcucugccugcugaccupaggccauuggcucu\n", + "cuguccugaauccccacgaggcccuggcucagccucuucccaccacaggcacaccapucagaag\n", + "cuuccccuucagccaaucaccguucgaggcccgcccccgucgccggaaggagccgucgccccgagcaacuacaacguccggcuuucugaguupuggcpaaaggcg\n", + "gugguggugaagacgcuggagcagcuggcgcaacaaggcaagaucaaagagaagauguacggcaagcagaagaucuauuuugcggaucag\n", + "uguuugucagcucaguucugugucuggccugugguggugguguuuuggaggaucucuuugcauucuaccacgucccuggcaugugcag\n", + "acuuauaupcucugcugcupagcagccuucuguuugucagcucaguucugugucuggccugugguggugguguuuuggaggaucucuuugcauucuaccacgucccuggcaugugcag\n", + "ccggaaguugccuaggccaugcuccucucacaggacaggccagucagugguuugucugucugcguggaaagcaagagg\n", + "agcuaccggcugcupugcuccggauuuugcpuucgucpccuguggaagaagcgccgcgcacggacuucggcagag\n", + "gacaaaagccggaucccpaagcuaccggcugcupugcuccggauuuugcpuucgucpccuguggaagaagcgccgcgcacggacuucggcagag\n", + "gcupugcuccggauuuugcpuucgucpccuguggaagaagcgccgcgcacggacuucggcagag\n", + "cgauaccaucugugaucuapugucaacgagcuggcaaacuaupaguacucaggcgcccccagcgagcagcagaccuaugacuaugccaagacuauccucucccuc\n", + "gcgcgcucacacccgccccupagcagaagcaguaucuuccccagcuucgupuuucuccuccccccggagucapugugcgag\n", + "agauacccgcggccpacucggagcugupugupaggcggaggcaccaacuaagagcgaccuagcaucgcaaagccgcccucpcgcuc\n", + "acgcagagagaaaguuacgagguucguggccgcgguuuccccaggcagcuggcgcuggaggcuucggcgucacgugcug\n", + "gcuaaauuucuucauacucaacuuucagauucuuuaaucuccagcucagcuucaacaauucaacgcuguucuuucugaaaaaguacacaucgugccuucucuacuucgcucuuggaacauaauuucuc\n", + "auucuuuaaucuccagcucagcuucaacaauucaacgcuguucuuucugaaaaaguacacaucgugccuucucuacuucgcucuuggaacauaauuucuc\n", + "guuuugcucuugucacccaggcuggagugcaauggugcgaucucagcucaucaaguucaagagacucuaaugccucagccucccaaguagcapuuacag\n", + "ucaucacugcaggauucugaggaggcaggcaggauacaugcgugauucuccuucccaucuuugcacagaaccuauacucgugcacugcaucug\n", + "cuuuccucuugcugaugacaugauuccuguuugaaucuguugacaagauucugaaagcugaacagagaauucuggcacugcacupuaggaaaaag\n", + "cauuucaagaaauagauaauaucaaggacaucaggacaccpagupagagauuggacupagacucagcag\n", + "gagcgugcgugagugagugugugugugugugugugugugugugcaugcgugugugaagaaugcacacuaucuccuguug\n", + "gugcugugcuggccauuggugacccaaagaugaugaaaaauauguuccugcccacaaggaguuagcgaccuacup\n", + "acuugacagguucaguuggagacgaucauagguggcugcugugacaaapaaauugugcuuuuccagc\n", + "acacacacacagagugaaaaaggcgagccaccaaaacccaucuccagucuccucccpcccccagcccgccucugugccacuuugcaucccacgccggaggaggcauuaacgagaccpuaag\n", + "gcuuuuuaaacgguccaagguguagagccauacuucaggaggauccucagaaguuuuggacaagccuccccaaauguggcag\n", + "auaaagauuuuggugcgaugagagugcugugaauauggauuuucuaucaaaaacacaggagugccguuuucaga\n", + "agagugaaaaaggcgagccaccaaaacccaucuccagucuccucccpcccccagcccgccucugugccacuuugcaucccacgccggaggaggcauuaacgagaccpuaag\n", + "gauuguggacucuuccaagauucacaaugauauggugaauccaaagacuggaaccaaaaagauuuacucagugcuuuaguuuuaacaacaguaaauugucuaccaacacccauc\n", + "gaagagguaaccauccaucacgguuuucccagaacaggcugauuugcgucuucuguccuggcauaaggaucccuucacucucggaaguguuccg\n", + "auuggaguugacuaauaugaauguauguuauucaacccaaagagacaugaagaggcccaaaagugacucucuccauugccccacugcauguguuuguacacugaaugcuuacagauagaugguaaau\n", + "agugcggucacauacuuccagaagagcggaccapcugcugccagcaccugccacucagagcgccucugucgcupacccuucag\n", + "gucugguugguuuccaauacgguagaugcaucaguaggucuuuggaaaaacuguaccaacauuagcugcagugacagccugucauaugccagugaag\n", + "cucagugcggucacauacuuccagaagagcggaccapcugcugccagcaccugccacucagagcgccucugucgcupacccuucag\n", + "agaggaagagguagcuccacaggagguacagcugcuuacacaucucuccucagagcugucccuugacuupugaauuucaggccaacapcuuccupauacaagagcguucucc\n", + "ucucuuuagauucucgaauuuaccguggucugaacuucaacaucgagguugcuauuucuguuuuaucauugacucaacuucaagccagguuaucagg\n", + "aauuauucauuagguacuugaaagcucugcapauugguggcugagaggccuagucgacuguuucuuagcuagag\n", + "guaggaggaggaggaucgcuugagcccaggaauuugaggcugcagugagcuaugaucgcacuauugcacuccaaccupugacaugagcgagacccuuucucuaaaaaguaaaaaagaaagaaa\n", + "agugguuggugacpacagagcggucggugacagccucaapcuucagcaccgcgcccauggcagagccagacc\n", + "agucggugacaggacagagcagucggugacpacacagugguuggugacpacagagcggucggugacagccucaapcuucagcaccgcgccc\n", + "gagcagucggugacpacacagugguuggugacpacagagcggucggugacagccucaapcuucagcaccgcgcccauggcagagccagacc\n", + "gccaggaccucaacaaugcccupugaccucguccuauacaacuucuccgccaacaccupagucuupaccugaguccugccccg\n", + "pcaaugugcacacccauuaccaggaggaaaagugcuacgaagauggcaucuucuucuaccaccuuggcugccaucaaupugucaggagcugagcuugccccgccaggaaccccugagg\n", + "uaccacuuggacuacugcuccauguacacagaccacagcgucugcucccpacccggaaugcaguuggugccaaggagccugccaagcugcacccccuccupacccccuupcu\n", + "gaccccuucugugaguggcaucagagcaccagccgcaaapacgcggcaugcagccggcpccpucpugcccugaagaguccagaggagugucccccgcucugcagcca\n", + "uguacacucggagccacggugccggagcugcgauggcuuccugaccugccaugagugucugcagagccacgaguguggcugguguggcaaugaggacaaccccacacupacg\n", + "agccupugugugcaucugugccgapcuucpccccgacugcgccaccaagcuggauggcpcagcuggucupagacccucauggacagccgccucucagcc\n", + "gacacugccagccgcuuccugcaccgccupccacaccaugguggauggacccgaugccaccuuguggauguuupccupccugccccapcugcupaaaccuguacag\n", + "gcupcugcpcucccccugcuccccaaugccucgcuccccggaggaaugucgacgucuccggaccugcagugagugccuggcccgccauccucggacccugcaaccuggagauggagag\n", + "auugaaaacupugacagapuccuagugaagacgaggccgugugcgugaacugccagaauaacagcuaupagaa\n", + "acguugccccaucugacgcucggcucgaggccucucugugapaccppccaucccccuccapcggagaucggaggucgcugccaagc\n", + "cugcagacguugccccaucugacgcucggcucgaggccucucugugapaccppccaucccccuccapcggagaucggaggucgcugccaagc\n", + "cccgagucuucgcugcgcgccgcgcuccpcggaccgapacgcpagcggcugcggcpcccuguggaggccucgcpccupcccgaucuccgagccgcp\n", + "ccacuucugccguccccaacgccaccuccucapccagcaagaugcaguuugagaugcacgacaacgugaaaggcaaag\n", + "gcugccupucccpacgupccccgcgccccgcugcccuugcuuccgcgaucucucucuucugaauacguuuccgcucguuuaucucugcgaagugauuuuacucug\n", + "uucaacugcucugcuuccaucuguucuugucuugccuuaccuauuauggaguccucaggcauuaaauuuuguugugauugcugcauuugaaaccagaaguaaccugaagaaaaapucga\n", + "aggcgcaggagcgagcgcgcccagaguggagcucagcugcupagccagcpagccuupuucccg\n", + "accaugaaacccuupcacgccccuucagaagcuguuauccaagacaaucuaguuuuccuuuauaaaucacuuaagacacuuaugaaguuucuuguucugaaauugcuguacugca\n", + "agugcacacccagcpaaggaagaggaaguguguucaggaauagcucaggcagcugugccauuggccggcaggccugucagucgccupccgaggcugaaaagaggaagaa\n", + "guuucugcauaugaaguguguaaaauagauugcuugauccaaaacagaaaaacagugauaacuguuuugcugaguucccagacccuucccaag\n", + "ggauauuaaugguuugccucaaaauugagaaauaauuuugucuuuccuuuuuuucuuuaaaagcagagaaaaacauuugcuucacaucucaucaaaucuucugcaucaagccacauc\n", + "guacaacuuccggcuguaaagauggcggcuuccuagugagucggcggcugauuuagaaggagguucaggcuacggugagccgaag\n", + "agcupauuauccgcaugcgccaccacgcccggcuaauuuuguauuuuuaguugagacpuuucucc\n", + "guacaacuuccggcuguaaagauggcggcuuccuagugagucggcggcugauuuagaaggagguucaggcuacg\n", + "uguaaagauggcggcuuccuagugagucggcggcugauuuagaaggagguucaggcuacggugagccgaag\n", + "ugcgccguacaacuuccggcuguaaagauggcggcuuccuagugagucggcggcugauuuagaaggagguucaggcuacg\n", + "ucccaaagugcupauuacaggcaugagccaccgugcccgaccguaaccaaauguuuuuaaaacuccaapaggauucuggcuuccccuguccguguuccaucuagccacacaggagcc\n", + "gccucuccgccuacuccagccuccgccgccucagcuucccgagcgagcccugcggccgccggagcagcucccgcggcggagcaggagccgg\n", + "pagaagapcuagagcaaagaccgagagccggagaaaggcgaaaggcgcggugagcaaucgccgacguagagapcagcccuccgcgcugcaauauugagaaggcacccgcpacgc\n", + "ucucacuguuagaaaccaggaagaucagaggcccacaauagcuucccacgaacucagagcagaucuuccaaccupaagaaag\n", + "agagccagcccagcauuaaccaaacaaagagaagcagaguggauccugugcuaauauupaaaaccaggcaacaggacucauuupccuuuauugugaaaac\n", + "aupaaacugaggcccagaauugcuaaguggcuugcuugaguugacacapagcuccaggacucacccucag\n", + "ggcaagcaugaguuugugaaugacguggcaucacugupagcugucgaccgaggaggagauccaccacuuuaagaaugagagccupc\n", + "aguacgcgguucuuggcaucupugagcguggcupcugccuccuucccaucuppugcuaccugcupccaggauggacpagccaccagcagcucccucaa\n", + "gaguggccuucccgguuggcgcgcgcccpcggcggcgcuggaggagcucgagacggagccuaaguu\n", + "gcuugcucgcgguggcuuguggcuccuuccugcggugcuucucucuuucgcucaggcccguggcgccgacagg\n", + "ppcppugguuuggaaaaaugacucaguaaguucagcgcgcccgcuccggccggcccugcgccucccgccgcgcccp\n", + "gcucgcucccucccccgcgcgcccucccucgccgccuccucccgccgccugcggccccccccucgccpaccgagcgcgcucgcuccggcgccggccucgccuccucgcagcagcgcc\n", + "acagaggugcgaccpucccggccugagucgcggccacccgcaggucugagcugupcugaggcagcgcagccgcugccgcapugcgcgaugccuugaaccup\n", + "cgcaggucugagcugupcugaggcagcgcagccgcugccgcapugcgcgaugccuugaaccup\n", + "aggucugagcugupcugaggcagcgcagccgcugccgcapugcgcgaugccuugaaccup\n", + "gugagaugaaucucuaaucgguggccgccagacacccgcggcgaaggcggcucpcucpcuccg\n", + "gcucaguccuccaggcgucgguacucagcgguguuggaacuucguugcuugcuugccugugcgcgcgugcgcggac\n", + "ugcucaguccuccaggcgucgguacucagcgguguuggaacuucguugcuugcuugccugugcgcgcgugcgcggac\n", + "gcuggagugcaauggcaugaucuuggcucacugcaaccccugccucccagguucaagugauucucccaccucagccucccagguagcupauuacag\n", + "ugaugapuccuucuccaucucccagcccuccuggcuucccucaucuugcuucaggcugcagcaucuaccacaagag\n", + "gagaaagcuuugugguuuggucucapaaguagcaggcgccgguugagagaacuacggcccugucggaagguaaccuccggugcaaacgaccaucggcggcaggcgagcg\n", + "aagcuuugugguuuggucucapaaguagcaggcgccgguugagagaacuacggcccugucggaagguaaccuccggugcaaacgaccaucggcggcaggcgagcg\n", + "gcgagacgcguacagacucgugaccuucacugauugguccguagacccpcgccacggaaggag\n", + "agcuaaaaaagucccuguacgccaucuucucccaguuuggccagauccuggauauccugguaucacggagccugaag\n", + "agaaagcuuugugguuuggucucapaaguagcaggcgccgguugagagaacuacggcccugucggaag\n", + "cuuuucggaggaagauccuugagcagccgacguupacaaaggauuuggagaaacccapcuaaagucacguuuuuccuccuuuaagacuuaccucaacacuucacucc\n", + "gcauuuggaaacaccaccgucugugucpaaagcagaauaacucuccaguaucucgucauuagcuugcuggaagcaggapcu\n", + "aaccagugucuccuguaccagcagaagcuccagaacucucacccgauugccugccucugcugcgucuuugcccacugaacagcc\n", + "agugucuccuguaccagcagaagcuccagaacucucacccgauugccugccucugcugcgucuuugcccacugaacagcc\n", + "ggaucugcucccgccgccgccgccgccgccgucgucuuucucugucucggcugaggcagccaucuuucucuugccgcgugcugguguuggaggacccucccugcuucag\n", + "gccgccgucgucuuucucugucucggcugaggcagccaucuuucucuugccgcgugcugguguuggaggacccucccugcuucag\n", + "gucuuucucugucucggcugaggcagccaucuuucucuugccgcgugcugguguuggaggacccucccugcuucag\n", + "gguacagcucgcagaaagaagaaggugguacauagaacagccacagcugaugacaaaaagcuucagaguucucuaaaaaaacuggcugugaauaauauagcugguauugaagag\n", + "gcaaagccgaccgagacggagccgcugucaacucuccaacucagcucagcugaucgguugccgccgccgccgccgccagauucuggaggcgaagaacgcaaagcugagaac\n", + "agacccgccucaaacauggcggcgcccagcgcgcgaggacgugauccgcuucugcuccggcuuggauuguagccuugacgaggucugagcgaccauggaccggccpuucguggcagcgcuggug\n", + "cugcugcauuuuuuaucaccuaugaauaugugaagugguuuuugcaugcugauucaucuucauauuugacaccu\n", + "agacaggaucuugcucuguugcccaagcuagagugcapcaguggcgugaucauagcuuacugcaaccucaaacuccupcccaa\n", + "puuuacaguucagaaucacgccggccucauucuaccgcugcucucuccuggaucucggccacggaucuuuugcucgcgaaaguuccuccgucuagcugcacacaacgcugcugcaggaaaccgag\n", + "gccucaaacauggcggcgcccagcgcgcgaggacgugauccgcuucugcuccggcuuggauuguagccuugacgaggucugagcgaccauggaccggccpuucguggcagcgcuggug\n", + "aaacauggcggcgcccagcgcgcgaggacgugauccgcuucugcuccggcuuggauuguagccuugacgaggucugagcgaccauggaccggccpuucguggcagcgcuggug\n", + "gccucaaacauggcggcgcccagcgcgcgaggacgugauccgcuucugcuccggcuuggauuguagccuugacgaggucugagcgacc\n", + "agacccgccucaaacauggcggcgcccagcgcgcgaggacgugauccgcuucugcuccggcuuggauuguagccuugacgaggucugagcgacc\n", + "gcuggupuagcagguguuucuguugacuugauauuauuuccucuggauaccauuaaaaccaggcugcagaguccccaaggauuuaguaaggcuggugguuuuc\n", + "agacagacccgccucaaacauggcggcgcccagcgcgcgaggacgugauccgcuucugcuccggcuuggauuguagccuugacgaggucugagcgacc\n", + "gucuaagcuguuguaccaaggagcccccaaaacacaguggcccaagaaagauacaaauugauuucuccacauaacgcuuuggaagauag\n", + "uagagacapuuucaccauguugauaaggcuggucucaaacaacugaccucaagugauccacccgccucggccucucaaagugcupauuauaggugcgagccacggugcccagcupuacag\n", + "ggcuugcgcgcgcpagucapucacggcggcguaggcuguggcpaaacgcuguuugaagcgg\n", + "acuaaugagcgacgugcaccggcgcgcacggcccggccaccgcugcggcugcggcggccggcggcggcccguugucag\n", + "guggagccuuugaauuuuuuaaaagaccauaguaaucagaucuacuugaaaaauuaagugaauugauuugguuggaaugcucuuuuaccgaugcuuuaacauacagccacuag\n", + "auucccagaaguugugcaugaguuccugugaggagaguuggcaucuuggaaaucaaagacgguugugaugcaguuuuuugauaugaggauaacag\n", + "acagcggagagaauaaucgaaugaaaacugaagcuuucugcuuuauuccuuuucuccuucuccuuucagucag\n", + "gaccaguccugccucuguuguagaagacaugugguguauauaaaguuugugaucguuggcggacauuuug\n", + "acapucucacucugucacccaggcugacacgaucauggcucacuacaaucucugccuuccugccucaapuucuuccuugagcaccucagccucccaaguagcupaccacag\n", + "aaaugaucaaguguupuauaagccaaggagcugagagapagaccagcgcaggucugaggagcugagaapaggcuuacgugaagg\n", + "aaaaugugucaucucauccupacugcccuuggccacugcugaaucuguuuugaaaccucuuugcag\n", + "auuccapuuaagaaauggaupucacugagaucuagcacccaguuguccupcuucugcuuacpuuauugagaugauagaaggcccag\n", + "cccpcccgccpaccccccggagccgccucggccgcgccggaggapcpagaggaccaugugagupcuccggagccucagcgccgcgcag\n", + "ccucggccgcgccggaggapcpagaggaccaugugagupcuccggagccucagcgccgcgcag\n", + "ggucucacucugucacccaggcugacacgaucauggcucacuacaaucucugccuuccugccucaapuucuuccuugagcaccucagccucccaaguagcupaccacag\n", + "agagacucuccgaggcggcggcagagacagaagagcpucpccggcugaccaggaaccupcgagcagcggcpcccgap\n", + "auucugaaggaagauuuccauuagguaauuuguuuaaucagugcaagcgaaauuaapaaaauggauguagaaaaugagcagauacugaauguaaacccugcag\n", + "gguauuuucccuaauucuccauggugcuucaauagcauguuauuaucauaaaaaugaacaguuuuguggaauag\n", + "paguaaucagcaacucapaccuguacgagucuauagccuaccuggucgagaaaacuauuccucaguagaugccaauggcauccagucucaa\n", + "agcucpcpagcpcgcggcpaaggagcpcgacccggugugupccagcggagcuccg\n", + "aagcucpcpagcpcgcggcpaaggagcpcgacccggugugupccagcggagcuccg\n", + "guuugaucacuaugaucaucucacccacagacagaggaugcapcuucauuuuuguucccaaaaacapcaccguagauacguaaa\n", + "aaaaaaagaggcaugaaggugaapagugguguaugugucauuaggacpacccacpucucuuguucaucagccucagc\n", + "gaggucacaagcucuggugccccaaaauggcucugguccucagauauaguugguugccacccupagugagaggaaccaggaaagcag\n", + "auugguggcpcggcpagcggcgcpcgcgugcpcggcggcagcggcggugacggcagccuaggccpcgapcc\n", + "cccagcaaagagcagcacacagcugaaagaaaaacucagaagacagagcugaaaaagaaaacuggug\n", + "cccagcaaagagcagcacacagcugaaagaaaaacucagaagacagagcugaaaaagaaaacuggugauggaucucauuccaaacuuugccauggaaac\n", + "accucupcagagaaacaaagcucuauaugcacagcccagcaaagagcagcacacagcugaaagaaaaacucagaagacagagcugaaaaagaaaacuggug\n", + "gcacagcccagcaaagagcagcacacagcugaaagaaaaacucagaagacagagcugaaaaagaaaacuggug\n", + "gugcaaucgcpaagccapuuuccagcuaggacacagcaggucgugauccpucpacacugccuggcagaggcugcgagc\n", + "gccapuuuccagcuaggacacagcaggucgugauccpucpacacugccuggcagaggcugcgagc\n", + "agugcaaucgcpaagccapuuuccagcuaggacacagcaggucgugauccpucpacacugccuggcagaggcugcgagc\n", + "gugucauugaggcagguccapccuuugcugacccucpcuccuucaccccugccccgagccuuccccucuugccupcgacuucc\n", + "ccpauuggupacggauggcucugauguccuuggcuggcuccgcuugucccuugacucugauuugagucagaggaaaucaucugagcg\n", + "aucugccgacaccccaggccaucgagccccaggccaucgugcagcaggucccagcccccagucga\n", + "aaaaggacagacuacuucaaaauagaaaaggaauucpcgagccagagapcccacacgacuagaaggacgacugccuggcgcgauacaaaaau\n", + "gacuacuucaaaauagaaaaggaauucpcgagccagagapcccacacgacuagaaggacgacugccuggcgcgauacaaaaau\n", + "gugacccgcgcugucccgcgcugaaggcggcggccucggauggacugaaccacugugaaagcccgaauppaaacaggcagugacggccgcuapaaggacup\n", + "guauauuuuccuggaguacgcguccccugcccacgcuguggaugcugugaagaacgccgacggcuacaagcuugacaagcagcacacauuccpucaaccucuuuacggauuuugacaa\n", + "auggcupcuguagccgucgcggcgcgcggugcggccupagagucggaagcgcggcggccgcggagcccugcgaguaggcagcguupccc\n", + "acucauugugucugugucgaggcgucpapccuaaguccgugugcggugcccuucggccggccugagccccagagucagcuccccuuucucgcccagcgcccccaggccgcucccpcucacg\n", + "gagucucucucugucacccaggcuggagugcaguggcgcguucucagcucacugcacccuccaccucccagguucaagugauucuccugccucagccucccgaguagcugagauuacag\n", + "auuguaaccacaucagcaaagcacuguuaguauauaugcugaacaaauguggagaaaucgcuguuuuacauaggaaaccauggugauuugccccagaauguguauccag\n", + "gaauaguaaagaaacacaucauaaaaccucccaggacauaaaggugagcacagacccuguuuggaucaagucaguuccuggagccuga\n", + "apcuuucuguaucccuagguuucuugccuugauguacuggagcaaucagaucacacggcggcuuggaga\n", + "apcuuucuguaucccuagguuucuugccuugauguacuggagcaaucagaucacacggcggcuuggagagugagugcaagguuuu\n", + "guuucuugccuugauguacuggagcaaucagaucacacggcggcuuggagagugagugcaagguuuu\n", + "cagagcacguccccuuccuccuggccccuggcacgugcuuccuccacgcacgucauggcugacucugcccucucaccuuccuuucagaacccapacc\n", + "agcguuauuagaaaugcaagagagcuggaggcucpuguagcugagguugaaaggugcacggaa\n", + "cugcgccgccgcgccgccgcuccgcccccggucpuguguggcugcgcgcgccpagagaugcugag\n", + "acuuucacagaacguacugaaucapccugcauccccgugccgugccgagccgacggagaaauggacuccucuucucgcuccuguggaguuucgucuucugg\n", + "agagaggcgagcggagaguggaggaggaggcggcggcggcpagcgguccccaggaaugucgcugccgccgccaccgccpccgcugccguugaggaggagacggaggagaccgacguuguuag\n", + "cagaaaaagaaaacuaagaacuucaauccaccaacacguagaaauupaaaguaauuacuuup\n", + "gcgcgcgucccguccaggcugcgccgccgcgccgccgcuccgcccccggucpuguguggcugcgcgcgccpagagaugcugag\n", + "cpupuugucgacacguucaacccguucugcuggcucgagaacgaaguaggccgucucgcucupucuccaggcccgcgaccguccgccagucgucccgag\n", + "aaucuccggccugugaaacugugapauucggccaagacguccucuucccucugccucccacccaggccacucuucaccuccacc\n", + "aggccaccuucuuccaucuucaaaaccuacugucucugcauaagaacucucaugauuauaugccggccgcccagacaccccagg\n", + "gcugacuggcpupuugucgacacguucaacccguucugcuggcucgagaacgaaguaggccgucucgcucupucuccaggcccgcgaccguccgccagucgucccgag\n", + "cuacaacaaaucaucgucaaccuguuccaccuucuccagucugguagcaaaaapugucucag\n", + "cgacuagcpcgcggcccccapuggacuccccgccagccccggccuggaggcuccgcccgcccccgccupcggaaggaacgcggagcggcucuggccuupucugcggcggcggcgucgg\n", + "gcgcagaggccucupuagguggcucaaccccgccucucaguugaggacucugaaggcuguuucuguggcgcuuccccugcgagg\n", + "aacagauuuuauuauuacugccagucaugauggacaugucaaguucuggaaaaaaauagaagapaauugaauuuguuaaacauuuucguagucaccugg\n", + "gaguuauugagaguauugcaguuagcucugapagcauuguucuguucugupugaugauaaagca\n", + "aaggcuuuaguucaggagugguguuaauguauuaauguguupcgcgagaggaaggcggugcuuauuucgaaucaug\n", + "ucuuagaguuugaaagagucuaucuugauaaucuccccagugcauccauguaugagcgcaguuacaugcauagagauguuaucacccaugugguaugcaccaa\n", + "acaauggaagguaauacagagaauauagguuuuguggugugguagauugaaagccacucuagcuau\n", + "gugcaguguccugacuguaagaucaaguccaaaccuguuuuggaauugaggaaacuucucuuuugaucucagcccuuggugguccaggucuuc\n", + "agacaacagcuucugagcuuuggacuaaucacagccucuguucucagcaggagccccaacacugagaccag\n", + "acacuaagugaagcuucuccauucuguaagcuuuccpaacauccaaggcaagacuggcacccagcacagcag\n", + "aucaguaggcugugcaggcugcgagcucguugacgcaucucagcccacucccuuguccucccgccuggcgaag\n", + "gccgccpcugagagaagagcuugcpuuugcgguugauggccccgacugaapcuggaggcggugu\n", + "gccguugccgccpcugagagaagagcuugcpuuugcgguugauggccccgacugaapcuggaggcggugu\n", + "ccpagcgcgcgcgccgccgccguugccgccpcugagagaagagcuugcpuuugcgguugauggccccgacugaapcuggaggcggugu\n", + "agugaugucgagcgucgagcucccaaaaccgagcuggugapcugcagguggcggcgcagucucgguaggcggu\n", + "uuuuagacauuucagguggcagaauaaauucaauccuuguuucuccaucuuaucgaguaguagaaguuaguuacauucucuuugaacucauc\n", + "gcpaaaaguucagcugagagauauaaaagagcagucuuuccagcaccugcaaauccagagcggcpcacugacpcacuugcaccguguggacagacucuccgguucu\n", + "acauuucagguggcagaauaaauucaauccuuguuucuccaucuuaucgaguaguagaaguuaguuacauucucuuugaacucauc\n", + "aagagaagaaggagaguggccacguugauucagccaagcaccuccaggagguccccucuggauguccc\n", + "gaguagcugaauacaggcucaaagcaggcgacpacaggaaugagaggauggaugcuggcapcuuggag\n", + "agucugagaagccaacupccaaacaaguuuuagaaccucuacuggcugaugccaacaucaucagagaugaacuguucuuaccagaaacuucucugcuccugacaccccaccucuccccag\n", + "auucucaguaaagacacacuacguaaucaaagcuacugcucugcuuugcugagcuuugagaugaaaggucuccagguupaguuaagcuugucauucucuaauuugaaaa\n", + "ugcagguagguagaucgcugaccacauuugcucauuucuggauuauucauucaaaggaagcacuaugagucaaucauupcacagag\n", + "gaaacugguaacuucpaguugagccacgagcuguugugcauccagagguggaauupcccg\n", + "aggugguuugugcucccccuacugccuauaucgacuucgcccggcagaagcuagaucccaagauugcuguggcugcgcagaacugcuacaaagugacuaaupcuuuuacupagaucag\n", + "gacucccgccuuccacggaapaccgagcccgugccaaacaggcugagcgauuupagugaggagccauccuaccgcuuuccccaaccuggaaacagcaaagcgcaaggccucugagucaguuag\n", + "auucucugagccgcugcugccccugupaapaccucgagugugaagcauccuucccuguagcugcuguccagucugcccgccagacccucuggagaagccccugccccccagc\n", + "uuuauagcagcaguagaaauauaccacccuagaggacacaccuccuuuuagcuagguaccuauaaauguccaggauuuucuauucaauugagaagaacccagcaaa\n", + "auaccacccuagaggacacaccuccuuuuagcuagguaccuauaaauguccaggauuuucuauucaauugagaagaacccagcaaa\n", + "cucucgccgcgucgccggugccugcgccucccgcuccaccucgcuucuucucucccggccgaggcccpaccagagcgagaagcpacc\n", + "gucauuucggagcgacucagcgccugcccgcccucucgccgcgucgccggugccugcgccucccgcuccaccucgcuucuucucucccggccgaggcccpaccagagcgagaagcpacc\n", + "agagcgucggcgccacggccgagaacacaucuucgccgccgagcugagcupccgagccggagguuguggugucugacugcgcupcacccucpccgcagcg\n", + "agcgucggcgccacggccgagaacacaucuucgccgccgagcugagcupccgagccggagguuguggugucugacugcgcupcacccucpccgcagcg\n", + "acacacacacacacacagccggaguccccucccgcagcaaccccaggacacgcgugguacagcccuugcugucgucccgucgaupuuuapaugaagg\n", + "cgagapapaggcggacccgcgaugcuuaaagaccucuccpccucpcuacccucaccggcucgccccaggcguaccagcggccaccggugcuccag\n", + "gcgagcaggagcccaggccaaggcuggagacgcgcgcuggcuuagaaaggcggccuucagagagcgcagcpcgagugcagcagag\n", + "apcucgagapapaggcggacccgcgaugcuuaaagaccucuccpccucpcuacccucaccggcucgccccaggcguaccagcggccaccggugcuccag\n", + "auugccgaggaaggcuugcacapugaaagcuuugcuucucugcugcuguaacapacuagcacagacacacggaugagupucauuuccagauauuaggucacagcagaagcagccaaa\n", + "agucauugccgaggaaggcuugcacapugaaagcuuugcuucucugcugcuguaacapacuagcacagacacacggaugagupucauuuccagauauuaggucacagcagaagcagccaaa\n", + "cucuccccgcccggauuaguggcagcuuggccugacucuccpcuccuucccccgcccccgccugcugcccuccccupccpcugcuccgcccppcacugugcuugcccag\n", + "agugaaugcguagucccagccucagcacapagccaccuugaagcucucaaauaucacuguugugaauacagagapaaaaccaacuguaacgugccacccaaau\n", + "aaagcucauuacuaguccuguccagcaacgugccucuccuggcccuagaguucuuggaaauagcccaggccaaagagaaggccuuucucccc\n", + "gauucacagaacccaggcuggacpacuuguggcgagcaguccagcacagccucacagugcagagcaugagcuuuggagccugcccccacccuagcuuugugaccuuaa\n", + "gaaaugaugccagugaaugcguagucccagccucagcacapagccaccuugaagcucucaaauaucacuguugugaauacagagapaaaaccaacuguaacgugccacccaaau\n", + "gaggcgccggcggccgugacgaggcgcucccggagcugagcgcuucugcucupcacgcauggcgcccgcacacggagucugaccugaugcagacgcaapuuaau\n", + "gcuucugcucupcacgcauggcgcccgcacacggagucugaccugaugcagacgcaapuuaau\n", + "pcpcgcggcgaggcgccggcggccgugacgaggcgcucccggagcugagcgcuucugcucupcacgcauggcgcccgcacacggagucugaccugaugcagacgcaapuuaau\n", + "uauauuuugaauacaucugucuucauaaaauacaccauguccaaaaucuaaaapccaauuccaaauuauuccaccagcuuugaapaauugaagcaagaauaacaaga\n", + "cagaagaauagaaggaaggugauaggaugugaugauagaauuugugauagccaagcaacaacuuuuccuaauucggc\n", + "ucpugapccguccgcggccucgcuuucgccuccuccgagccpccggcgauggccgcagcugugaggcgag\n", + "cgucuuugcagcagaagaauagaaggaaggugauaggaugugaugauagaauuugugauagccaagcaacaacuuuuccuaauucggc\n", + "ggacccguggcccacgaagcucaucuuugaacuguccccgccuucucccgccuugacuugugacccuaggcccuuupcgccucugacccagcuagccagaucccggacccaaacc\n", + "uucuaauccccacaaugaccccagccuaauaauacaauaauccccaaguagaaccapcccaaggcccccucgucagcupcucccaccuccaagcugacgcccucaaccacucugcup\n", + "ggaguuuauagcaucuguggauuuugguacccacggaggugcuggaaccaaucguugaggauuccaaggacaacucuaugaugcaggcacaccuguccuagcugcucaapucgupaugcag\n", + "aggugguguggagccggaagcaggaagcagccugugcuccccaggaccugccugguupaauuggaggcuucuaggag\n", + "ggagccggaagcaggaagcagccugugcuccccaggaccugccugguupaauuggaggcuucuaggag\n", + "agagcugagagaggaaaagaacacagaucucgcaugguucagauuuuucuuuuuagguccaggaguaag\n", + "caccuuuauuuucugucuuucaacuggcaagagucauuuugaccagcagguuaaucaacucuaagacagauccucacgcaaag\n", + "ggaagcgguuggcggcgcucggaagcggccgcggaucpaauucugcuggcgcugcagcugcaga\n", + "ggucauuugaagacucucucggaagagauagcgucuugcugcaaccugcggucccagcagaaaaaccuugugauccuuguugcpcgac\n", + "gauuuggaaapcauggcaggaggucucaucucugcuucacaaugccgaugauuuagcupaggacccaaa\n", + "gauuuggaaapcauggcaggaggucucaucucugcuucacaaugccgaugauuuagcupaggacccaaaaugcuggaaaagcugaupugcugauucucuccagcuuuucag\n", + "caaaggagacagaagaaggaagagagacgguaacaaggaaagaaggauggaagagaaggcaugaggacggcuauuuggaa\n", + "caguuaguacacugaaauucaaagucaugcucauaacuguuaaugaaagcagauucaaagcaacaccaccaccacugaaguauuuuuaguuauauaagauuggaacuaccaagc\n", + "uuaguacacugaaauucaaagucaugcucauaacuguuaaugaaagcagauucaaagcaacaccaccaccacugaaguauuuuuaguuauauaagauuggaacuaccaagc\n", + "caugcucauaacuguuaaugaaagcagauucaaagcaacaccaccaccacugaaguauuuuuaguuauauaagauuggaacuaccaagc\n", + "acagcgucuuguuaguccucucccuguacuccgcaauauuuucuuucuuucucccuccucuccuccauuuguuguuugauguuucccacucuuugaggaagg\n", + "gguacaaguugaauucuauaugaaugaaaauacauuuaaagaaagacuaaaauuauuuuucauaaaaaaccagagaucaa\n", + "gucuaaggauacgccuguucaauuuuucucucaaauuacuaagcugcuuauuauacauaauccgaguacuacuagaaaacccuucacaaggaaaugaaug\n", + "ggaaacaucupaacagauuuuacgaauacccuucaucuuggaaauaauuaaugcaguucccuucauuaucuca\n", + "auauucuggccuuccuuaaggaaucuauuugucccagucuuucugaacuguuggcuugccaaacaugccuuggaaaauaugauu\n", + "aaugaucuacacagagccauucagcguacacagucugcaauguuuaaucaaguuuugauuuuaauaucuacauuacu\n", + "guccgcccggcuugaggcccgcpagcgcggcgcaauucgucggcccgcppcggccucccggcaucuucgcggcgaccaaggacuaccaggaapagcggcup\n", + "ggagcggccgcucguccgcccggcuugaggcccgcpagcgcggcgcaauucgucggcccgcppcggccucccggcaucuucgcggcgaccaaggacuaccaggaapagcggcup\n", + "puaacucauucgacuguggaguucuuuuaauucuuaugaaagauuucaaauccucuagaagccaaa\n", + "acuuuuauaagccagccccaggcaucccagagcaagauguagcuguguagucuccuuccauagcugcucuaapcuggcaacauggcucagcaggcuugccccagagcc\n", + "aagauguagcuguguagucuccuuccauagcugcucuaapcuggcaacauggcucagcaggcuugccccagagcc\n", + "acccgcccaggcuuuuauccggcaccggcagcgucuuccuuuccucccccgucuauggugguggcggcggcggcuccucpcggcggcggaagacgaggcugcggcguugcc\n", + "ccccgcccucuccgagcucggcuugaggcpcgcpcugagaguccpaucccpccagucgcggccpacaucpcgcugcggccpacccgcugcugagauagacag\n", + "acacuuccuuucuuuccucgcaaagaaagacagcuauugacuagaagcccagaauugcccccaaguuccgaccaccagcucgaauucuu\n", + "cgaaaugagagcaaaaapagagagcaggaaagcgagcacaggcgaguacaguauacaaaguguuuugaguuucugacuggcgugccggaaagaucauguuagcacacccagaaacuucacacg\n", + "augagugucagaagugugaapugccuguucugaaucccagagccuccucucccucugugaggcuggcaggugaggaagg\n", + "gaaucccuggagcuagcggcugcugaaggcgucgaggugupcacuuggacagaacagucaggcagccpagcucugccagcuuuggugaccuugg\n", + "cggaggacuaugagcugccgcgcguuguccagagcccagcccagcccuaccgcgcgcggcccggagcucuguucccuggaacuuupcacugccucupaccccugccggccagcaggcaggaug\n", + "gcgucccagauguuguggaacugucccuggaucuauagcucuucaccgucucuacuuucuuccuucuaagagauccugaaaccucuguc\n", + "agaagagaupcuaaacgccapaauccgucccuuggccugaggagcuuggagcuccuaggcup\n", + "cuggccgaaaacaaacaaucacugagaagucucaaagaaauauaccacgugapaaaaaacupagaagauccggaauauuaucguuuuuccu\n", + "agauugcuuugcauaaauccaccccuguuugaaaucuaucaagucuuguuaagcccaacacaacaucauguagcacuuauaggaauaaaaggacuu\n", + "cgccccacagacggcggcgcagcccgccgcccuuuucgaggccggcccccccucucacgcgccuugaag\n", + "cugagauuuagccgugcgaugcccgcgcapcpccgcpccapaggcgcucagaguccggagccgccgagcgag\n", + "ggcugugucuggcugucccugauaaaacugugagauggugugcagugucggagcaugaggccacuaagugccagaguuuccgcgaccau\n", + "acagaagcgaguccgacugugcucgcugcucagcgccgcacccggaagaugaggcucgccgupagcccugcuggucugcgccguccugg\n", + "gcaaacgaagcggaugcugugacacuggaugcagguuugguguaugaugcuuaccuggcucccaauaaccugaagccugugguggcagaguucuaupucaaaagagg\n", + "aacagccgcccccacugcccccucucpcaugaaccgagcuucuuguugccgcccgcugcccuacccgccgcugccgccgcaucccgacucupccagcgcupaac\n", + "agacgcugucgcugcgcacaccuggccucugugccgccugcucccugcucguccuccccuccccacccucacccaccugcc\n", + "ggcccgccaucaccggccucagagacagccgcaugucupccagucacggcucuuggccucupccccaccguugcupaapag\n", + "cucucucuggucggaggcggcgguaauggcggauggupuuguggcgccggcggcggcugcugugapacg\n", + "uccaggcgcccgcccgccgcgcgugauucucgccucgccgcagcccagcccugcgcgccuugcccggcggcccccgcccggccgcuccpccccuggccccgcggagcg\n", + "cucgccucgccgcagcccagcccugcgcgccuugcccggcggcccccgcccggccgcuccpccccuggccccgcggagcg\n", + "gauucucgccucgccgcagcccagcccugcgcgccuugcccggcggcccccgcccggccgcuccpccccuggccccgcggagcg\n", + "gugauucucgccucgccgcagcccagcccugcgcgccuugcccggcggcccccgcccggccgcuccpccccuggccccgcggagcg\n", + "ggauaaauugacccuccaguggacagcucugagaaguguucuacauggcucuuuggaagguuccagcaggauagagccccaguuguccauagag\n", + "agagcucpagagaagcuggacugcagcugguuucaggaacuucucuugacgagaagagagaccaaggaggccaagcapcupccagaggugccaac\n", + "gugaacaucaaguuggugcuauggcaaggcupaaacugcagccugacuupcugcccugaucauccugcugcuccccggaa\n", + "acagcugcuguugucugcgguauucaaaaacuuuugaaacacugcauguccaacaaaauuuauuuuuugugugaau\n", + "auuuuugacauguuauaaaaugcaagucacagcugcuguugucugcgguauucaaaaacuuuugaaacacugcauguccaacaaaauuuauuuuuugugugaauguaaguuuuuauugagg\n", + "auuuuugacauguuauaaaaugcaagucacagcugcuguugucugcgguauucaaaaacuuuugaaacacugcauguccaacaaaauuuauuuuuugugugaau\n", + "acauaacuguucguuucuaacguggcuguaguuggcauucucucucauaccaagauaccuuuugag\n", + "uggccacaaauucuauuaaagcagaagaaauaguggugaaccauaaaagagaaccaguuuccucucuauucugcaauuuagaggaaaaauuuucauccaaggacagaucag\n", + "ggccugagcupcapcggaggcpcucggcugucuccpcugccacgcagagcpcuucguggcgugg\n", + "agauuuuugacauguuauaaaaugcaagucacagcugcuguugucugcgguauucaaaaacuuuugaaacacugcauguccaacaaaauuuauuuuuugugugaau\n", + "gagcupcapcggaggcpcucggcugucuccpcugccacgcagagcpcuucguggcgugg\n", + "ggcucgcggcggaaaaguugcpcauagacgagcggccccpacpcagcuagcgcgacccugagccggcgcccgugguccggcc\n", + "auucagaguuccagacaggcacuucacucgcggcugcgcggcccugucaggapaacgcagugccaggugccugacucccagag\n", + "ccucaguccucaucaccuguguacggcuccagugccaaaacuuccagugucuccaacccucaggacaguguuggcucuccgugcucccgagupugaggaggagcacgucuacag\n", + "gcguuccguuccpccgaggcucgcggcggaaaaguugcpcauagacgagcggccccpacpcagcuagcgcgacccugagccggcgcccgugguccggcc\n", + "auucucuccgcguugcccugcagauucagaguuccagacaggcacuucacucgcggcugcgcggcccugucaggapaacgcagugccaggugccugacucccagag\n", + "guuccpccgaggcucgcggcggaaaaguugcpcauagacgagcggccccpacpcagcuagcgcgacccugagccggcgcccgugguccggcc\n", + "cauucgccggaggcuggaggaggcugacccgcguccccgcccagccugcuccuaugcgguacuugaagg\n", + "ccpcppcpcucuauuucagcagcucucapccuupcucaucccgagucccpcucagu\n", + "agucaaacagaugaaaucccuguauugacauuaaaagauaauucuaaguaugguaccuuuguuaaugaggaaaaa\n", + "guggcucccpagcgcgcacgucccggagcccaugccgaccgcaggcgccguauccgcgcucgucuagcagccccgguuacgcgguugcacgucggccccagcccugaggagccggaccg\n", + "gagcgcgcacgucccggagcccaugccgaccgcaggcgccguauccgcgcucgucuagcagccccgguuacgcgguugcacgucggccccagcccugaggagccggaccg\n", + "ugccgaccgcaggcgccguauccgcgcucgucuagcagccccgguuacgcgguugcacgucggccccagcccugaggagccggaccg\n", + "gcacgucccggagcccaugccgaccgcaggcgccguauccgcgcucgucuagcagccccgguuacgcgguugcacgucggccccagcccugaggagccggaccg\n", + "gcgcacgucccggagcccaugccgaccgcaggcgccguauccgcgcucgucuagcagccccgguuacgcgguugcacgucggccccagcccugaggagccggaccg\n", + "aaaaacaugauguucccuggaacaaccucccacaucacagauguaaagacuuuucuucucccaggaauucaaacuugaggcuacaugugcuaggaapacaaaccacacuaacag\n", + "gaagugguuaccuggaaggaaaggagcugcagaacuugauccaggagcuccagcaggcgcgaaagaaggcuggauug\n", + "cggcugaagauugaugcugccucauugccucagaagccccauagaccaucacggacgccaagcuuccgguaacucucacaguggagg\n", + "aagaaacagaucugcagauuauggaucucuuacucuaucaccaauuauuauuguugugauguugauguaguupagaugagaaaacaucuuguccucacuaagg\n", + "uccucccucccccuucuccuucacccccaagugucucccacgacugcccuccccgaccucuagcugacc\n", + "auugccacagccaaccggcucccacauaucugcacacacuuaaauacaaaggccpaapucagaccaccauccpuacucuaag\n", + "ggaguuucuccaccagcaacauggccgccgccugagaggagagccpccgccgccgucucugcagcccgcpuaacupccguugccgccguccgcgcucggcccccgcggagag\n", + "caccagcaacauggccgccgccugagaggagagccpccgccgccgucucugcagcccgcpuaacupccguugccgccguccgcgcucggcccccgcggagag\n", + "uugaggaaacugaagcacugagaagccuucauggagcuuacguucuauugcagaagacaaacaacaccugagcaaauagaccag\n", + "agcaacauggccgccgccugagaggagagccpccgccgccgucucugcagcccgcpuaacupccguugccgccguccgcgcucggcccccgcggagag\n", + "guguccgccggaguuucuccaccagcaacauggccgccgccugagaggagagccpccgccgccgucucugcagcccgcpuaacupccguugccgccguccgcgcucggcccccgcggagag\n", + "cagcaacauggccgccgccugagaggagagccpccgccgccgucucugcagcccgcpuaacupccguugccgccguccgcgcucggcccccgcggagag\n", + "cuccaccagcaacauggccgccgccugagaggagagccpccgccgccgucucugcagcccgcpuaacupccguugccgccguccgcgcucggcccccgcggagag\n", + "gacagucgcucugagcaugagcgucaguaccugcugugccccggcucaagcpuggagaacacggagcucgucaagucacccag\n", + "ucccagupcuaauccacaccaguggacuugaaacacgcuuupuugcuguaugguaguaugcuaaag\n", + "gcupcuggcccagaacucaccuapccuggucupucucccuggaggcuccugguaacaaacagccccaccccuucupugcugguaucc\n", + "aguaaauacggagaaucacgucgaacaccaguggcccagauacugucguggccgcgcaccuuuggaguuuupcaaagagaguuggauggaaggccgaacugg\n", + "guuaucauaaguuucuaucucucuucucauggcupccuuuauuuucucuugcuuuuuuaauuucagagucuccccccccuccuuacuccagauacccg\n", + "cagccaagcccapcuggccugaagcccccggacggcagugcccagcaggcagcgcccagcacccuggcucccaccucccaguggccccaaaggaaaacagcugcc\n", + "ggaagagugapaagcggagacucugcapccuccaaggccaggcuucapcupacucaguccugaggcacupagccaugapcuguggcapapcagg\n", + "agugapaagcggagacucugcapccuccaaggccaggcuucapcupacucaguccugaggcacupagccaugapcuguggcapapcagg\n", + "gcuuccgcccggagagagcuggccpaugaggcgccggcuuucccpucuucuccagcugccaccgcuuuacugcaaaacugacpcgcaaaaac\n", + "pagcgcuuccgcccggagagagcuggccpaugaggcgccggcuuucccpucuucuccagcugccaccgcuuuacugcaaaacugacpcgcaaaaac\n", + "gcccggagagagcuggccpaugaggcgccggcuuucccpucuucuccagcugccaccgcuuuacugcaaaacugacpcgcaaaaac\n", + "gccpaugaggcgccggcuuucccpucuucuccagcugccaccgcuuuacugcaaaacugacpcgcaaaaac\n", + "ccgcccggagagagcuggccpaugaggcgccggcuuucccpucuucuccagcugccaccgcuuuacugcaaaacugacpcgcaaaaac\n", + "gapagcgcuuccgcccggagagagcuggccpaugaggcgccggcuuucccpucuucuccagcugccaccgcuuuacugcaaaacugacpcgcaaaaac\n", + "pagcugagcaucgccapcpcggcapcgcggccucuccgccpuguaccaccugucgcggcgcgagaccucug\n", + "agcagcggcgccgccucccagaguucagacccaggaagcggccpapcaggagcgaaucpccgccgccgcc\n", + "gacugapugccgccgccaccacgccpacuguugacagccagaaccuuuaagcguaacagagucaccug\n", + "ucuggcucuugcugauugaauuccuuuggugcaguuuagcauguuccucuguguucugcaucuccuguag\n", + "uugaacagauuugcaguccaugagaaauacuuuccuguuucauapagcuuacuguuaauauuuuuauuuuacaguguaauguucaagcucagaa\n", + "gcagugcgcpcuggccgucgcggacgccgcuccpcagccgagccucugupagccpccgcggcggcgcpugcuccpccgaggccgcg\n", + "gcgcuggagcapugguggacpccaggcgcgagguggcggcggcugcpcugccpcugcuggagcgcgguucccgcuguggcgagcpaggcguccgcagapcggupugcug\n", + "upagccpccgcggcggcgcpugcuccpccgaggccgcgguaaaguuuagcuugaagaacgcggccgcgcuggagcap\n", + "gaaauacuuuccuguuucauapagcuuacuguuaauauuuuuauuuuacaguguaauguucaagcucagaa\n", + "gccuuccugaugcgcuugccugcucccuggucucucugcaupaaggaguguucccagcuugcaaacuccagcuuugccugugagaggaacaagcgucccugauccagaaggug\n", + "gccuuccugaugcgcuugccugcucccuggucucucugcaupaaggaguguucccagcuugcaaacuccagcuuugccugugagaggaacaagcgucccugauccagaag\n", + "ggccuggacguagugucuucaacaguuguaacagcagcugccauuugcugaaugacagcaugugucacacacucugcugaguauuacaggcauuuuuuucuaauacaaagucuuguagugugg\n", + "aaauacuugcagacuugaaggaauuaucagucuuucauuuucuaucaucaguguccuaugauaguuugugcuucccucccucaucccuuuguuc\n", + "auccuuccupuuccggcuccggcuccagcuccuucccucgccuacagaggcggcgcugucccugaucgagcggcpagcgag\n", + "uuuuuuccagaaauacuugcagacuugaaggaauuaucagucuuucauuuucuaucaucaguguccuaugauaguuugugcuucccucccucaucccuuuguuc\n", + "uagaaggcagucuugupugccuccucccccagccgcaacucaggucugcagcupuccugccuccuuccgagupcc\n", + "gagccgcaggcagagcguccggcggccpapacgcggagccacagcccgacgcacggacggapacgccggagcccgccugacc\n", + "agagcguccggcggccpapacgcggagccacagcccgacgcacggacggapacgccggagcccgccugacc\n", + "pccuuugucucucgcugucgccggagucccaggucugucuucacugcucuguguccucugcuccuagaggcccagccucuguggcgcuguuaccagcagguauuggagauccacagcuaag\n", + "gccuuugucucucgcugucgccggagucccaggucugucuucacugcucuguguccucugcuccuagaggcccagccucuguggcgcuguuaccagcagguauuggagauccacagcuaag\n", + "gucuugccaucucuaagcuggaccuggugaccuuuuuggapaaagaaagagcccuggacugugaagagugaggagaccauagcugcacagccag\n", + "ggacuguugacauuuapauguggccauagaauucucucuggaggaguggcaacaccuggacauugcacagcagaauuuauauagaaaugug\n", + "auuuuguuugucuuguaggcauuuuguucccaacaucaccuuuggucacccugugguagaaagccuucgaaagcagcuaggccaggacccuuucuuug\n", + "agcgguauggcgucpcugcaagauuggcccguccauccucaacagcgaccuggccaauuuapccgagugccuccggaugcuagacucupccgauuaucugcaccuggac\n", + "gcauuuuguucccaacaucaccuuuggucacccugugguagaaagccuucgaaagcagcuaggccaggacccuuucuuug\n", + "acggagaapcpccaaaacugcgcgcccaaucpugacgcucuagccuugccpacucgupuaacuugcuuuupagccagcggu\n", + "cuccggccgcguccccgccggcccugcagacguggcpcpacccgcupcacucccgcgcguacucggccgccugagcg\n", + "gcuguggauuccccuccaaguggaggaggaupcaggcupauccupcaaaucucugcugucgucagcaucugccacaguag\n", + "gucauggauugacggcagucaaggaaaaagcaggagccacucuacggauucaugguguaaauucuggaucuucugaaggagcccaaccaaauacugaaaacggagucccugaaa\n", + "uaacagaugcagccacagaucapcccugcagaaagcccacccacuuccccuucaucagccucucpu\n", + "ggaggcugcauccgacucggucacaaggaaaauggauucaguuugcaucucucccuccuuuaaacagcuucuccpucucagcaug\n", + "agcuagcuugaaugcggugacgguucucucaauucuucucaagagagcauauaapcaaaaacuggcuuugagacaccccuggaugaucacacacaaaacgccuaaua\n", + "augaggaaagguggugagagagapcacaucaaagacaauagugcucagagcagcuuuuacuuauuga\n", + "ucccucacagccgacgaggcaacaauuaggcuuupauaaaacgaggugcggagagcpcupcauuucuccccgag\n", + "cucacagccgacgaggcaacaauuaggcuuupauaaaacgaggugcggagagcpcupcauuucuccccgag\n", + "cucuuucccucacagccgacgaggcaacaauuaggcuuupauaaaacgaggugcggagagcpcupcauuucuccccgag\n", + "apcggauccupcuuccucccucuagaccaaapugcggcugcugcagagguggcugaugcag\n", + "ggccaggaccucguguguucccguccgccccucupacggcgccagcccggcaggccgccgaccguccupcucccgcgcagcgcg\n", + "caccguugccaggcagccguugccuggcgucgcpcguacucugcgcupcgcgcggaggccuaggcpaagcucgagcggcggcgcc\n", + "aaccgacgcgcgucuguggagaagcggcuuggucpuggucucgupuccugccuguuuagucgcuuucapuucuugagccccuucacgaccgucacc\n", + "gugacpugaagcucupcugcggucaggccggcgaccggcuupagcccauauucuccauucccgguuccpugaucguggagaggcggaagccccuucuggugcuaguagugaa\n", + "cgacggagaugcgcgcpccuguupugaaggagcagagcggccggaagcgcggapagccgcp\n", + "aagcgacggagaugcgcgcpccuguupugaaggagcagagcggccggaagcgcggapagccgcpauggaccgcag\n", + "uuuucuccauucaagauagucccuuuggagaugcgccccupucgaagccacuacuggccaucccagagccagaccuggugucccaag\n", + "ccccucucccggcccggugcacgcpcgcugcacgcpcagcaugcucggcuccupuuggaggcucugcacaaauuagacaguuuuuuuggapcpacacccuuuccag\n", + "aacagacccaaggccccgccaccgccggcuagcagcccgacagcccgcccgccuggcgagcgcaggcucuucuuccagaaacugcgaggauccgagcguacuguuugugcaccacaag\n", + "uuuaaaaagaaacagaaacauacacapuuggugaauggugccgaccgcggccaucgcaguuggaggcuauuuuuupp\n", + "agucguguuuuaaagaguacagugcpaggcugagapcgcaugcaacaacaacuuuuggaagg\n", + "paugcacagcacapagagagauugcgcauguuggucagucguguuuuaaagaguacagugcpaggcugagapcgcaugcaacaacaacuuuuggaagg\n", + "aguuggucuccaucgcuuuacauaaaaauggcugagugucuugucaugcuagcacugcauuaagugaugcauacag\n", + "aucuugauguggaagaaauggaggacucagaaccaaggauuuccaagugauuucuuccaaagcacaggaaucucacucuguuaaagcuggucuguucuaacugag\n", + "gcuggaguacaauggcgcaaucuuggcucaccacaaccuccgccucccpuucaagcaguucuucucucucagccucccgaguagcupauuacag\n", + "auuuucupcggugcugugcagcgcugcggccggacucacpuccggaagcaccauggacccccpaaacgcgccggcggcgaaggagccgagcccc\n", + "guugucuugaagugaggcucugcuguaguccuguucuucuggcucuaagaucugaauguugugaccacuaauuug\n", + "uugaaccaagacucugaggcugauaugcaaugucacuuacaacauuaaucagauacugcauuuaag\n", + "acggaguuucgcucuuguugcccaggcuggaguacaauggcgcaaucuuggcucaccacaaccuccgccucccpuucaagcaguucuucucucucagccucccgaguagcupauuacag\n", + "uauuucuggaguaguugupagagagauguacuccaaagagaagaggacucuugcuaugguucag\n", + "agcgcugcggccggacucacpuccggaagcaccauggacccccpaaacgcgccggcggcgaaggagccgagcccc\n", + "gucucuucaaagcugcggagagagugacucuccgaugagucacagcugcuucuuugcugauuggu\n", + "cucucuguucccugacagccgaugucagacccugccacuagccuccuuaacagaaguucccagcc\n", + "cagagguccacagacauccaggaagaugcagccagcagacaaagaauggcagccacccaagugcugapagcccucccggccauuucugucccagcuccaapucucuccacg\n", + "cggcugaggcgccucgaapcaagcgccaapcgcpcgccgccggaagcupcpcgcccagcpaugcggugaapcgagcggcgcggcggcugcg\n", + "uuccuggacuauuguapuugcugcccucauccuguuccugguagcacugcuggcucguguccucgucaaaagaaaaccaccccpacccacuguucuaug\n", + "uguaugcaguuuuuggauuuaccagcguggugaaccucaucauaggacuggagcaagauggaaucauugacpuuc\n", + "guccagacccgacggccggcccaguuccacgcacccagcgagcccaagcgccuucuccgcaccag\n", + "pagcagcggcucuggcggucguggcggucggagauccgagagcucugcuucucugaaaagcguguggcuuucuggacuug\n", + "uuucaggccacccacgagccagcpaaaggauugccagccagagaaagacgaacuccgaaguccca\n", + "gagcagcggcucuggcggucguggcggucggagauccgagagcucugcuucucugaaaagcguguggcuuucuggacuug\n", + "gcggucguggcggucggagauccgagagcucugcuucucugaaaagcguguggcuuucuggacuug\n", + "guuguggcccaggcagugcuauucauguguaugaacacagcuggaaucuucaucaguuaccugucagaccpcccagcgccaagcuuuccuggagacucggag\n", + "cucucccagugaagugauaucacugccucuguggacaagacaccuccaggagcccagcucacagccaccgguaccuucuuccag\n", + "uggugccugacuccucacccuuccccugccucacugcccugugcuuccuccugcaggacaagcupccuccaupcgccugapccaggcgccapccgupcacgagu\n", + "ggcacagcgccauuccugcaugupcuguggcagcagucaccaugcucuccuggaucguggcaggacaguucgcccgcgcagagcggaccu\n", + "agaaacuacaauucccaggaagcacucggcagccacaaacggaugugaggugaggcaggagcggcgaccuuugaaggaaaaaaggaaguguuuggacgacagcgagcpagaagcpucaa\n", + "agccacaaacggaugugaggugaggcaggagcggcgaccuuugaaggaaaaaaggaaguguuuggacgacagcgagcpagaagcpucaa\n", + "ccauuuucgcpcggaggcggcccggcpcccupagagcupacpcggcggccpuggccucggccacccgcuaauugcaucuuuucccggcgucucgucugcagapagcacu\n", + "gaagcacucggcagccacaaacggaugugaggugaggcaggagcggcgaccuuugaaggaaaaaaggaaguguuuggacgacagcgagcpagaagcpucaa\n", + "aacagugcaacccugaaacucguccuguugagaaaaaaauaagaucagcucuuccuaccaaaaccguaaagccuguggaaaacaaag\n", + "augaugaugacucuauagcugauuuucucaauagugaugaggaagaagacagaguuucuuugcagaauuuaaagaauuuag\n", + "agccggcaggcagcpagcccgagagagccgcgucpagugcggucuccauggcagugcupcgcagccggagagag\n", + "cccugccpagcagaaguggagacaucagcaggauggcaucggcaagucgcuccccucccpccucaucugccaaacgaucaucuccuccuccgaaguuguaugcaugacag\n", + "aguucagaaacugccgccguaacccaagaacaaaguugcaugcagagccaaccuaagagcuucaaaaucpauuccuuacugagaaag\n", + "guugcupcggagucagagcaguucuugagguucaaggaggcpagaccugagcucacgcuugcugagacagaagucacagcaggauuaugccccucapcaagaggaag\n", + "agugaccpaggaggcggcuacgccgacacaacggcpaggcugcagcggucugcgcgccpagcpcgcgcuggccgcgg\n", + "agccucucuguggaapcagccugcgccupuaccgaggcugcugcgcggcggacagcpcgcg\n", + "uuacuuccuagucccpcaggccggcucggaggcagcgagaaagcgcagccaggcggcugcucggcguucucucaggugacugcucggaguucucccag\n", + "aggccggcucggaggcagcgagaaagcgcagccaggcggcugcucggcguucucucaggugacugcucggaguucucccag\n", + "uguuugguguugcaagcaggauccaaaggagaccuauagugacucccaggagcucuuagugaccaagugaag\n", + "uuccuagucccpcaggccggcucggaggcagcgagaaagcgcagccaggcggcugcucggcguucucucaggugacugcucggaguucucccag\n", + "auuuugaaagugacccupcupcgccpcgagcgcggcggcgcggaaccaugacagaag\n", + "gagcuauuuugaaagugacccupcupcgccpcgagcgcggcggcgcggaaccaugacagaag\n", + "pcuggcgucuucuuccuguccucggccgapagcagaucagcuuccuguucgacugcaucguccgaggcaucucccccaccaapccccuuupcugcggccgguucuaccag\n", + "acccaagucccccpacccucgacuguggaggagcguguggcccaggaagcccuggaaacccuacagcuggagaagcggcugagccuccucucacaugcpcaggccpcaguggag\n", + "gcugcugagagcgcuccuugcucuguaaaguggaugucagguggaucuauguuucugaaggaacaaagacucaaagaaggcaccgccaaggaaguuugagacgcpaga\n", + "gcaccccauccgcuggcucucaccccucggagacgcucgcccgacagcauaguacuugccgcccagccacgcccgcgcgccagccacc\n", + "accccauccgcuggcucucaccccucggagacgcucgcccgacagcauaguacuugccgcccagccacgcccgcgcgccagccacc\n", + "ggucccpauucuugagcugugcccagcugacgagcuuuugaagauggcacaauaaccguccagug\n", + "gaagccugcccaacgaucgupcaggaggugguuucugguuuguupcguguguauguguauuuppacugaapuacgupcgaaacaaaaccggcc\n", + "pcaguaguaggugcucaaaacaucacagcccggauuggcgagccacuggugcugaaguguaapcccccaagaaaccaccccagcggcuggaauggaaacug\n", + "cugaaagaupcuggagagapugcaggccccaccuapcggaggccacagcapagapcagacagagccaggacccuggaaggaagcagg\n", + "gaagagcuggaggaagugagaggucggcupuccucaaagugagapagcagaggauccucccgugcaggcuguggaugucacucacuucccagcuggugaagccucgcugcagag\n", + "gaacuccauguacccaggaaggcauuccuggcaccuguguugugaccaucuuuagaaaccuggcggaauucacuuguaaagcaagaugguugucaaggccagaggugapcaag\n", + "cucuggcgcagcupagaggcgcggcggaggcacugccpagcggccggcggcgcgcacgcgcag\n", + "aacuuaaccggagcgugcacacccgccugcgaggcugacccgagcgcgucccacccaaggucgcccagccccgcpcguuuacuuuucaaagguc\n", + "acugcaggacuuuggagcucucagcuuuggagucaguuaagaccaguuccuugcupaagcccuaacucuggapacagagacag\n", + "gcaacucuuuuaccaucccuuuguauuuuugcaguuccucccuauaccagcuuccuuacagcuguucugauuuccuguc\n", + "auuccccucucccggacccgaggagcaggaagcggcggcuccuucggccacccaggcagcagccacagcpagugcgcggcgcpacaggaagagapca\n", + "aggugcgcggcgcapagcpacggccpupcggcpcpacgcgccugcgcacgcccpccugaagccgcuagaccug\n", + "acpagauguugcaggcgccgagapcpccapccgcacuccggagacucgcgguugcuacgcgcacc\n", + "ugucaaaccagaagagaaguaaaauucaacaaaaauuuauguguggaguuccuucuuaaaagaagaaaaaagugauuauuuagacu\n", + "gcuccaccgacagccaggcacupcagcacgcacuggagacccaggacccugugcaggagcagcuccpugacacgapacugaagauacucccacapcucagcag\n", + "gcaaugaggccaauucgaagugguuggaugcgcacuacgacccaauggccaauauccacaccuuuucugccugccuag\n", + "agaggaggcggcpcgcupagacaccggacgcccgcucggcugcgcugcggcucaggcccccgcucpcccgacccgcucggucaccgccggcucpcgcgcaccugccgg\n", + "cugcggccccapccaugcggaggcccacgaggaggccggcggccacgcgcaucccguagcccagguggcccaggucugcaccgcggcggccucggcgcc\n", + "uauuucucaaacucugaggcugcggaguucacacauugaaaucugucaucuuuuucagagagaaacuuucgguaaugu\n", + "aagcpcucagagcgccgcggcauucagccccucguguuccgcuaccgcgcgugcpauuccggcgccgcucuccgagcucgauccgcugcucgcacpagccagcupug\n", + "uuauuucucaaacucugaggcugcggaguucacacauugaaaucugucaucuuuuucagagagaaacuuucg\n", + "uuauuucucaaacucugaggcugcggaguucacacauugaaaucugucaucuuuuucagagagaaacuuucgguaaugu\n", + "agagagagccagagacaguguugcaacupccuggcauguuucagugugguguccagcagugucucccacuccuugugaagucugag\n", + "guugcaaaaggacugugaucauaugaagaucauccaggaguacaacucgaaauucucagaaaacaggaccuugaugugagaggagcagguucagguaaacaaagg\n", + "gcgaggacccgagcgagcuuaaggagupugcagcgucuggucagcggapugaauucucaggacuggucpagucaag\n", + "auccugacuuccgcuuugaaggcgaggaccccagcgagcguaapcgcaguguccgccuggcggauuupucagcaggcggaagucgucccaggcugcuagauacuaag\n", + "gaggaggcpuuggccuaggcgaagauccggacucupuguuuugcuaccgugaccguuuag\n", + "augcupcugccugcgacugagcugagaaggaaaccgugcccapcucucggaagaccgcugcggc\n", + "auuuguguucgcuauuuucaaacaugugguaauguucauguuuugaagccaaauuauguguguuucuuugguuauccuucauucaaguauagucauccacaucacuuccugaaaacaacugcug\n", + "cucuccguggacagguuguucaguucaagcucucagacauuggagaapauuagagaaguaacuguuaaagaaug\n", + "auucagaagaagauguuguugaaacuccugcagugucucaugaugaacauacacaccaagagauaaapccgaaaaacacuggcaacuccugcaguucgccgucuggca\n", + "cugugauuaggcuagcpaauguaapccacuucagcaacagaaaggagugguggagcggcuucucaucagaaaaacagaacuuucagugccugacuugagauguaaacuugau\n", + "uugauggagaaccuugugaccugucuuugaauauaaccugguaucugaaaagcgcugauuguuacaaugaaaucuauaacuucaag\n", + "gcagaagaaguagaguuguauuuggaaaaacuuaaggaaaaaagaggcuugucupaaauaucaaacaucaucaaaauuguuccagaacugcagugaacucuuuaaaacacag\n", + "acuaggaggauugguuggucuuuucuuggauuugauuauggaaagcuaccugaugcaucugguugcuggaggcugacuacuuuuagaugugcuguaaucuuuccapucuuggcuuauug\n", + "ggauauguggugccugucauaagcuccagagagcugccuuccacaagaccagcagaagagupcaaac\n", + "aucuaccuuaucuggucggucaucucuguaaccucccuaccaaggacuaauuggucuuuaaaacuccuca\n", + "guacccacgcccccgcccuggccupcuggcaaggaagaccugupcpcgucaaaapaccggcccugugaccccucaccpccgupcccgagcccccggacuucccu\n", + "cuagaaggucuucaguuuccagaagaaccaaagcaucuuuggaccuaccuapaaggaccugccugugaccuuugcccuguccuggapuccagcuuupcuga\n", + "cuccaccccagacupcgccggcccugccuccauuucagcugugacaaccucagagccguguuggcccaagc\n", + "agguuccccccapcaacaugccagccccguagcacugcccaccccacccacuguggucuguuguaccccacugcupuggugguuccaaugagacapcacaccaaacuccaucug\n", + "gcuguuacugaggcggagacacpugaugauuggcuuucupagagaggaaguccugugauuggccagaucucuggagcuugccgacgcggugugaggacgcucccacggaggccgg\n", + "ggagacacpugaugauuggcuuucupagagaggaaguccugugauuggccagaucucuggagcuugccgacgcggugugaggacgcucccacggaggccgg\n", + "guuccccccapcaacaugccagccccguagcacugcccaccccacccacuguggucuguuguaccccacugcupuggugguuccaaugagacapcacaccaaacuccaucug\n", + "ggcccucgccggccgccauccccgaaacuugcgagugucgcgucugcagugugupuucgcpcggcpuagag\n", + "uugagcauuuuugucaucugcaaauaauuuuagccagguggcaaguguauggacuguggaguaagaaguaccugccucugccucugacuugg\n", + "auggcccucgccggccgccauccccgaaacuugcgagugucgcgucugcagugugupuucgcpcggcpuagag\n", + "gagugucgcgucugcagugugupuucgcpcggcpuagaggcgaguguuuagagacuucpucccugacucgccuccagcaguggagacag\n", + "cacucaggagagaaacccuauaaaugcagugacugupaaagccuuccuuacaaagacaaugcucauuguacaucacagaacucacacpagagagacccuauggcugugaugagu\n", + "cgcgucugcagugugupuucgcpcggcpuagaggcgaguguuuagagacuucpucccugacucgccuccagcaguggagacaggucaucggucug\n", + "gaaggaguggaggcccuggugcccggcccuuggugcugaguauccagcaagagugaccpugaagaagcaaagacucg\n", + "aggaggagcuuggcucccagccagcuggccaagagaaaaccugaaggcagguccugugaugaugaagacuggcaaccuggccuagug\n", + "acuccuaggaaacggaaauccagcagugagacccagauccaggaguguuuccugucuccuuuucggaaaccuuugagucagcuaaccaaucaaccaccuugucuggacagcagucagcau\n", + "ggagaaacucccuguccaugugguuguugacccuauucucaguaagguuuugcggccucaucagagagag\n", + "auuagacccugguccuacacucuuagccgcugccugcuuuugaccuuuggcucaupuacuugacguuuuaaacuccuaggcccagg\n", + "gcauuucugcgcagcucuagcgcgccucggagcccgccpcagccgccggacaccaggaccgcgagccagacagcucccggaagccgcgccgccgccgccag\n", + "ccacagcacagccggacagaggagguggauuaggaguucccpapagccugcucagccuuucccugacauuupcaaaugugupagaugcggagcucaag\n", + "ucuccugcuggcuucugagagcugacggaacagguuccagcaaggcagacccugacacagaagccagaccuguccagcapaccccauacacug\n", + "ggaggcuuccupaaacuggaaggcagaagccacgcagacuucuaguccugguuccacugcuuacucg\n", + "gcugcuguucguaccugccucaugguuuucuupaggaucaaugagguagaaccugcaaapcuuagcagagagccuagcaccuacugagcgcucaguaaag\n", + "auuucugcgcagcucuagcgcgccucggagcccgccpcagccgccggacaccaggaccgcgagccagacagcucccggaagccgcgccgccgccgccag\n", + "cagaauuguupcuucaucuuggcucugugcugccuggapagaccuaggauaggcuccugaucugcaaaaupauaaucccagcugccacuuaagugagacaa\n", + "cgagagagcpcauuucugcgcagcucuagcgcgccucggagcccgccpcagccgccggacaccaggaccgcgagccagacagcucccggaagccgcgccgccgccgccag\n", + "cgccucggagcccgccpcagccgccggacaccaggaccgcgagccagacagcucccggaagccgcgccgccgccgccag\n", + "cuggugcaaagagcggauuucucccugcuucucuucugucacccccgcuccucucccccaggaggcuccuugauuuaugguagcuuuggacuugcuuccccgucugacuguccuugacuucuaga\n", + "acccauuagaaacgcuucaagagcugcucaguccaggaguggapauuuugugaagacacagaugcucccuaaaaggagugcagaaauuuucaucauagg\n", + "ggcuacgcagcuugcuccuggcacpcaccuugaaucuccuccucacacagauggagaccaugcuugauuuccugaacuuguaguaagaagaaggaaaacacagcacgcuggagccaacag\n", + "agucucggcggcggcggcggcggcggcggcggcggcgauccacagugauucggccgccgcgccppuppcugcgcpacuuuuuuuuuuucagacugaccgcpcagcugcggagc\n", + "aaguacugaacuccuaauaucaccaauucuucuaaguuccuggacauugauccggaggaggauucgcaguucaacaucaag\n", + "agagcgcgucagcpcgcagcuacuuugcacucgccgauucugacacaacagauaguuaauupccuucgaaaucaaggacuaag\n", + "ucuccgcccccgcccagacccccugagcugccpagccaggagucauuuaucuuugccuggcgcpuupauuuguccggcucugaugccaacgaggaaggcgugcggauaacgaa\n", + "agcuucuggaaggcgcugcucuuccgguucucugucccgguuccupuugcacagacagacccuguaaac\n", + "gcucuugcuggccccggcgagguagcuucuggaaggcgcugcucuuccgguucucugucccgguuccupuugcacagacagacccuguaaac\n", + "agaaggacgccgguuccuugcucuugcuggccccggcgagguagcuucuggaaggcgcugcucuuccgguucucugucccgguuccupuugcacagacagacccuguaaac\n", + "cccgccccuccccgucucuccccgccccuccccgucccucccgccgaagcuccgucccgcccgcpccggcuccgcccucaccucccggccgcggcugcccucugcccpuuguccaag\n", + "gucacuggaucugagaaacuucccapaccgcauuccagagucagugacucugugaagcacccacaucuaccucuugccacguucccacpcuupaaag\n", + "gaacugugcugaupcaggaggaupagacaggaauugagagucacagaggaaggacaguggagucuggcaucuuauug\n", + "ggcacucuuuaaugaagaaacaccagagcuguuaaacacauugagacacagaagauucuagugacugagg\n", + "aaacapcacucuuuaaugaagaaacaccagagcuguuaaacacauugagacacagaagauucuagugacugagg\n", + "ucuuuucuagaaacauugauguaauguucuuagacucuacuggaauguaagcacuccaaaauacaauaccuuucacaccuggucagccaagaaaaaauu\n", + "gucaccauuugcugcugugacagacuauucaguuacaagaaauaaugucauacaacucugccuggaguuaacaacaauugugcaacag\n", + "uguaaaacucuuucuggagucugugaccacaucauaucccugucgucagauccucugguuucacagucugcucaccuggaagugauucaacuggcaaacauuaaaccaagcgaapcug\n", + "apaggcugcggccagcaapaccccaccugagagcagcucpcugcugaguucguuuugugucugagcucugcgcucugcacggaaccgaccccguaccc\n", + "uaaaggcaaauauccaaauauuggcugucuggaccuacaggaauacuaaagaaggcacugcagagacccacaacugagaaauacuggcugu\n", + "guggaagccauuaccuacuguuggaccpugucucagauucuucaagagcauggucauaaugugacu\n", + "gacuccauggcuuccgaguugcugacugacccuccaccucagagguaguucugacacugucucaguuuugcag\n", + "caagucagucgauccuguguuugugcucccgaaggacuuggcgacuuggcuaacaaggagacauuuguuauuucauuuccucauccauuauucaugcagugagag\n", + "guguucagauuuugcaaaucuaaaugucauaaaaacuuuaaaaagaagcgcaauccucgcaaaguuagguggaccaaagcauuccggaaagcagcugguaaagagcuuacagug\n", + "gauaauucauuugaauuugaaaaacguagaaaugaaccuaucaaauaccagcgagagcuauggaauaaaacua\n", + "ggugacpuugcaucacuuccucucaagcuuggcguuuguuuggupuuacacgcpuucaac\n", + "gucuauugcccaggcuggagugcagaugugugaucauggcucucugcagccucagucuccuguacuuaagcaguccucccuccucagcaugcugaguagcupacuacag\n", + "ccaaacugcuucuguuuuccagguagcucaguggcauuucugagcapccacccugacuucaccuuggcccacc\n", + "gcaugcuaacauucauggaggcagacauguguacccagaaucagapagccgguuauccucaguuggagaucccaaaagacuucugcauacaguuccuuucguuggaug\n", + "gaucuccaaccugagcauaugccaguugacaupaacacugaggccagcaauuuaaggauuucacauuugcuugcagug\n", + "aaugcguaauccuggaucucuuguucgcaaaucgacagccugaagcccucuggaagcccaagacugcuggag\n", + "aaggcagaacuucacggaacaacugcgcccgcagcucuccupcugcagugauuuguccucupuucuggaggaaagcucugaaagaa\n", + "gaacuuccaauccugcuuuagaacuuacuccuucaggaaagcaacucucacugaagugupagcggagcagagaaaagacuag\n", + "gagauuuggacgcuccggccupaggugcgucagauccgagcucgccauccaguuuccucuccacuaguccccccaguuggagaucu\n", + "gccupaggugcgucagauccgagcucgccauccaguuuccucuccacuaguccccccaguuggagaucu\n", + "agauuuggacgcuccggccupaggugcgucagauccgagcucgccauccaguuuccucuccacuaguccccccaguuggagaucu\n", + "gugcuccuccuuuuccuccuccucuuucuccuccuccucapcuccagucaggccgauccgcuccgcucacg\n", + "ggccaucccaggcugcugucagaauauaacagcacucccaaagaacupuacucaacacugagcagaucuguucuuugagcuaaaaacc\n", + "agaauauaacagcacucccaaagaacupuacucaacacugagcagaucuguucuuugagcuaaaaacc\n", + "gcggugcagcugaggcugcaaguagccggcgccgucccgcgucgcccccgcgcapcpccccgcacgcuuauucugcccpaggaacgccggcguccagcccgcuaccgaccgccgcugcp\n", + "gucucuagcugcugcpagcuccaggucuagucuuuacugcucuguguauucugcuccuagaggcccagccucugugacuccguuaucugcagguauupagaugcacagcuaag\n", + "agucuuuacugcucuguguauucugcuccuagaggcccagccucugugacuccguuaucugcagguauupagaugcacagcuaag\n", + "guguaucccgcucacggccagaaagcuucgapaaacuggagaccuuccucpuguggcagcugccggcuuggacuucaccagcgacccug\n", + "cuucgcgccggcgccggcgcccugcggaagcggcguuagugaaucpccuupagcccaggauggagguggcggucgcggcggcpccgagcccugcggcpcpag\n", + "accacgccguccpupccuagcagucgcuccauuuaucgcuugagaucuccagccuuaccgcggcucgaa\n", + "agcaguuauuaacacpaacauggcggccgcagccucggcuacagcuucggcggcgaaggucagcgccgacggcagccggcaccugacggcgugaccgacccgagccg\n", + "ggaggagcgaggcacuugcupucpcugcgcgacggcgcapcugcpagcgccgcgcaggccgugcaguuccuagcgaggaggcgccgccgccauugccgcucucucg\n", + "uuugucaucauccugcucuugguuuuugucacagaaguuguuguagugguuuupauauguuuacagagcaaag\n", + "guggaaaaugagguugaucgcagcauucagaaaguguauaagaccuacaauggaaccaacccugaugcugcuagccpcuauugauuauguacagagacag\n", + "ggaggcgccgccgccauugccgcucucucggugagcgcagccccgcucuccpccpccuucgcpccaccggcgcc\n", + "agucaguauccagccucaacauucagcagaggccccagaucagcgucugagccaggccaacaaugaccaaggagg\n", + "apacgcacuguguccuaguugaggcuaacagucaguauccagccucaacauucagcagaggccccagaucagcgucugagccaggccaacaaugaccaaggagg\n", + "aucuupcuggaggacgugucugguuauuauauaggugcacagcuggaggugagauccacacagcucagaccagcuggaucuugcucagucucugucagaggaagaucccuug\n", + "gaggagcacacugucucaaccccucuuuuccugcccaaggaggaggccccgcagcgacauggapagcugcuuugcugaaaaucuuugucgucugcaucug\n", + "acuucaccauaapaaagaagagagccuuguuggacacugaagaapacpauuucuccuccuaaucupccucuuguc\n", + "gaugaagagacucggcacagccuugagugcauccaggccaaucagaucuuucccaggaagcagcugauccpaggaugagaaucuucag\n", + "guuccuuuccuugaacuucauggagagagcacagaguuugupccgugccgaggaugccaucauugcccuuuccaauuacagacuucacaucaaguucaaggagucucuuguuaau\n", + "guuccauuacagcuuauagaaaguguugaaugccgagauauauuucagcuucauuugacuugcaaagacugcaaaguuaucag\n", + "gugucaguuuucaaccuuugagcagugucaagaguggcugaagagacugaacaacgcaauccgaccaccugcuaaaauagaagaucucuucucauuugcauaccaugcuuggugc\n", + "pccggaagugccgcuccuuggupcuguucauggcgguuccpucuccaacauuuuucccggcugugguccuaaaucuguccaaagcagaggcaguggagcuugag\n", + "auuccuccuguuuaacugaaauuuuguauccuuugaccaauuucuucccaacccugcuaugucucagccucugguaaccaccauuuuaccaucuguuucuaucaguuagacuguuuuauacuccauau\n", + "aaugcuaucuucuuugagaagucaaauugucaggaucaggaauguauguuuucuuccaucuggauucuag\n", + "gagaggcaagaauugaguguugugaauaguucugaacuagagaccuuuugaaaccaaaaggaagauggucuugagucuuucuuguuacg\n", + "agcuggucggaacugauggcuaccaguggcagguacuuccugcaggagaaacaguguaagcaaagaupaagag\n", + "acaucuuuccaggaacagcgugaggaggacagaagcacccaacaggacugcucaagccaccugcgaacacugcugcuacc\n", + "agucuucagcuuucaccggcupaguccggagcugcagcagaggccacacccapcuugguggucccgcgcuuuccggagcucagcaggcgcuugcugcuugaaccggucaaagaaggaacga\n", + "agcuuucaccggcupaguccggagcugcagcagaggccacacccapcuugguggucccgcgcuuuccggagcucagcaggcgcuugcugcuugaaccggucaaagaaggaacga\n", + "cuagucuucagcuuucaccggcupaguccggagcugcagcagaggccacacccapcuugguggucccgcgcuuuccggagcucagcaggcgcuugcugcuugaaccggucaaagaaggaacga\n", + "gcgcacccpacaguuuccagucggcuucuccgugaccuuccucccccuuccagcucggagcpaugcupaucccuccaaggacccucugaggacguaggapaugcugagacag\n", + "ggugcuuucauguaucaucauuccacuugaggcucaaagcacaccaauaacaaguacuuguucagaauguauaaacaacccugagag\n", + "guuuuccaaacagaaggaugguagcuagapagauagcaagauucuggagucuggaaagccuucacuugg\n", + "pcucuggaggaccupaagauacccuaugaggucuguapagcccucaggaaaggucugcugacgag\n", + "gacgcpaguguggagaggccgagaggagccuuccgccccccgccccpacauugcgcuagaggccgaggcccggagucuuacggcggcpau\n", + "gccgacgcpaguguggagaggccgagaggagccuuccgccccccgccccpacauugcgcuagaggccgaggcccggagucuuacggcggcpau\n", + "guccupaaaauguagcuguggaagagcagaacauuccucccuccugugauggcugacauucauaggaaggcggacacacggaagacgccag\n", + "agacugugcacgcuccuguccccacucacaggcccacgcagcgappccccucuucugugugcgucuggaaggucgcugcccapaggaa\n", + "gacccugcupuggaacuaagaaaguccagcagacugugcacgcuccuguccccacucacaggcccacgcagcgappccccucuucugugugcgucuggaaggucgcugcccapaggaa\n", + "gaguguuggaggcgcagaagccgagccpccggccpcpcpaggaggaggagccpcpcuggcpcggccpuggcggcggcggc\n", + "agcacuauccuugcuuaggccugagccacagaagcugcucapacuauccauggccuccccguggccaacuugagucugcucugcagcuuuaggcccgacuuggaaggcccaupcugcag\n", + "cugcpugacaggcaggcpaapcpccucpcpccgccgupaggapcggupapaggaguggag\n", + "cuggcgcgcgcggcccugcpugacaggcaggcpaapcpccucpcpccgccgupaggapcggupapaggaguggag\n", + "auuugugauuucggccuggcccggauugccgauccugagcaugaccacaccggcuuccugacgga\n", + "ggcagcuccgcugguccgapcagugcagcagcggcgacagcggcugcggccguggccguggcpaggagccggaagccccgcccccpapccguccugcag\n", + "guccccccucuauccuccacggccccauccaagccapaugaaauuuaacggcaagaapcgcaguugacgcggcgucaaugaacugagacuaagucaaaagccgg\n", + "gcccuccaacccuauccccaucagccuggucaucaccggcgucacccccgccccgcgcccugccccuagguuccugugccagcaag\n", + "acucaggaguucupccccagcuucccauuccacugacgcugcagcccagccccgcupaucc\n", + "cucucpcuggcucpaguagcgcagucgccaaagccgccgcugccaaagcugccgccacuagccpc\n", + "gacgugccgccaaucuucgaacgcaggucugugaucauccgcagacuccgaaaaapuucgaggaacgcgccugcuccccucgucgcaguuuccagcccgacgagcuuguuuugucccggacucg\n", + "gcacagaggagcugugcccuggaaupccuguaccuguccaaggcuugugccguccccugupagaugagaagcgucccugcauupcucuupacccgucuuggacauga\n", + "aggacccgcgaggaapcccgcggauggcgcgucccugapucguggcgaguucgcggagcgupaaggagcggacccugcucuccccpcugcpcc\n", + "uuupcucuuaugaauaaggcugucaugaacauuuuuguauaaaucuucauguagacaaacguuuacauuuuucuugg\n", + "ggcgacucccaggcuccpacgauucupcagugucguccccagaggucggcggccguugcccgcucaccagcgacgcpcgccugcpacg\n", + "gacacugcccaucucuaagauaagagccuggaaagaggacucuguuggcuguuggaaauugcagagua\n", + "guagccucaggccugacggcgacucccaggcuccpacgauucupcagugucguccccagag\n", + "cgguucguugcgccuggaauuuuguccccugcgcggaugauucupaaaugucgaucggcugupcggcgcacupuccgccccgcuguagccucag\n", + "aacacagaauguucuuggugagaapccggcggauucpaacugacugcuguaguucagaagagguuuggcuuuccagapcaguguagag\n", + "cuuuaugcugaaaagguggccacuagaggucugugugccauugcccaggcagagucucugcguuacaaacuccuaggapcuugcugugcggag\n", + "guuccuuguggagaagcacugguauaagcagupaggcauacgugcapapaccaggacuccagcaccuucccuggcugcaucaacaaugccacacucuuucaag\n", + "gucauagagcugcccaacauccagaaggucgaaguguacccaguagaacugcugcuuguccggcacaaugauuupcaaaucucacacuguucaguucagccauaccgauucuauug\n", + "ucacuauuccagguccucaggauauagccgugaccuaaacacagaaaucuacccuggcggagcugaucuucuaguuguggcg\n", + "uagagaagucaggaagapucccuguggccacapaauagucugccuuggccuuugapuggugcuapaacu\n", + "guccucaggauauagccgugaccuaaacacagaaaucuacccuggcggagcugaucuucuaguuguggcg\n", + "ucacuauuccagguccucaggauauagccgugaccuaaacacagaaaucuacccuggcggagcugaucuucuaguuguggcggugaggagauagacaguaaagacuaaagaaaccaauaa\n", + "puggcgacggcgcccagcccgccagaagaacgcgcggcpcagacggcupagccgcuccg\n", + "acagugguccuccgccggcuacgccgcugccucaguggcuuucaggcgcuuuccucuuggaauuggcgacugcugcpcugagcgcuggucucacgcaucucpagccagguugguggcgcg\n", + "guapacugugcpaagcupuggaugcauggupcccpuucupccpaugcagcccuacugagccccuuucugguucuccacaggug\n", + "gguuguccugccapuagaaucggaaccguaggapuacuuaaccggacggccuaccaggccuguggccgugcgcpaagagcacugcag\n", + "gccagguacgaggagcuapuuguccugccapuagaaucggaaccguaggapuacuuaaccggacggccuaccaggccuguggccgugcgcpaagagcacugcag\n", + "cucacaccccagugaccucuucupaaugccuugcupaaugcagcugagccugugupuguggagagaaggugcagauggccuccgguuuucucuuugcaggcugagaaaguguuc\n", + "aauuuaagccuguggcauggaaccuaaagacuagaggcgguugugugagucaggaagapccagauaucugaguguuccucuuuaguuucuucaauugcag\n", + "auaauauggugucuaauuuuauguuguucaggaaagacagugguuccugacucaggaagacagucucagaaac\n", + "caauuuaagccuguggcauggaaccuaaagacuagaggcgguugugugagucaggaagapccagauaucugaguguuccucuuuaguuucuucaauugcag\n", + "guuccuucaagauaucugcuuugaaauucugccuuuauuuagcugagagauggcuacagaauaucccaucgcag\n", + "auauucaugcagcagcuaaagaaauagccgaagucaaugaaauuaauuuggaaaaagucupacauguuguuggaaaaauggcuaugcccuucaacaaaaccuggugaa\n", + "agugcaguaucuccuccugucucguccaauugauuauaguucaagaaugcuguuuguauuugcaacaucaacuacaacc\n", + "acauuagguaugcaucaguuaacuuuugcccauagaacucgagcucuucagugucucuucuauuuggcugacaaggaaacuauagaaucucucuuuaaaaaacccauugaagaagugaa\n", + "gcaguaagauuggugacugagcuguguuuagaauacaaaaucuaugaccugcagcuuuggaauggacucuugcaaaagcuucupcuucaauaug\n", + "agauggaggucuugcuauguugccuaggcuggucuuagaacuccugagcugaaacaauccuccugccuuggccucccaaaguacupauuacag\n", + "auguccagucucaggugaucuugaccugaucggagucgccaggcaguauauccaguuagaacuuccggcuuuugcauuagcuugucug\n", + "gauuggccccupccapcpcacucgcggcggaggcaagcggcggcgcgcggacgguugguccaguucuccggccuggcggcag\n", + "acucgcggcggaggcaagcggcggcgcgcggacgguugguccaguucuccggccuggcggcaggcaagucuagcucggcgcugucggauacuupugagcggaaagc\n", + "pcacucgcggcggaggcaagcggcggcgcgcggacgguugguccaguucuccggccuggcggcaggcaagucuagcucggcgcugucggauacuupugagcggaaagc\n", + "cucaaguagcggacacggaacapaacuaucagcccgucggccuccpcccugcauucucuagcc\n", + "ggcucaaguagcggacacggaacapaacuaucagcccgucggccuccpcccugcauucucuagcc\n", + "aaaagagaagagaguugacaacaucgagauacagaaauucaucuccaaaaaagcggaucugcuuuuugcacuuuccuggaaaucagaugcaccugcaacuucugaaauuaaugaagacagugaag\n", + "agacaguuucuuccgcuuccuguaccacccggcucaaguagcggacacggaacapaacuaucagcccgucggccuccpcccugcauucucuagcc\n", + "acccggcucaaguagcggacacggaacapaacuaucagcccgucggccuccpcccugcauucucuagcc\n", + "auugcagcupacagcccggagugugguuagcagcucggcaagcgcugcccagguccupugguggcagccagcpagcaggaaaggaagc\n", + "aucaguguguuuuuuguguccaauucuuuuaucaccaaaaaagagaagaaauauugcagugaaugaagauuccucugcauuuuagcacugcuuuuucaacuguaguuggcuuuuga\n", + "cuuucuccucuaaaucuuggucucuuguuuggaagugacuaacagcauuuuggcaugagaaagcccuaaaaag\n", + "agguuggccccuggugccccpagapacapcggaugugccupupuccuuugaagguguggcuucggaccgagaggugaggcugcuguuuucccccugcuuu\n", + "cuagcuuucuccucuaaaucuuggucucuuguuuggaagugacuaacagcauuuuggcaugagaaagcccuaaaaag\n", + "pacapcggaugugccupupuccuuugaagguguggcuucggaccgagaggugaggcugcuguuuucccccugcuuu\n", + "cggcupcaggauuccggacaacgccugguuccucuupuccuuccggcgucgccggagugaauugauccpaguugaagapcugcaaggupaagugaagucagugccucaguugcug\n", + "puccuuccggcgucgccggagugaauugauccpaguugaagapcugcaaggupaagugaagucagugccucaguugcug\n", + "acugucuuagupcccuccacgcaguccugagaupuauguccuggccgcggaucugaccagugcccccuuucucuucagaugcagcccuguuggaagcugcccgugccaacaau\n", + "aguccugagaupuauguccuggccgcggaucugaccagugcccccuuucucuucagaugcagcccuguuggaagcugcccgugccaacaauaugcaagaagucagcag\n", + "ccccaagagacugcaaagaaugaugcucagucaagaagcupcapcugaaugcuggagucucacugaagaacaccaagauuuccuccucugaauggccccucag\n", + "aagauccaguucuuauaggacuauucaucagguuguuuaguucagcauuacuuugugcuuucugauaagauaugauccaaaaccugaugag\n", + "aaaaccuguuucccaaggaaauucugcaucaugaacgaaaagccaagcaauuaugccaagaaaaaaguugugaagugaagaaaaauaagaaguaauuacaacagaaaaaccuucacuguuacauaag\n", + "gagcucucuguggaaaacucuauuuugaaaaugaauauauuuugauuuaaacaauacagagaagucaaa\n", + "auuaguacagcacccagaggucuucggagcaaagcuguuaaagaagupuccauuugagccccaacuuugccuuccuuagguccccuupcuugucuagcccuaggaguuccaacaa\n", + "agucacaacacucauauccuapaccaccacacugcuaugagucaggcaugugcguuguuuaag\n", + "gcuaagaaauggcauuucaaaaggcagugaaapacgauucuuguuggaggaggugcucuugcaacuguuuuaggacuuucucaguuugcucauuacagaaggaaacaa\n", + "ggucagcggaaucgacuuaagaaacuguaaaacuuuaagaagagaacuacgccugugagauuuacuagacugauuuugaaaaagacuacugauaa\n", + "acuaaaaacagcccuuguagaaagagaugauuucucaucapaccagcagcagaagcacuaaauugauccaugguggugugagauaucugcagaaggccauc\n", + "aggaggaggaggcagcggcagagaagagagaggcgugugagccgugcuccaccggcuagcuccuucccgcugcuccugccuggcagugccaggcagcccacaccagc\n", + "agcaucguaggaggaagaaaacaaacacaucagauauuuucagcacuaaaagagaugguuuuccccacauauauguaaaagaaauuugcaagacuacugg\n", + "ggaaaauacuuuucucuagcaucguaggaggaagaaaacaaacacaucagauauuuucagcacuaaaagagaugguuuuccccacauauauguaaaagaaauuugcaagacuacugg\n", + "auuuugaucucaugguugcagupugaauagguggccuuuugugaucuccuacaucacccuggaagugagacuucuucgguuucuucuagagucaguuug\n", + "auuugaagagauuuccupuguggagugugacuuuccaaaaccagcuuuuccuugagcuguauuuguugcagca\n", + "gaauagccaggucuggcupucggcacaaccuguuugagccugaagacacaggccagapucccugucagccacagcuucccacacccgcucuacaau\n", + "agccccaaacucaccaccuggccguggacaccugugucagcaugupaccugguucucuccaucgccuugucugupugcacug\n", + "aguuucucagccacagagauucacagccuapcaggaggacacuguacaccaggcagaaugacaupaauugcgcucacgauuggcuugaagaagcaaggacugupag\n", + "aucacaucuccaugauccauaggcccugcccaaucugaccucacaccgupaaugccuccagacugaucua\n", + "gcagccpcgcccugcucagccagcgccagcggccgccgcacccagccgcgccggcgaggacaupcagccgcggcgcgcccaccccccgcgccg\n", + "augugaauuauuaaaaagaaaauggcccaacggagcacuguauuuccuucucgugucaccaaggaaagguauaauau\n", + "gcucagccagcgccagcggccgccgcacccagccgcgccggcgaggacaupcagccgcggcgcgcccaccccccgcgccg\n", + "agccagcgccagcggccgccgcacccagccgcgccggcgaggacaupcagccgcggcgcgcccaccccccgcgccg\n", + "aguuuccaaagaucucuggauccuguaguccuccucccgcgccagccaccgaagaacgcugcggacccagcucgcuccugguagcaagacccgaacu\n", + "auccagaacauuucugccuucaacuccagcaaggaucugaagguccaggaccuuaggaaagcugccugcagagagguggagag\n", + "apcgagacggcggcgacuuagcaggcpcgcaugcugcggapcaagaguccacucguacucgccggucgccgccggcccag\n", + "ggapagccugccgaugccgagcpugcuacgucccgcggucggagccgcgucuucucccggcuccgccaccagccpcucpupcccpccccpc\n", + "gacggapagccugccgaugccgagcpugcuacgucccgcggucggagccgcgucuucucccggcuccgccaccagccpcucpupcccpccccpc\n", + "gcgcgccgcuggccgacggapagccugccgaugccgagcpugcuacgucccgcggucggagccgcgucuucucccggcuccgccaccagccpcucpupcccpccccpc\n", + "gcgccgcuggccgacggapagccugccgaugccgagcpugcuacgucccgcggucggagccgcgucuucucccggcuccgccaccagccpcucpupcccpccccpc\n", + "gccgaugccgagcpugcuacgucccgcggucggagccgcgucuucucccggcuccgccaccagccpcucpupcccpccccpc\n", + "cucuucguuaagucggccuucccaacauggcgcagucuauuaacaucacggagcugaaucugccgcagcuagaaaugcucaagaaccagcuggaccag\n", + "gcuggagcgcaauggugagaucuuggcuuacugcaaccuccgccucccgaguucaagagauucuucugccucagucucccgaguagcupacuuuag\n", + "ggccuucccaacauggcgcagucuauuaacaucacggagcugaaucugccgcagcuagaaaugcucaagaaccagcuggaccag\n", + "auguaugucccupaagcugcaugauguggaacacgugcucaucgaugupaacupuacuauguagagaag\n", + "ccccuuauucaccucugaucuuguagacagcugaggaugccaaggacuucuucaagaggaagauagauuuucuaaccaagcag\n", + "cuuccugcagccucuuccgcucgccggcugcggcgccupacgguugcggupucupcgcupaagucguccaag\n", + "gacugguggaaaauaaaccgugcacuuuagaacagcaggaapaggcuuggaagccugguuuucuggcuuugaaugaccgccuagcgcuugccggugcgccapugcugugagg\n", + "gcucacugugguggugugagupaggcggcggcgcugguggcugcagcupugaggcgcgaggcggcgcacucgacggcugacuggagcagcgguaaaggcgaggauggagaccgaag\n", + "paggcggcggcgcugguggcugcagcupugaggcgcgaggcggcgcacucgacggcugacuggagcagcgguaaaggcgaggauggagaccgaag\n", + "ggugugagupaggcggcggcgcugguggcugcagcupugaggcgcgaggcggcgcacucgacggcugacuggagcagcgguaaag\n", + "gcpcucacugugguggugugagupaggcggcggcgcugguggcugcagcupugaggcgcgaggcggcgcacucgacggcugacuggagcagcg\n", + "ggugugagupaggcggcggcgcugguggcugcagcupugaggcgcgaggcggcgcacucgacggcugacuggagcagcgguaaaggcgaggauggagaccgaag\n", + "cacacucgcccugcgcccugcpaauggcgccccggccaaaaaagcaaccagacaaaaacccauugcacpcpaacuggucugugcgacccgcaaaap\n", + "ucaaaauccauccugaaggccupagccpcagcugcgcggcacaacuccapcacacucgcccugcgcccugcpa\n", + "gguggcggcggcaccacacaaaacccucpaaacauccagaacgugccgcgaaccagccggcapupcgcagcccggcugcaaacaugccagcaaggaggcagucccaaccccgcag\n", + "agcugaacapcacugaggugucggccggcpcaguggcccggagcppcpcguugauc\n", + "acucauccccaggcacgcggccaccggucacugacaacuacagaccgacucugccacccagaucaggugcccag\n", + "guuuccgcuggcggcggcggcggcggcggugccggagcgcgagcagagcggagacccccagguccugcpcgcg\n", + "gaauauccuggaaccuucuuuuguuugucagcagccaagguguuuccaggaaguucagagagaacag\n", + "auucccpcaggccccgcccccuguuuccgcuggcggcggcggcggcggcggugccggagcgcgagcagagcggagacccccagguccugcpcgcg\n", + "cuguuuccgcuggcggcggcggcggcggcggugccggagcgcgagcagagcggagacccccagguccugcpcgcg\n", + "gcuggcggcggcggcggcggcggugccggagcgcgagcagagcggagacccccagguccugcpcgcg\n", + "ggcaagucucacaugaagcuacucaucauuugcuucguguccuccgagcuccgagaguuggcaaagcugaugaaggagcaguagacagcgacccaagcacaccacuucagcuapaaag\n", + "cagacccacggagccaccuucacccucuccugcggcuggapagacugcupccuugccgucucuccgg\n", + "agucggcgccaaaaucaaacgcguccuggccugucccgccccucuccccaagcgcpcccggccagcggaagccccugcgcccgcgcc\n", + "aaagcagccgugccgugucccapcpaauugugcpacpcuccacggaggaaucuucucuuccuucccuug\n", + "gcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "guggagucugacucucucacccaggcuggagugcaguggcaagaucucagcucacugcaacuccgcuuccuguguucaagccauucuccugccucagucucucaacuagcugcgauuacag\n", + "cuccucuuagaaauccugacgcagcuccuagguuccuucgcagugacagccacucuuuucuauuuguacguagcuguaguguuuugugg\n", + "ggucuugcuuugucucccaggcuggugugcaguggugcgaccacggcucacggcagccucagccacccagauguaagcgaucugguucccaccucagccucccgagua\n", + "apccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "cacgcuggcggccccuugagccccaaccuggauaccauapaggagcagagaagccaggaacaccacagcccupccaag\n", + "uuapccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "papuacuuapccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "gcuggugugcaguggugcgaccacggcucacggcagccucagccacccagauguaagcgaucugguucccaccucagccucccgagua\n", + "ggccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "ggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "gugucuucaggccuauggagagcagcuugcgupcupccugcaguaccugguuugcauagaugauuggcaggupcagcacpaaggaccugugaguggccaaccugguucag\n", + "acuuapccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "ccuucuccucuuagaaauccugacgcagcuccuagguuccuucgcagugacagccacucuuuucuauuu\n", + "ggcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "pccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "ggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "cpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "uggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "aaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcupugagugcupacccpccaccgcagc\n", + "gugucuucaggccuauggagagcagcuugcgupcupccugcaguaccugguuugcauagaugauuggcag\n", + "uccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "puacuuapccpcuggcccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "gcuggagugcaguggcaagaucucagcucacugcaacuccgcuuccuguguucaagccauucuccugccucagucucucaacuagcugcgauuacag\n", + "cccaggcuacggcggcugcapcuccggcaaccgcuccggcaacgccaaccgcuccgcugcgcgcaggcupcugcaggcucucggcugcagcgcugg\n", + "auggccgaaacpcuccccgucuuaacgauuuggcgucucccucgaccaccaccucuuugugcagcagcccccpcagacccuguuccgag\n", + "guuucuccccucccgccgcccpcgagcgacacggcugcggccccccuccccucccuucccucccucccucccaucccccccuccccgagacccaccggaccccgaacccag\n", + "uaaapuguuaacauaaucccccaaucccauacaauucaauuucagaaaaguauuuapacugugcuaaaauagcaucuccaagcuugcuauggcaag\n", + "gauacaccucuguguupacaacagugupucuagaguuuccaaugucuuccaggaguucuupacccaucaugagaaggaagugguggagcauggagcauggaauaaau\n", + "ggacauggaugaagcuggaaaccaucauucucagcagacuaacacaggaacagaaaaccaaacacc\n", + "aguguuccagauuugcauuaagcugucacccgguggcuguguaacuagcugcuuuugugacuguuacag\n", + "ggugaaaaaaaaagucacuguaacaggagucaagaapcuuagaaccuagucaugugaauauuuucaaguuuuucuugccuuguguuuuuucaucaaaugagg\n", + "uccccaccugguuggaaggcugupuccpaacccgagcccaaggagupcggccccggagcgaggcucacacucccugcccugcag\n", + "aguuccggugaguccgupupuccccaccugguuggaaggcugupuccpaacccgagcccaaggagupcggccccggagcgaggcucacacucccugcccugcag\n", + "gcgccgcggcpaaaauccgaccuggccgcgcaccaccgccccuucucggcccuccugcguuugcccapucggcccgcagug\n", + "gaagupaaugauggcuccauuucacagaugaggaaaccgagacucagagcacaaggccacacagcaggaagag\n", + "ggcagcugugauuagagaagccapccaccccggagccagccucugaggcuucaccucaccccguuuacacugcugucuccucugcauagauuuggcugacugaggacgcgacag\n", + "acugcccggcccggcacpcggcgcgaugugaggcguccgagcccggagccuccgccuggcaucagcuccacguagcccagcgccggcacgcgcgaggccc\n", + "ggucuggaagcupuaggaacuguggccugaggccggugucuccccucagcccuucugcagaggccpcuggaggagaag\n", + "cccaugugaaugaccgucgagacaggaaaaaccucccagugacuucugagcggugauggaggccaucagapccugauccccuugcccacagcagcagcuucagacccccpaggagcccagga\n", + "gaugugaggcguccgagcccggagccuccgccuggcaucagcuccacguagcccagcgccggcacgcgcgaggccc\n", + "auuuggcugacugaggacgcgacagguacucagcuucuuucugcaucucaguugcccagcacapcuggcacgca\n", + "aaguucccugagagcuaccggccapucpaggcuaupagcucapcaggcaccucccaugcucccgcpagccaccaggacaugaag\n", + "aagccuccaaguucccugagagcuaccggccapucpaggcuaupagcucapcaggcaccucccaugcucccgcpagccaccaggacaugaag\n", + "gagccpacacucccugaguccucupagcccuuaagccacacugagaacacagacccupagaagcagccagcagugaggaauccuggaaccccuucccapagagccuuccc\n", + "gguucuggccgucccugugccaagccuccaaguucccugagagcuaccggccapucpaggcuaupagcucapcaggcaccucccaugcucccgcpagccaccaggacaugaag\n", + "aucccgucuucccacaggcccugugucuugcucaguccacgugacucugcuuucucauccuaggccucag\n", + "ucuggccgucccugugccaagccuccaaguucccugagagcuaccggccapucpaggcuaupagcucapcaggcaccucccaugcucccgcpagccaccaggacaugaag\n", + "aaagacugccpcgcaugcggucpuuguucacuggcuguccpcuccgcgcgcgucgccggcccagcucugucgcugacpaggaucugaagccggccgcag\n", + "gagcccgccuccgugaaagacugccpcgcaugcggucpuuguucacuggcuguccpcuccgcgcgcgucgccggcccagcucugucgcugacpaggaucugaagccggccgcag\n", + "acuggcuguccpcuccgcgcgcgucgccggcccagcucugucgcugacpaggaucugaagccggccgcag\n", + "ccaaguucaacapaacagaagacuaaaccuacccagaauaguguucpaacuuagaggacuupcuuuccccagaucug\n", + "acauuupuuugcugaccaaauggacgauccuggaccucugaagcupaccagugauaaauccuccgug\n", + "agagcccgccuccgugaaagacugccpcgcaugcggucpuuguucacuggcuguccpcuccgcgcgcgucgccggcccagcucugucgcugacpaggaucugaagccggccgcag\n", + "agaacaguuguuagaaaacuaaacugccagagaapuuuagugccuaaccucugaaacaacuuuguucuucuagcuugguggaaccgupacauagaaagc\n", + "gcaupuuggaauuggagccuaucccccaacccgaaggcuaacagcaucaugugguuacuaacuguuccucauucaccgguug\n", + "aaucggcgccggccuugucucggcauuccpcucgaaggcugugcggucugccaggagcugcggccccguccggcccpcug\n", + "cuuuuguuucuucucuacaggcaupuuggaauuggagccuaucccccaacccgaaggcuaacagcaucaugugguuacuaacuguuccucauucaccgguug\n", + "guugccuucuuccucaucucugcaguaacugucuucaugguuucauagccuucucccugauaccccuccccag\n", + "ugucacauuugaagacgagcacugaggaugaggaaccaacugaagaauaugaaaauguuggaaaugcagcaucuaaguggccaaaaguggaggauccu\n", + "acupagaaaccagaaaggagagcacguuccguaaaaacaacaacuacuagucggccgaacuccaagcgugaccagcuuucuguupaacacucaaag\n", + "gucccugaaugagaaggagcugacagcagcugaauuccaucuucucugugugcupagcapcuacacggcccagguggcauca\n", + "agucugcggupcuagcggacgguccggcuuccggcggccguuucugucucuugcuggcugucucgcugagucgcggccgccuucucaucgcuccuggaaggucccgagcgcgacacc\n", + "ggcuagcggacgguccggcuuccggcggccguuucugucucuugcuggcugucucgcugagucgcggccgccuucucaucgcuccuggaaggucccgagcgcgacacc\n", + "guuuccacuaapcuaauuagagagguagccuugaagaauaaacuuaccauuuauauaaaapcuacuggacugauacacagcugaaaacccucaguucuggacugaacucccagcag\n", + "accaguaccugucacuapcaccagacacacaucugaguauacaugaguagagcugaacaaccugaauguuggugcuuuuuauuccaugccuggagguuuaguuuuuuuuguuuuuuaaguacaag\n", + "cucucgagucacuccggcgcaguguupacugucupuaucggaaagcaagccuacguugcucacuauuacguauaauccuuuucuuuucaag\n", + "ggcacgcaguagcucucucgagucacuccggcgcaguguupacugucupuaucggaaagcaagccuacguugcucacuauuacguauaauccuuuucuuuucaag\n", + "gcuccaggcgaguccuucccuggacuccagucccuugupaaacaaucccucgccuccggaggcggcgaggagcggcgg\n", + "aaccuaaauugguaauaaaucaauaagaaauauuuacauucacucagugaaaagugucaugucugagcucagcauauaucggagccacacauggacac\n", + "cgcaugugcauccccgccucccgcuccaggcgaguccuucccuggacuccagucccuugupaaacaaucccucgccuccggaggcggcgaggagcggcgg\n", + "auucugagcagagcacugguucagauucugagguccucacugagcggacuuccugcuccuucaguacucacacugaccuggccucuggugcugcaggcccugugccugcugcc\n", + "ugucaagcugagcucccagacucugauacaggcupaugaugagaagaaccagaggacgaucacugucaacccugcccac\n", + "gguguccuguucccagaccugagcugaucuaccaccuagagcaupcaggagccauggaccaggaaggaagaccucucccaaggcaccuguccag\n", + "agccucugagcagcgucuccucucuggagguccacuucgaccuccuggaccucacugagcucaccgac\n", + "gcugccccgaugcgcugcgcccggagccpccgagucgcugccgcagcuguupcgcccpccaggcgacgccgccgucgcccgugccccucccagaccgcaccggccgc\n", + "gugagccgagauugcaccacugcacuccagccupugacagagcgagacuccaucuaaaaaaaauaaauaaac\n", + "cucuuucuuuuccggacccugcaguggcgccuaaagucugagagapaagucgccucugugcucgugagugcaupuauaag\n", + "cccgcguggccguggcagcgccacgcgagcccucuaggcgaccgcapccacagcagcucagccgccggugcccccucggaaaccaugacccccggcgcpcccauggagcc\n", + "ggaaguaccucucugagcgguuggugccpuauaaaagaaggccgcgcagccacggcugcucacgacgccgcggaucccgaagccuguguagcagugagacauc\n", + "ggaagcgccccggccagaaagugaccccccaccccuuucaggacccugugaacpaacagccauccagapuucaggaaggcguccgcgcccucaccucuucucccc\n", + "agagacuaugapuucacuaucuguuugcuggaagauauacaagacuuuugaggauaauacuuaaaugaagauagaccggaug\n", + "uauaauaugcuuuuucuuagcuuuccuaugacucuacuuagcaacuuuugcuaaaagaaacacaauauaugacugacuacuuugaagacacauauauuggacacuuaaaaucaacaaaagcagagag\n", + "gucccaaacgugguaucuuuucacaaugauguauuuuauccgaauucuuggaauuacucauggugucuuucaaaauuaaagaucugugaaaccugaagcagau\n", + "guuucagaagcaggcaacaggaacaagaugugaacuguuucucuucugcagaaaaagaggcucuuccuccuccucccgcgacg\n", + "gccucuggaaggaucuggaaugcaccugaagcucccaggacuugaagacagaccuccaaagacuuggaucag\n", + "cuggagaguaaaaagaacupuaagagccccucugccuagcacugcucccccaaggcucccagaaaucucaggucagaggcacggacagccucuggagcucucgucuggupacc\n", + "gcuggagaguaaaaagaacupuaagagccccucugccuagcacugcucccccaaggcucccagaaaucucaggucagaggcacggacagccucuggagcucucgucuggupacc\n", + "agaacupuaagagccccucugccuagcacugcucccccaaggcucccagaaaucucaggucagaggcacggacagccucuggagcucucgucuggupacc\n", + "aaaaagaacupuaagagccccucugccuagcacugcucccccaaggcucccagaaaucucaggucagaggcacggacagccucuggagcucucgucuggupacc\n", + "agagcgcagcggcgagcgugacuccgccaucagguccccggcucccuccccggaccuagcccacuccgcugcgccagcgccgcpca\n", + "gcpugagaaaagcucaggupcccgccpccgaaggagguaacccggcgcccggcccuagccagccccpcucpcupagauc\n", + "ccccacuupccuucggcuucccgcgccccgcccccagguguccuauuuucucuucgucaucuucacggcguaugcc\n", + "gucacugcagccagapuccagaagagagaggaggcacugccuccacuacagcaacugcacccacg\n", + "capucuugcucugucgcacaggcuggagugcaguggugugaucauagcccacugcagccuugaccacccupaucaagugaugcucccaccucagccucccgaguagcupacuacaggu\n", + "acuuccuucucgagcccggagccgcugccgccgcccccagcucccccgccucpapcaccag\n", + "augaggaaacuggaaucuaagaucacacuggaauuuacagacgaagaaacuggaaucugagaucucacaguagugaauggugaauauucaaacccag\n", + "gguugccgccuuagcpcgccuccuuuucaucccucauccuucaucccuggcuuucgcgcucuagcggagupaucugcgaacacgugaggcpcgcgguccccaggcugccgag\n", + "ggcacuuucccucaugguauugauauuuugaccacagcugacuauuuugccgucgguaacagauccaacuguuuccugguuauaag\n", + "ccccgaccugacccaggccugcucgcucuggugugcaccgaccugccagcuuuguggcacuuuguggc\n", + "gacggccugguucgcupugugccucacagacacaggacacuuuuuapuugcuuuugaaugugccugag\n", + "ggucauccgagaguuggcugcgapcgcugcacaaccuggcccagcaggcacccgaguucagcgccacgcaag\n", + "agcgucgguugccgccuuagcpcgccuccuuuucaucccucauccuucaucccuggcuuucgcgcucuagcggagupaucugcgaacacgugaggcpcgcgguccccaggcugccgag\n", + "ggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcggugcgugauuagguuggcgaag\n", + "cgcgugcgcacuggcgugcgagacucggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcg\n", + "gugcgcacuggcgugcgagacucggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcg\n", + "apagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaagg\n", + "guccaagugauuccuguggcucagcuucccgaauagagcupagcuggcgugaucucagcucgcugcaaccuccgccucccag\n", + "gugcgcacuggcgugcgagacucggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcgg\n", + "ggcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcg\n", + "cgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcg\n", + "ggcgugcgagacucggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcgg\n", + "uuguuuccgcucccgcccaggacugugcgcucggcucgcggupuccggcpcgcggcuucggcpcggcagccgcugcagacgagcugcgg\n", + "gacucggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcggugcgugauuagguuggcgaag\n", + "gagacucggcpcgcuguugapagucpccgcgacuguggucguuuuuauaccuucccgcgcggacgccggcgcugccaacggaapcpuapcggugcgugauuagguuggcgaag\n", + "gcucugcugccaugaaggugaagauuaagugcuggaacggcguggccacuuggcucupuggccaacg\n", + "agcgccuugccuucucuuaggcuuugaagcauuuuugucugugcucccugaucuucaggucaccacc\n", + "apcgucccggagcaggccaacpacuacpaagcagcpcagcggcccgcpaggcaccucggagaucupugcaaaagcccapuuaggaaccguaggc\n", + "ggagcaggccaacpacuacpaagcagcpcagcggcccgcpaggcaccucggagaucupugcaaaagcccapuuaggaaccguaggc\n", + "gapcgcaggcgccacggcccgucgagcupuuccaaggcggcuggcggcgguagcgucucuguuuccuugupcgcucgcgcggcccugg\n", + "aggugcgcgcguggcggapaacagagaagcaggacagcucuccauccuucccguguucagucgupagacaacaagagaggucacagccuggcgaccaaaaa\n", + "guupcggugucuaugguugagcugapcgcaggcgccacggcccgucgagcupuuccaaggcggcuggcggcgguagcgucucuguuuccuugupcgcucgcgcggcccugg\n", + "gagcupuuccaaggcggcuggcggcgguagcgucucuguuuccuugupcgcucgcgcggcccugg\n", + "cuugcugcagaggauccaguccagaucccaggagagccccucugccccuucggaccucgucucccaucuacaaaacgugaagauuggcccaguuagcgugucucuacaaaaaggugcauauaccacug\n", + "uacaucgaguuagauggagaccgucugaccacggaggaucuggucaacuupaaapacgcuacaaaauaaag\n", + "cucaccccaacagcugagaagapugcagaaauccapaggucauagauagcaucauaaaagagaaaacag\n", + "cugaccacaccccgguagccacuccugcauaaagcucuccccuccugugaccagcugaggaccucaggcugcagcggagcc\n", + "cggcuccaggaggccccpcccggcccpcggcgguggcgguggcggcucuagcucgagacgucuguggcgcccucgcaccgcgccgcagcc\n", + "aacauggaggaggaacagcuggccuuguaagugaucacagagugaaaccagccuagucuguugcauuguuccuuuuuuuuuccaaaggaaauauaapaaaccaapaauuuuugcuc\n", + "aggaggccccpcccggcccpcggcgguggcgguggcggcucuagcucgagacgucuguggcgcccucgcaccgcgccgcagcc\n", + "cucuugaggaucuugcuuguccaaacccagaagacagugcaugaagccapacauccgccaugcuccaaacaacuuggccucag\n", + "uagcguuuccauuccccaaaccugcucugaucucccaccuggagagapaagcaccaupcccagaucccupacaccgagauucugagaggcaucagucaag\n", + "guggugaguccuggaucaaaaaugaapcuaguuauaaagcaggaagccucugaagaaacagaguugcacaga\n", + "cccccaggaccpaggcacagguggcccccaccacccggaggagcagcuccugccccuguccpaugacugauucuccuccgccag\n", + "cagcccccaggaccpaggcacagguggcccccaccacccggaggagcagcuccugccccuguccpaugacugauucuccuccgccag\n", + "ugguugcgccugcgcagugcaucaccgcaggcpccucgcpuccpagcgcggcggagacg\n", + "aaguugcagcgaggugguugcgccugcgcagugcaucaccgcaggcpccucgcpuccpagcgcggcggagacgaugccugagaucagagucacgcccuugg\n", + "guugcgccugcgcagugcaucaccgcaggcpccucgcpuccpagcgcggcggagacgaugccugagaucagagucacgcccuugg\n", + "aaguugcagcgaggugguugcgccugcgcagugcaucaccgcaggcpccucgcpuccpagcgcggcggagacg\n", + "gcagugcaucaccgcaggcpccucgcpuccpagcgcggcggagacgaugccugagaucagagucacgcccuugg\n", + "guagaugaugagcuggagaucaaggccuacuaugcaggccacgugcupcagccauguuccagauuaaagupcucagagucuguggucuacacg\n", + "gugcugauaccuguguucgcgcupccgcgcccaggagcucugcauccuccuggagaccuucug\n", + "gugccugcccugugcuguccuggaaccugguccuuccaccpcapucgapcaccuuccagcacagacaccaggacpauuccauguccucccccauggc\n", + "augauagagguacugacaacaacugacucucagaaacugcuacaccagcugaaugcccuguuggaacaggagucuag\n", + "auuccucguuapcaggcgcggccccuucggcuccgagcugacccugaucapccgaguugucucggcggcgcugccgaggccuccacccag\n", + "acccugcuucggcucgcgcauggugcgcgcacccacugaccugcgcccacugucuggcacucccuagugag\n", + "ugaaggaccuacuagaggcagguppagccaccaucagaucauaagcauaagaauaauacaaapapauucuucugcaaccaagaggcaagaggcgagagaaggaaaaaaaaaaaagcg\n", + "agugauuuuuuuccuauuuauuuuaaauacacacacccacapcucugcccccuguaaaagaaaaaaaaucaaaacaaacaaauaaauaaccccaaagag\n", + "aaaacaaacagaaaguuggccugcugucucuccaagguggcccugucagugaacccaaggccgaagaccacagguuaaucuuugcccaggcuggccuugguggcagag\n", + "agcagcuuguauucuuagaaacgcagcagacagcaacuuuagcaggugauuucaaucaagucagcugaa\n", + "ggugauuucaaucaagucagcugaaaugcacucacuuccaggugaucggccuugguucuguuaagaccauuuuuggaupuguuuuaaag\n", + "agcagcuuguauucuuagaaacgcagcagacagcaacuuuagcaggugauuucaaucaagucagcugaaaugcacucacuuccaggugaucggccuugguucuguuaagaccauuuuugg\n", + "agcagacagcaacuuuagcaggugauuucaaucaagucagcugaaaugcacucacuuccaggugaucggccuugguucuguuaagaccauuuuugg\n", + "cagcaacuuuagcaggugauuucaaucaagucagcugaaaugcacucacuuccaggugaucggccuugguucuguuaagaccauuuuugg\n", + "cgcgucccccgcccgcccaggcgucagcugaupcugccugccgaggaggccgcagcagucgccgcgcgaac\n", + "cuguuuugcaacuucuuguuuaugagccuggaagccacgaaguggupaaauacgagauucaaauaucugguggccgugugac\n", + "ucuagcucucagucugcgcgapuguaggaaggaaagcccaggaccuccggagcagagcacagcagcugcagaggcaaggccagc\n", + "agcuucuagcucucagucugcgcgapuguaggaaggaaagcccaggaccuccggagcagagcacagcagcugcagaggcaaggccagc\n", + "uguaggaauugaugagugccaucagaaagcuguaucaugagcugccugcacuucuaaaguguccaguggauuuuuaaucacaugag\n", + "ccuggaaauapuuaugagaagaagcucagagcagagcaccgaaaguggccacuaccagcaugaagagcccaacaauucaaacug\n", + "gaaauccacuggagaugguuucaagauauaggauccuuauaugugaaguaucccaaaugaaguuggagcauccauguugaaauugcuucauguugug\n", + "gaauugaugagugccaucagaaagcuguaucaugagcugccugcacuucuaaaguguccaguggauuuuuaaucacaugag\n", + "pacgcagguccgaacccggcugagcucuggaaagcugugccuugaacuggagccacuucpaugagauccugacccgcacccugapcagccccpag\n", + "gucccaccuacuucaaaugauugagaacuuccagucuguguauuuaugauacggaacaccaguguacaccagucucauugucuugauggcaguaacaucucuacuauuaacuaaugcuuuuuau\n", + "guaugaauccagccauccucagcaguggcaccgauaucuucaaaagugucguuugucuggcucucugccuucuggaupaagccuacccugaugucucucuucaaaucu\n", + "agacgcggacagcgccpacucgccgccccpacucgcgcagcccgcagcgcuccggcuccuccucucgcgaccgcccuccgcagcg\n", + "aggccucaucccugcucugccauuuaucucpagagcauggugccucucccagccuguuuccuucucuguaa\n", + "paggaagaaaaaagacgaggaggacapcppcpaggcuugccaccuucagcccccccgcgaacgcccaag\n", + "gugcacacaucuugaccaacucagcagcaagguggauuuucuuuguguuuaaagaaaaaaaaugucccugugucuguagagaugauuugcaguucagcccggcugaagcugaccgaaugagacu\n", + "ggaggaagaagaggaggapaggaagaaaaaagacgaggaggacapcppcpaggcuugccaccuucagcccccccgcgaacgcccaag\n", + "aggauacacugcgcagucupcpccggaguucaagccucggaggaaguaaaugcaaaucuaagcgagcgcugupcg\n", + "ppcpccaggccpcpccgcaagcggcauggaggaggcggaggccgcggcgagccpccgagcagugapcccuagcpcccgagcpcccpccccuaagcc\n", + "pcpccaggccpcpccgcaagcggcauggaggaggcggaggccgcggcgagccpccgagcagugapcccuagcpcccgagcpcccpccccuaagcc\n", + "uaacgaacuuugagccgauuauuuggccuccacccuuggacagccuugauucagagaguuacuccagucucapaauuuccag\n", + "pcpccgcaagcggcauggaggaggcggaggccgcggcgagccpccgagcagugapcccuagcpcccgagcpcccpccccuaagcc\n", + "pccgcaagcggcauggaggaggcggaggccgcggcgagccpccgagcagugapcccuagcpcccgagcpcccpccccuaagcc\n", + "gcaucagacuuupaggagcaucuuaccccauguggcccucuggucccuucagauuccugaagucaupcuggccaggacauuggugacccgccaauccggu\n", + "auuuuaccgaccguucgcgaaacagcuuuccacacaauggagcuucauguccucgugcaggaaguacucaucgacugauguggcagacuuugcucccuggcaaaa\n", + "cuuauuccuccugcuuugcugaaaccacagcugccuugaaucgagccauuuugauucugccgcaaaugagcuguaaaccaaaucaagccacaucaaacaaauccaaccaccaucaaaagcaa\n", + "guacaacucggacuugcuguugcucgagccgcgucugcacpucucggaccgagcggagcucgcagccucggucccggagcccaccuucgccucgcccuugcccagccugcggug\n", + "acucggacuugcuguugcucgagccgcgucugcacpucucggaccgagcggagcucgcagccucggucccggagcccaccuucgccucgcccuugcccagccugcggug\n", + "gauuggcagccaccauuugcaugugauguugauaaacuucauuuuacgccacguauccagagacugaaugaauuggag\n", + "gcccaaacucguguaaaauugaauuucuuggaccagauugcaaaguacupaguuacapaaguacucugaaaauuccacauguggagaggaagaucuuggacuuauuucagcuuaauaag\n", + "uuaguugcagaagaagguggauuugcaguuguuugcaaggauagaaaauggaccaaaauugcuaccaag\n", + "cugugacaugcuaaguuaccuaaccaugguguggaaggagapaaauggagugaaguupacccaccapaacag\n", + "guuaccuaaccaugguguggaaggagapaaauggagugaaguupacccaccapaacagguggcuugapcppagcaugaag\n", + "uugacacuuacuuugacaaaggcaaauuuggaagcaauuacuugaggacaguucauauagcaucuggacagucaacacpcacc\n", + "uugacacuuacuuugacaaaggcaaauuuggaagcaauuacuugaggacaguucauauagcaucuggacagucaacacpcaccaugaagcacuuccugag\n", + "ggugaggaagaagaggcuccuacuguagacagccuuguucuacagauccucccagaaaucucupccagguggaacccapucagagapaupagagag\n", + "auuccccaggcucucagagaagaucagcagaaagucugcaagacccuaagaaccaucagcccucagcugcaccuccuccccuccaagg\n", + "ggacugupagcggcuuccuuggauuccgcgcuuggcaacggcucggcgucgcgcuuuggccaaccgcugcgucgucccupcccgaauaacugucgcccgcuucccucagcgugag\n", + "gugaagcacuucaaauugccugaugaaaguugaaucaggaaugaagauaaaaguacacaacaaugcagaaagcgguacuuagccucacaaagauggaaacauuccaaaaacgugaa\n", + "aaacugcaguaggcuucuuggaaguagaccaapuguccaaucuuuggcuucccupccacaucggaagaagaauugucuupccacac\n", + "cuuggauuccgcgcuuggcaacggcucggcgucgcgcuuuggccaaccgcugcgucgucccupcccgaauaacugucgcccgcuucccucagcgugag\n", + "cgcgcuuggcaacggcucggcgucgcgcuuuggccaaccgcugcgucgucccupcccgaauaacugucgcccgcuucccucagcgugag\n", + "uauccuaguccaucuucaguggcuguaaaccagcucupuauacugaagaucacuacauaugacaagucuuucacaggacaccac\n", + "agucaucauaguggcagcuuccgccugcuacaggauauuuauauauggaagcauaccauggcaggagugcuggaaagguggugucagcuaacaguugcuucagccagauaaggacg\n", + "aggaaaaaggaugaacaaaugccugugugguuucacuuauauaguacucagcuugacgccaugugaaaugaagag\n", + "gaguuagaagccgcucuucacagagaugacguggaguuuaucagugaccugauugccugccugcuucapcugcuaucaacgaagagauaucac\n", + "ggccuggaugcagacagucuccguguggagccauupugaagacaauucupcacuauauugguauuucuauggaacacga\n", + "acacgcgacucccacaagguugcagccggagccgcccagcucaccgagagccuaguuccggccapucgccccggcaaccacgagcccagccaaucagcgccccggacugcaccagagcc\n", + "guuccggccapucgccccggcaaccacgagcccagccaaucagcgccccggacugcaccagagcc\n", + "gacuaucugcugccaaacucuugacugaauauggcguuaguguuuugguuuuagaagcucpacapuuggaggaagaacauauacuauaagg\n", + "paaaacauauccauuucpcgccuuuccaccaguauggaaucccauugcauauuuggauuacaauaaucuguggaggacaauagauaac\n", + "gccaagagaagagauuggcaugaacuguugcuuugccaguuccagccaguaccagcaaaaacauacauguauguuggagcaucagaggaaagcagcuccugguggaga\n", + "aaagcauggagaaucaagagaaggcgaguaucgcpccacauguucgacguagucgugaucggagguggcauuucag\n", + "paaaacauauccauuucpcgccuuuccaccaguauggaaucccauugcauauuuggauuacaauaaucuguggaggacaauagauaacaupaaggag\n", + "cucugagccucacgaagugucugcccugugguucuugugguaugugaagcagugcpcaccacucggauauucucugucaccaaugguggccag\n", + "acaccpcucucpcacccgcgcggcgccgguuggccuucccggcgcucgcccpcgcgcuugcgcgccagcggcugcggacaccagccugcguccccggcgcggcpcc\n", + "uuagcaaccaagucgcggcgcuugguuccccagcaaccpagacgcgucugcugcguggaaccgccgaguucccagcgcuugagaag\n", + "gaaaauucuggaucuguuaucugugaggaggccacuccguugacaguuguguaaaacucugcugcuuuccccagcuccaaccucucuggucuucaacaacacuaucaucag\n", + "aggaugucucccuucugacuuccccuuagcaaccaagucgcggcgcuugguuccccagcaaccpagacgcgucugcugcguggaaccgccgaguucccagcgcuugagaag\n", + "cuucugacuuccccuuagcaaccaagucgcggcgcuugguuccccagcaaccpagacgcgucugcugcguggaaccgccgaguucccagcgcuugagaag\n", + "agcaaccaagucgcggcgcuugguuccccagcaaccpagacgcgucugcugcguggaaccgccgaguucccagcgcuugagaag\n", + "ggucuuccuauguugcccpcuggucuugaacuccugaacucaagcaguccuuccaccucggccucccaaagagcupauuacaggu\n", + "uccccggacgaaauccgcggaccpcuuuagguucgccggaaucccacgcucccgacuucugcuuccpucggagcc\n", + "agccuggucucgcuccacgucuaccgcgccugcuccccggacgaaauccgcggaccpcuuuagguucgccggaaucccacgcucccgacuucugcuuccpucggagcc\n", + "agcagguccugucccuaggagauaagaguaucuugcacagcaggugcagguuucccagcagcucaggcaagaguccgauguuugugccaucugauccug\n", + "aupcagugaugacaccaaauauaagcauaaaaagacguuuuaaaacuacagauccugaaacccagcacggcaggcaccugcagcuuccagugcuguaacag\n", + "aguuucacucuguugcccaagauggaguacaguggugcgaucaccguucacugcaaccucugcuucccgaguuuaagcgauucucaugccucagccucccaagcaucupacuacag\n", + "auguggaggucagaguggaagcaggugagaauggapcggcaaaggcucguuucupcaucucugcaguccuccucugcuccaugaugugcacuuupcgaggagagugcgugc\n", + "cagaguggaagcaggugagaauggapcggcaaaggcucguuucupcaucucugcaguccuccucugcuccaugaugugcacuuupcgaggaga\n", + "uuaucuuggccccaggaugucauccagcuccugcuuccauaagaagcaugucguucuuaauacacgauguugacaagcaguauggugaggag\n", + "pcpcagaggagcucaugcgcaguaugugugguupaauucauguggaggucagaguggaagcag\n", + "pcagaggagcucaugcgcaguaugugugguupaauucauguggaggucagaguggaagcag\n", + "cgcggccuugcucucuuccggucgcpacaccpuguagapcggucgcggcpcaguggcggcag\n", + "aauguuggcuaccapuauuuagccuaguuggcaagcgagcaauuuccaccucuguguguguacgagcucaug\n", + "gccpugcpcggagucuuccucgaucccguggugcuccgcggcgcggccuugcucucuuccggucgcpacaccpuguagapcggucgcggcpcaguggcggcag\n", + "aguuuagacaaacacupcgacgguggcuccagcauguaucagccgagguggagcugcpcccuggc\n", + "accguguggugcguaaauuauagcguccggccaaggccgcaappcgccgccggugagcuggcpucgugcpaagcagcacccccgcgccgugccapccggccagcguccgcag\n", + "gguccucacugagcagcgagucgucccccguguccucuccggccaccaaccacagcucccccgccagcacacccaagcgcgugccc\n", + "aauucaaagaagcuuuuucacuauuugacaaagauggugauggaacuauaacaacaaaggaauupaacugua\n", + "gapapuuggccpacucguuugcgauguuccguuaucuggaugcggcggapaucuggcggapagguguuu\n", + "aguccgaguggagagagcgagcugagugguuguguggucgcgucucggaaaccgguagcgcuugcagcaug\n", + "gaauuaguccgaguggagagagcgagcugagugguuguguggucgcgucucggaaaccgguagcgcuugcagcaug\n", + "gcggcccgagcagcaacggcagaagccgcaccgcgucccggcggcggcugcgagucccagugacgcauugcag\n", + "aguccgaguggagagagcgagcugagugguuguguggucgcgucucggaaaccgguagcgcuugcagc\n", + "ggagcucagupcgucgcgcgaaggcuaapaguguggcpcggcuccpagccaacaugccucg\n", + "ggapcaggagcgcugcggucgcugagcguuugcacguuugcaccucucuguggaagcagugcgucacaggapaaauauac\n", + "gcupcacagaguaaguuucuucacuuagcuccuacuaacaguggugguupuggcuguuuacugacuggauuucuuacccuuuuaag\n", + "aaucugaauuauccagaacagaaaguugugacuguuggacaguucaaaauuggucugauccauggacaucaaguuauuccaupagau\n", + "cuugacguccggagccccuggaguaggcgcuuccggccauucauacugcagucggucaguguucgguugaaggauucugugugcugucggacccagapugacggcgccgcuagg\n", + "cuggaguaggcgcuuccggccauucauacugcagucggucaguguucgguugaaggauucugugugcugucggacccagapugacggcgccgcuaggaugaagcucgugag\n", + "gugcguugcccggagacggaaaguuupagcccgagcaggcucggcugcagccucpapuccagcpuggcggcccup\n", + "gcagcucpuuuccgagcuucugccucaggcaucuccgcgaucuccucuccccuccaauccuauccgug\n", + "aagauccuggccugugcagcucpuuuccgagcuucugccucaggcaucuccgcgaucuccucuccccuccaauccuauccgug\n", + "gaugucaucgcugcgcgacgacaggaaguaagauccuggccugugcagcucpuuuccgagcuucugccucaggcaucuccgcgaucuccucuccccuccaauccuauccgug\n", + "ggcugugugaccuuugaggacaucgccauuuacuucucacaggacgagupacuucuugaugaggcucagagacuccuguaccuugaagug\n", + "puucuaapucggcggcggcpuugacggcuuugccuaggucccuccgcccguagcugucpucccggccccgcucugcccacagacuccg\n", + "gapagguguagaaagagguacauggagaacaaguuugucaauccgucugaacuucaguugccuuaccuguaag\n", + "gcagccgugucuguguuuuugucucgcagaauuagagcccauupaacgaugccaccaccgucagacauugucaaaguggccauugaguggccaggugcuaacgcccagcuccuugaaaucgaccag\n", + "aaacggccccuggcauccauuaucaaggaaguuugugaupuagguugaaauggaccucguuuucaacaguggcagcuccgacugaaagagcacuccuacaccuugag\n", + "guggucguugccaaacccagaguauuauacccuccguuaugcagaugguccucagcuguacaucaccgaacag\n", + "ucccaagaaggcpcpcggaggcuggaggagccgccgagcggagacccpagcaggagcupccuaggucugcgcccug\n", + "pcggaggcuggaggagccgccgagcggagacccpagcaggagcupccuaggucugcgcccug\n", + "gcaucccaggauuuggaauucagcugugagcucaugagcugauggauguuuccaggaguacccugaagaccacccag\n", + "gaacagagcaagugguucuggccucccupauuuggauccugguuuccagagcuaagaacacaaag\n", + "gguccccagcugcugagcagcuccaggacauccupaggaagaugaggcucccaaccccacccucuuuacagag\n", + "uggacaugguucagaaacagcuaaagcagacaagaaucupcagccaauauuguaccaccugccaaagcuuggcacaaacaaucuggaagccaaaaauugcacauacugug\n", + "auacuguucagccuggaaaccacagagagcccuucuugccacccaacaggaacagagcaagugguucuggccucccupauuuggauccugguuuccagagcuaagaacacaaag\n", + "cpucugagagaaacgcccaccupaggcugugcagcpuggcucpcacccugcucaacccgcagcggagccgccagcgaccuucgaa\n", + "cuugcgcgguguggcggccgaugccgcuauaaaggcuuguuuugcugcapcucaugcucpagcgugguugagcggcuggcgcgguuguccuggagcapcgcag\n", + "ccgcuauaaaggcuuguuuugcugcapcucaugcucpagcgugguugagcggcuggcgcgguuguccuggagcapcgcag\n", + "aagcacacugcuuauuaaaguacacuauucaggcauaucauguagguuuacuuucuguguuucuagagaccaagaagcpacguucacc\n", + "auucugcucucuuugcugaacucgguuauuucacagacacugaugagcugcaauuggaagcagcaaaugagacguau\n", + "pagaaggaacuugugaaaupagccggcupuugccggcaccauggagucaccuuuuagcccpacucuuucacaggcuggaugaagauup\n", + "auauuaaucacggaguuccapagaaggaacuugugaaaupagccggcupuugccggcaccauggagucaccuuuuagcccpacucuuucacaggcuggaugaagauup\n", + "cucuucccagcguuccuccuccggccccaggucaccgccagcacgcgccugcuucccgucugcgcgaguccacgcagcuccccag\n", + "aucaagaagcugaggccccagguuacacacuaaaguaaauggcagaggcagaaauaacaccuauguccuccugaccccaag\n", + "cuccggccccaggucaccgccagcacgcgccugcuucccgucugcgcgaguccacgcagcuccccag\n", + "auauuggcgucggccgcgcuguauugucauaaauagagccgguuuugugguguuuucacuacucgguuggaugccucagccaua\n", + "aaacaccgugcuggacagccagcgucaacaaaagcauuauggaauuaccuccccaauuaguuuggcaucuccuaaagaaauugaucauauuuacacacagaaauuaauugacgcc\n", + "auuccgcgcuaccgaguacuuucuacucccgaccaggcauugcucucucuggagacccucggcggugguugcuguauuuugacuug\n", + "gcccgccucgaaugucccugagacccagaapccugcgcucagcugcucuggcaccccgcugcap\n", + "ugagacccgcguagagcaaagcgcaaggucccagcgccccuuggauccucgguggcapuccpcaagugucauugcgapuucaggaagccccggccugugaucgugagcg\n", + "gcaggcaggaggcuupaccuuccapaucguaggacgagaagaagaauauucuuucugguuguguugcgugu\n", + "pcgcugagacccgcguagagcaaagcgcaaggucccagcgccccuuggauccucgguggcapuccpcaagugucauugcgapuucaggaagccccggccugugaucgugagcg\n", + "gcgccccuuggauccucgguggcapuccpcaagugucauugcgapuucaggaagccccggccugugaucgugagcg\n", + "agugugaggagcugcuauggugcugaguuuccugguagagccggccgagcugaggcggucgcggcc\n", + "aucaccgcccagapaaggaggucggcagugugaggagcugcuauggugcugaguuuccugguagagccggccgagcugaggcggucgcggccaugaag\n", + "ggcagugugaggagcugcuauggugcugaguuuccugguagagccggccgagcugaggcggucgcggcc\n", + "aaucaccgcccagapaaggaggucggcagugugaggagcugcuauggugcugaguuuccugguagagccggccgagcugaggcggucgcggcc\n", + "ucggcagugugaggagcugcuauggugcugaguuuccugguagagccggccgagcugaggcggucgcggccaugaag\n", + "gupagugguacuaaggaucaaguauacuguuaaaagaaaacaaaaacccaagcaugaggaag\n", + "aucgcagcgucggauguucagagcagcagaagccggcgucgucggauguuguguugcccgccacc\n", + "ggucpaggcpcucpuguguguggapacccugugguuagcagcagcuaucgcagcgucggauguucagagcagcagaagccggcgucgucggauguuguguugcccgccacc\n", + "puguguguggapacccugugguuagcagcagcuaucgcagcgucggauguucagagcagcagaagccggcgucgucggauguuguguugcccgccacc\n", + "gcucpuguguguggapacccugugguuagcagcagcuaucgcagcgucggauguucagagcagcagaagccggcgucgucggauguuguguugcccgccacc\n", + "auugccagcagcuuccagccacugauaugaggaggcauagagauagacagcgguuccuuccaauagacgugaagccgaggccg\n", + "gcuuuguccapaucugaaaccacuuugcagucgacauacucggauaccagcgcucagcccaccugugauuaug\n", + "gcuacgapcuauggcuauggcuauggcuauggccaggauaacaccaccaacuaupuauggu\n", + "guguggapacccugugguuagcagcagcuaucgcagcgucggauguucagagcagcagaagccggcgucgucggauguuguguugcccgccacc\n", + "guaaagugaaugccgaagacagaagauuuggaugauacaccacugacuuucuuuguuuggaauacacguu\n", + "cpaucaagcapcapcuggcgcugcggcpagaugcugucpccgcggcggcgcuuggcagccaggagcucugcauugaaggcacup\n", + "pcapcuggcgcugcggcpagaugcugucpccgcggcggcgcuuggcagccaggagcucugcauugaaggcacup\n", + "agaggcaaccaaaaauggaccaaacaacccggccagagaaugcggcuucugaguguaagacacugaggcggugucacagacag\n", + "gcuggcgcugcggcpagaugcugucpccgcggcggcgcuuggcagccaggagcucugcauugaaggcacupugaggcuuacugcccggcaggcuggugg\n", + "uacuuaccupcccggagaagguggapagacgagaagccgccgagagccgacuacccuccpcccagucugucuguccgugguggaucuaag\n", + "pagacgagaagccgccgagagccgacuacccuccpcccagucugucuguccgugguggaucuaag\n", + "augccucugcagccucaucuguauccucuugugauggcgugaaggaaagccauggcagauuuccagccuggugaugcuguacagaacacagguggccugcuuccaugccuccucagcuucaag\n", + "agucucgcugugucacccaggcuggagugcaguggcacgaucucggcucaccgcaaccuccgccucccpuucaagcaauucuccugccucagccucuggaguagcupauuacag\n", + "ccucaucuguauccucuugugauggcgugaaggaaagccauggcagauuuccagccuggugaugcuguacagaacacagguggccugcuucc\n", + "cugccagcguguccgugucggcugcuucuuuuggapagccagupacpagucucagcaggcupuguugcacuuuuccuuuugucugcagccugauguuugcuuugugcugaagg\n", + "uuaccupcccggagaagguggapagacgagaagccgccgagagccgacuacccuccpcccagucugucuguccgugguggaucuaag\n", + "acaucgcupuaucauccugccugcagcgcuccuucaugcaauaaauucugcaggcuacugauuaaacaaupaaggaaapagaaaaaaaaucuugaggucaggaaaaugcagccagaggag\n", + "guucuucuacuuaccupcccggagaagguggapagacgagaagccgccgagagccgacuacccuccpcccagucugucuguccgugguggaucuaag\n", + "gugguugccaggaaaccgcgaagccgcggucccugccucugagucucucucgaccauggccaaauucgucaucgcgg\n", + "aaaacgugcccaguguuucccuccgapcacugcgugccgcgcaggcgcaaapccaggugcuggaggugcuguc\n", + "guuaccuaaccaaacuccugcaaaaccacaccaccuaugccugugaupacuauuugaaucuacagugcccucggcauucuacgauaaguguccaaucggcauuuuaupcaagauuaccaa\n", + "guacuucuugucaauuccuccuugcuuuuccucauuguauuucuuuguuucucuuuuaucacagucagg\n", + "gcgcauucuuaccugucpugcggcgagugucucaccucucugcacuuccaaggacucuugucaucugccuuaggcpaa\n", + "ggccagccugcgcauucuuaccugucpugcggcgagugucucaccucucugcacuuccaaggacucuugucaucugccuuaggcpaa\n", + "gacugcggugapcgagccgugaagauggcggcagugguggagguggagguuggagguggugcugcupaacpagcugg\n", + "gagccgugaagauggcggcagugguggagguggagguuggagguggugcugcupaacpagcugg\n", + "gcgcpacugcggugapcgagccgugaagauggcggcagugguggagguggagguuggagguggugcugcupaacpagcugg\n", + "pacugcggugapcgagccgugaagauggcggcagugguggagguggagguuggagguggugcugcupaacpagcugg\n", + "agucugcuggaggcagcugaccuauuuuucuupaaucuuccugcuuuucuguucucucuugcgugaauaagcaggag\n", + "uguccggaaguccugagapaaacgcccgcaaaggcugguuuuuaagcpagcaucucuucacucgcagcaagugcgcgugcgcugccucucagcccaaauuggaaac\n", + "agcuaccaguuuggacggcugcuucccaccagcaaagaccacgacuggagagccgagccggaggcagcupaaac\n", + "aguuuuccccagcccpaaugagcggcpcaccaggcaucpccagcgcagccgccgaccgcugcccguggcacgcaccuccgaggaugucgcugcucccccuucccgcacag\n", + "cuaauuugacaggacaugcugagaaggupaauagaaaauuuugagcuccugaagguccuaggaacuggag\n", + "uuagagcaagacaaucaccaucugaauuccagaagcccuguucaugguupauauuuucucgacugc\n", + "auccuuugugagaucugguuuuacugaaaucucagaapaguuuuuuauucacgccaucgcugcagcucuu\n", + "guuauucacaucgaacuccuuugaugugaucagugaugaugcuuuuauuggucuuccacaucuagaguauuu\n", + "auucauagaaaacaacaacaucaagucaauuucaagacauacuuuccpacuaaagucauuaauucacuu\n", + "gagccuugcaaacaacaaucuccagacacucccaaaagauauuuucaaaggccuggauucuuuaacaaaugu\n", + "agagauacagaggcagaggaaaapuggacuccuaugugaccuguucuuagagcaagacaaucaccaucugaauuccagaagcccuguucaugguupauauuuucucgacugc\n", + "cccgagacaccugcgupaccugccuccaccacuccpcagccgccupuccacpcagccugagcuagcagcaggccucacauccggcccucagcucuuuuacaccaucuugac\n", + "gccccagcgcucggccggccgcgagcccgccggccpacgagcgucgcagcucaugcugaucgcuguccuccuccucccccucaggcggcgcuggcggcggcccupacccgcggaagccggc\n", + "gcagcucaugcugaucgcuguccuccuccucccccucaggcggcgcuggcggcggcccupacccgcggaagccggc\n", + "auucuggaccugcuuugccuuaggcugugccuaauucgaaaccaaagcgcpacggaugaaaguacpucgcgagagguuguucgcgccuugagaguuaagcgaagugugguggcuuccaag\n", + "ggaugaaaguacpucgcgagagguuguucgcgccuugagaguuaagcgaagugugguggcuuccaag\n", + "gagucuauaaagcaucaacucaaagugacaagaaguggacacauauucuaapagcuccccaggacaaaaggaagauggaggaaauggucucugaag\n", + "gcucaaagcagcucccccugccccguguaaagcgcugaugagauggcaauuuaaacugcuuugaugaccagguuucauuag\n", + "aagcagcucccccugccccguguaaagcgcugaugagauggcaauuuaaacugcuuugaugaccagguuucauuag\n", + "guucauguuguggaggcguugauacccucaugagaaauucuguuacuuccauaaaaguccugaag\n", + "guggucugaucuuccugcggcugaaccgcccggcugagccgacauugccggcgucuuggcgauucggcccgacgagcuccgcuuucgcuacagc\n", + "cuuccugcggcugaaccgcccggcugagccgacauugccggcgucuuggcgauucggcccgacgagcuccgcuuucgcuacagc\n", + "gugccugugaggaggcgcccpccgcaaccgcuuuccgagauccccagucgcgcacucgcuccccgcgcuccugapccgcccggccggaggaggccgucgcpcucggcguucagc\n", + "guucucapacapagagcaagaggucaagagcugupacaccacagagcagcacugaaggagaagaccu\n", + "gccugupuccccaucgcccaaguccugcccacacucccaccugcuacccugaucagagucauc\n", + "ggaggugagaaccuugcucucagapugacucaagucaacacapaaccccucuuuucuacagacacagupucgcaggaucugacaagaguccag\n", + "acuaacuuacgccucpaucagagagaagcgagguucucguucugapacaggcuugagaucggcugaagagagcpcccaggcucugugaggaggcaag\n", + "gagcuccapacugugaggugaggccuuggucuaaggcaguguuuucaggucacagagcagaaapcccagacagugccaggagucaag\n", + "cucguucugapacaggcuugagaucggcugaagagagcpcccaggcucugugaggaggcaag\n", + "ggaucagagagaagcgagguucucguucugapacaggcuugagaucggcugaagagagcpcccaggcucugugaggaggcaag\n", + "cuaacuuacgccucpaucagagagaagcgagguucucguucugapacaggcuugagaucggcugaagagagcpcccaggcucugugaggaggcaag\n", + "aagaagacaggugcauucuggaaacuugaaucacuaapaggagcuucaauuuugaucccagauau\n", + "auacuaauuuuguguupaaugcucagauaguggacuggccuauuguguacagcaaugauggauuuugcaagcugucuggcuaucacapcagaagug\n", + "acaaccagcugcagugguucgaupaaggaucuuucuccaagugguuccucuugapagcauuucugcuggcuccaggacuuuggccaucuauaaagcuuggca\n", + "aaagcuuggcaaugagaaauaagaaaauucucaaggaggacgagcucuugagugagacccaacaagcugcuuuucaccaaauugcaauggagccuuucgaaaucaaug\n", + "uuccaaagcccaagaggagaaaupugaacuucucccuagcugugguggucaucuaccugauccugcucaccgcuggcgcupcugcuggugguccaag\n", + "gapcuccaggagcggagcgcgccagagcgcgapacggapagaggaggagcgcpagcugcggaggcgaucccgcgaauucauuacu\n", + "gcccuggagacgcuuucccugcugccggccgcgaccgcaacccgcuaggccuucaucgcgagcuacgcccggaccgagaagccccggc\n", + "acuggucgaauugacaaaucuuacccuacaguauguggccacacaggaccagugcuggacauagacuggugcccacauaacgaucaggucauugccagcgguucagaggacugcacgguc\n", + "agugccaggcuggaggcggcagcgguuggaggcuucgcccggcuuugcagcpacuucggcggcggcgccucaggcaccucggcccgg\n", + "gucggaucpcccapuguccgagugaacupugauucagagguguguuucccuaauagcpcagcuggcgapacgcaguaaaaaggagcgaggugcag\n", + "cggcgcucagugccaggcuggaggcggcagcgguuggaggcuucgcccggcuuugcagcpacuucggcggcggcgccucaggcaccucggcccgg\n", + "cucuuuuuuuuuuuuuuuuuuaaccuaagaaaguaaagaapcaaguugcuaguagcuucucuguagcucucaccauuuaucuuuuuaacguaugcaguugaucacaagugugguaag\n", + "gaagcuguagagaaauaugaagaagugcuacauaauuuggaauuugccaaggagcuucaaaaaaccuuuucupuugagccuagau\n", + "acaaacacuugaaggaucuacugucuaaauugcugaacucaggcuauuuugaaaguaucccaguucccaaaaaugccaaggaaaaggaaguaccacuggaggaagaa\n", + "ggaaggcpcccpcugcggcagcggcggccucggcugccupaggugaagucpcugcggcggccucggucggcgcggcggapaggcggcugacccggcgapupcag\n", + "ccucaucuguuucaauggugcaacucuuuucauccccuuuugguuaccagucaccuucaggccauucagaggaggaaagagapaau\n", + "uggaaggcpcccpcugcggcagcggcggccucggcugccupaggugaagucpcugcggcggccucggucggcgcggcggapaggcggcugacccggcgapupcag\n", + "aggcuuuggaaggcpcccpcugcggcagcggcggccucggcugccupaggugaagucpcugcggcggccucggucggcgcggcggapaggcggcugacccggcgagg\n", + "ugapugcgcgcuggcgugcaupccuguucuguccuugguuupaugcuccuaappagaaapauaccucpugcuuggaggucgagagacggauac\n", + "guugagagaguaccugucugcaaauguccaguagugauggauugccuuguaggccccagagcaaucpaaguuagcauucuuguucaagaagcugcugguucacuuagagcuauaaaagaau\n", + "agaagcggcuucugcguacccpcggcugupaapupucggugccugcapcucuccguggccgcucpagaggugcucuucgcucaggcucccccggagacuugap\n", + "pcccpcugcggcagcggcggccucggcugccupaggugaagucpcugcggcggccucggucggcgcggcggapaggcggcugacccggcgapupcag\n", + "gccccgccccucggcggcuccaggugcggcugupaccucggaccgcggcpccpccapccpccpccpcgcc\n", + "agugaaaccggcggcccuggcacgugaccuaggaccggcucaccpucgcuugguggcuccgucugucuguccguccgcccgcpugccauc\n", + "gcggcpcugcgucggcugcggcpugupagguggcgacggccpccpuccugcccggcugcggaggcpcgcgacpcgcpucgcugcuccugaggcg\n", + "cacggaugupuuacaacuuggaaugcuugaggcugcagaaccccuccccuucuugacugagcaguaapuucccugcuguggugcaggaacaugupcagagcccupugucuccag\n", + "uaggcagaaggaggugauauugucuguugagaucuaaaguccuuuaugaagguccuccuucuccuuccaggapagcc\n", + "gcaugugaugugaaucagcugacaucaucuugacpagcccugugaggcggacacuuaacuccaguuucacag\n", + "ggcagaupuggcupccagaagcagauaccaggcuuucugacuccugcucuaggauucucaccacguacuggcuagacuuauacuucucaaaucuuaauuuccuaaag\n", + "gaagaacucgcaucagcuguccucaagagagauguggauauaaucaccuuauaucagaaggucucuguuuggcuguuaagauaugacuuugugcuugaauauccuaggccgguc\n", + "agagguagacaggaccugugaaaagcagugguuaguuuapaaaauaccuaggagcccugugauuuggagagugaaaacucuuuauuaccguuguuacuuuaacucuuuccagg\n", + "acucacaccucuccaggaaaagcagcagacaaaupauugaaaaauucaaacccucccucugguccupaggaaapcugucugag\n", + "agcgcpcugcggaggcggcggcgugugugguccuguuuuuggacagcuuucaacucugapaaaaaaacauuugucucaag\n", + "agguaaaccuccuuugcgguggacaaacuucgacccuuuggaauuccuggaagaguuaaagaaaauaaacuaucaaguggacagcupaggaa\n", + "gcpcugcggaggcggcggcgugugugguccuguuuuuggacagcuuucaacucugapaaaaaaacauuugucucaag\n", + "acucacaccucuccaggaaaagcagcagacaaaupauugaaaaauucaaacccucccucugguccupaggaaapcugucugagguccgcapuggag\n", + "ggcgccpacugcpugcucggccggagcgcuccagccgcugguccccpagacccugugccccuaaaucgcgguccacugcgcgcgucag\n", + "aagccagucaccuuugaggauguggcagugaauuucacccaggaagagupacugucuagaugccagccagapuccuuuaccaggauguu\n", + "gccpacugcpugcucggccggagcgcuccagccgcugguccccpagacccugugccccuaaaucgcgguccacugcgcgcgucag\n", + "uuucucacucccauupcgucgcguuucuagagaagccaaucagugucgccgcaguucccagguucuaaagucccacgcaccccgcpacucauauuuuucccagacgcggagguupuc\n", + "guuggacgugauaaguaugagccugcagcuguuucagaacaaggugauaaaaapcaaaaapcaaaaaagacapac\n", + "gucaauccagagccucagcaagcagcagcuggaaacpaagapagcagacaggaagcpaggucagcuguacacccag\n", + "agucaauccagagccucagcaagcagcagcuggaaacpaagapagcagacaggaagcpaggucagcuguacacccag\n", + "auccccgccccggcpuccaagccggugccpcgcccapuugccgcgcupcpapcagcgccugagapcggupuggcpuuccugcgcgcggcccgcc\n", + "gccugucgugguuuagcugaacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "agcugaacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "pugauugguugguugcuguuccugcccccacgccugucgugguuuagcugaacugagcugaaauccuaaaggccgcggagucggcgguguuguagguagcgguaccuugaguggcaacag\n", + "ggcagagcggcuccgcgagcuucucuccacuuucccauagagaaacccugacuggccgcugapcuagcuacacacacgcccucacgcccggcgagcccgcgag\n", + "gucacuaucauaugacaaaggcuuugccgcaguucaucuuccucccuguguacuuuccauuugccuuccugg\n", + "uuaaagauuggugccuggccagaaaugccugugaaacagcugugguuuaagcuucaacuguaaaagacagacgg\n", + "aauccugcugcaucacagaagcuggaaguucugauguuccacugaaaucacaauggaaagucuugacuugacug\n", + "gcauaupccacugaaaacuucugagcaauggauauaaaugagauggaacagaaggaaaaaaagguagacauuggaaagacugguuuapcuuuacuauuauccuag\n", + "agaccgccgccaguucgagcaggcacpcacpacaccccacucguugcuccuccguuauggaaagguguuuagcagacuuuuacgcccggagugug\n", + "agaaacccugacuggccgcugapcuagcuacacacacgcccucacgcccggcgagcccgcgag\n", + "aguucgagcaggcacpcacpacaccccacucguugcuccuccguuauggaaagguguuuagcagacuuuuacgcccggagu\n", + "aauaaguuuaagguggagagagcgaggcugapuggugguggapaggaggaaggccuuggccguuuaaagucuuauuucugaag\n", + "gcacccucaggaagaccccaagccucuagcaguaccugguaucaucuccagcauguuauagauguggaggauucacupauauugagaaauaccagaggcgaauuguuccacugua\n", + "ggagauagugupcccuugaggucuucaugucuauccucuacuuccauccuuucucccpaccuccacuccaaacucuccccccuggacccccaggugacc\n", + "aauguguguucagcccuuggcuguuccugaggccuggccuggcuccccgcugaccccuucccagaccup\n", + "agacpacuagccpcgcgcggcugagugcugcagaaucgcupuggcagagccgccagcgaggcup\n", + "gcugapuuuacugaguauggauugagcaucacacuaaaaaccuuccccggaaaaapaccaaaggauguaaacugaaaauuuuaaaaaucugcuuuguuuuccucaaauugcugaagauccag\n", + "aagcupaggagaaggcggcggaagguggagauugaugcuucuguuuuuuguugccgcugcugcccucgcgcupagccgagccggapaaggcgguggagag\n", + "acgcacaacuucauucucuaccccacuugcguuaagaagcagugaauaagcgguagguugacagagcuaccgucuuccuguuuuuuuccuccaauuuuccggcaguuacucccaguc\n", + "acuugcguuaagaagcagugaauaagcgguagguugacagagcuaccgucuuccuguuuuuuuccuccaauuuuccggcaguuacucccaguc\n", + "agaggaagcpagaggagcccacgucgccugucacccaauaucuccagccgcgcagucccgaagaguguaag\n", + "ccucuuuuccuccgcagagaggaagcpagaggagcccacgucgccugucacccaauaucuccagccgcgcagucccgaagaguguaag\n", + "apcpaggcppaggcpagcccggccgccagcgcucpuccgccucugacugcagcgcggcpcgaugugugauuacc\n", + "aucaupaccpugagcgcugagaaucgcggccgcagccaucagcccuggagaugaccaggagcggccacugcugagaacuauguggagagaggcugcg\n", + "auucuaaggaagccgagugccagagguggucagaggcugauauguagaauccgaaaaauacaggcugagccauggcaggaggag\n", + "gacugugaccgugaccgagagcgucgcupcacggccaggcggcgcggcpagugcacaggacgcgcc\n", + "guagaucuguccccaggucuguggaacugucaguugugaaguuuuguaaaauggucacccaacuuaaaacuaggaaauuacgaagaagagaaaauugcccuguaucuguuaag\n", + "gaacuucgaaagacuggaacacuuccgccugucaggccagaagagauuuccugacaccacagcuggaaacccaugugcauuucaguucaggaaagaaug\n", + "gagcccgcgcgucggcgccggcgccaapcggccucuagccacaccgaguccgccgcggcguccapucggcagcaaccgcagccgagcccgagcpuggcggcgcc\n", + "cucuagccacaccgaguccgccgcggcguccapucggcagcaaccgcagccgagcccgagcpuggcggcgcc\n", + "acaccgaguccgccgcggcguccapucggcagcaaccgcagccgagcccgagcpuggcggcgcc\n", + "gagauggcuaggacugauccuuuuagauccuaagaagcccccpaggagcagaacuuugapcgaapccuugug\n", + "gucagaugcagagagcguggaggcgcagagcaggcucugcggcagccggcpcaggacgccgagcccugaggagugucagccggucauccaccuggucccccggcucuucugacacag\n", + "cgcugccacugguuagcgauaauacuggcagcgcgaccgguuucugapuuguucaccuugcugcucagacgcuccgagaagcuucaggcagcauaacacuuacag\n", + "aggauuuccgcgguuguguaacggccugucgcaggcgugcapaccuggacuccgccucguccccpcucpcagccgagcc\n", + "cugcugccgucguggaagcaggauuuccgcgguuguguaacggccugucgcaggcgugcapaccuggacuccgccucguccccpcucpcagccgagcc\n", + "auacagcgugguacccacccagcaauacaugauaucuuggcucugagagaguguuucucuaaccauccucupc\n", + "uuucacauuucugaucacuaccgucaacaccacuuuuccuuccugccacguuacuucaccgagcgaguaccggcaaaccgugaaaacuggauugug\n", + "gcgguuaaagaagapcaagauccugaugaaauuggcaucgaguuagaagccaccagcaagaagucagccaagagauguguuaaag\n", + "agugguagcgcpacuggcupaagcggucggucgaguguggccuguguggacucgcaucuugcccgaagccpcggaggagagcucaagcuaag\n", + "aacuagauagaccauuaguguauccagaguugacauuaccuguguuaaggcucuucgaucaagaacauaacuaggaaucauucgaggugauucaag\n", + "guggcucggagagaccuuggcuucucupacucuaccccupacuucccacaucugcuccugagcuupcappcaaccgccugaggaaccucuccagcg\n", + "caaggccuagauaggaccggcpcuuugcuagaguggauupcgacauggapcacacgucuacuuupccacacupauuuucuggccuaugguggagcagauuguacu\n", + "ggcggccguuggcuggcpugcggcgcagccucggugucucupccggcggugcapcaacguuucauggugccpcggcacc\n", + "gauuacagacaugagccaccucgcccagccuuuucauggcugagugauauuccauuguguggauggaucacacuag\n", + "cggcagcuugaugacuauaaupcccaguugucugcpcugcpagcuaaguccccagauuggaggaggcuggcucuggucuucgaugcacaggaguggccguuauggaacgcag\n", + "gcaaupacagcugcugccagcgagapaccapcaccacucucuapagcccacacugcaagucaggccacaaggaccucugacccugapccg\n", + "auggacupugcaaupacagcugcugccagcgagapaccapcaccacucucuapagcccacacugcaagucaggccacaaggaccucugacccugapccg\n", + "uggccuuacugcgagaagcgcugcaguuacugcaacuucaacaaguacaucccucgccgccuggaggaggcugcc\n", + "cagccucuagaagaccagcauucucgugauuauggaggccccucugucuuuucugugacpagcaaugcugaccucgguuuccuggacccauuccgacucag\n", + "ccpagacggcgcgacccggcggcpccacccgcgaguccagcgucgccgcagccccccaaugcggccgcgagaagcagcppcaggcgaucgaag\n", + "gcgaucugcugcagcucggccpagacggcgcgacccggcggcpccacccgcgaguccagcgucgccgcagccccccaaugcggccgcgagaagcagcppcaggcgaucgaag\n", + "ggcauuccccuucugcacgauggcaaaaucupcaaaguugaaaguugcaagauuccagucaaacaauuguccuugcuupuaaauauccucaaaugaaaaaaaau\n", + "agcucggccpagacggcgcgacccggcggcpccacccgcgaguccagcgucgccgcagccccccaaugcggccgcgagaagcagcppcaggcgaucgaag\n", + "apcagaguagcgaucgucgccaaagcgcgcgguuuuauuucucuccgcuuuggacpcaaacuagcuuuupagugaagcpuacgcaguuauccaaca\n", + "ggcagaguagcgaucgucgccaaagcgcgcgguuuuauuucucuccgcuuuggacpcaaacuagcuuuupagugaagcpuacgcaguuauccaaca\n", + "agaaccupcugcgguggaccugauccugaggucucagcguagagaugcugaguccagaggccuguucuaguucaccagugcagugapcucaguauccpccucccgagag\n", + "cccagugacagcuggaguggacaaagugaccaapccucaaggacacacaaggccaagaagauuugaagugcugu\n", + "gaucucuuccccuuguccauagccuagaucgagcucccugugugcaccgcgcgcugcccgaggcgc\n", + "aucuaagaucucuuccccuuguccauagccuagaucgagcucccugugugcaccgcgcgcugcccgaggcgc\n", + "auucuccucugcgcggccuccaucuaagaucucuuccccuuguccauagccuagaucgagcucccugugugcaccgcgcgcugcccgaggcgc\n", + "ucagcgcupcacagccapcagcgcgagapaggcaacgagapuucccpccpcagcagcccagccccggcccggappcccgacg\n", + "ucccccaaaucugcuuucaucagugcugcgaagaaggccaaguugagguccaauccugugaagguucgauuuucugagcagguggcaguuggagaaacagaugca\n", + "gucgcacagcucugcuccuaacuccugcccgccccguccguccaucugucccgcugccccgcggcccauccaapccacuccaccucggacccaag\n", + "gaugguuuugaacuucugaucucaagugauccuccugccucagccucccaaagugcupauacag\n", + "gaguccuggcccggcccgucgcacagcucugcuccuaacuccugcccgccccguccguccaucugucccgcugccccgcggcccauccaapccacuccaccucggacccaag\n", + "gcuccuaacuccugcccgccccguccguccaucugucccgcugccccgcggcccauccaapccacuccaccucggacccaag\n", + "agaapagugaagauaagaauaugcauapaaaauggagagapagcgugacauugaguuggaggag\n", + "auauuugcuuacaaguagaggagcugauuuuuguacagacaaguacauuucaccagugcugccagcacguucucuuggucuggaag\n", + "cugcaaguuuagcacuggccuguccugauuagugaggaccucugauugccuaggccapcucag\n", + "gagaaugcaguugaaacuaauuuuguggauagagaaacuguuggaacugcuuuacaaaguauuuua\n", + "acccapcuggagagucugcgugcauauuugcuuacaaguagaggagcugauuuuuguacagacaaguacauuucaccagugcugccagcacguucucuuggucuggaag\n", + "gcuuuucuucaccgcucuaaggaacuaccacagucagaaggugcauucuuacugcgaucuuuuuauuugcuaccuupcuuaaggagccugccuauaucuacugag\n", + "auucgupagguguguuuguggaguaaggcagupapuagaggaaaaggagauaaagaaaaagcccauuucuaacucucugaacaggcgaggccagcuuaucugagaugccugugaucag\n", + "cucuuucaagaucaaaugaagacagaauuguucaaagcgupuugaccuccccuacucaguuuuuggcuccuuuuggaaaucugaugucugcccuucuaagcguaag\n", + "guuucucuuugaacuugaacuguggcucuuuugauauccagaaagagaguucuuugupaugguuaauucuuguuuupugcuuuucuucaccgcucuaaggaacuaccacagucagaag\n", + "acuuguggcugagcagagguguauguagugcauuuaggauuuugccgaggagcacguuuuuccaupacaguguguugauaucaggcuggcugugaupuucccugagucacccucugcgag\n", + "pucguucugcuuccugcccgapcgugcgcpucapcggccgcggaggcggaagcaucc\n", + "ucpaauapcggagccuggcuuaggaapagcugagguccpcccaguuuuccggaguugcg\n", + "gagaacgccapagcugugagagugugcagucgcguuccugcuguccggacacuuuuuuccucuacugagacucaucugguagauccgcaggccaguccucccapcugaagu\n", + "gaccugacaaugucccuguauuguggaauagcuugcaggagaaaauuuuuuuggugcuauaggcugcugucaaccuauguuacuaagacacg\n", + "auugaaugapucacugaagauacaguguuuacucuuugucugcugugaaaaagucuguucccaucucuag\n", + "gcucaagcucuucuccgcuggcaugaugcucaucaguucugcagcagaagupcagcccaccaagaagaacguggcuggcagcaagcgugugugcccuuccaauaauauaaucuauuauccacag\n", + "agaagcagcaauggucccuccapaacggaagccguugaacgugaacauuuggaguuuccucuuuugugcugauuccugaggacuaggaaggugccccgaaaagaauucaga\n", + "gcagcaauggucccuccapaacggaagccguugaacgugaacauuuggaguuuccucuuuugugcugauuccugaggacuaggaaggugccccgaaaagaauucaga\n", + "auucaaaggaaaaaacaugaaaauuaaaaucaaguuacaauuuuguauuggcauaaaacauaucagcaaauaag\n", + "ggaguagguggaauauccupagaggaaguuuggucguupcagcggccgacuuuccucucag\n", + "pcuucugcuggauaaaccaaccaccacaaagucuacagaaacaugucuccaccccagccucacuccacaaaugcuucuuugguggaaggcugguuccug\n", + "auggaguuucgcccugucacccaggcuggagugcaaupacgaucucagcucaccacaaccucugccuccupugcaagcaauucuccugccucagccucccaaguagcupacuacag\n", + "aguccpagcgcagcupccgcggcgcuccgaccuccgcuuucccaccgcccgcagcugaagcacaucccgcagcccggcgcggacuccgaucgccgcaguugcccucuggcgcc\n", + "gccgcacugupcgaggacccucapccuguuccagaaacaccpaagaagagcuggaagagagaaggaaguuguaccg\n", + "uucugcaggcaacapaggcagcggcuuuuaugcucaaaaggaaugagucccaguggcuggcacagagaag\n", + "gaugucacagagaupugaaauggauaugguagaaaaauucugaauuacuuuuugaaaucauugaacaagguggagaagguccagaagcauacc\n", + "auugaacaagguggagaagguccagaagcauaccaugaacuacagaagaaggaaagauggaguaaucug\n", + "ccccgcccagccccaggucuccccgccucacucpcccguggccpucacuccccgccgccccuccccgcacgg\n", + "acagucgcagccccggcgccccgaagcpaaaaaggcupugccgccgucccccagcugcgcaacccuaggaacucucgg\n", + "ggaaaccgcauuggaapcagcggccuugguguuagaagauuccagucuguguccuggugcugccccggcccugg\n", + "ggcggcaccuuccuacuucugcccagccacagcccuccccucacaguugagcaccuguuugccugaaguuaauuuccagaagcag\n", + "cggccugaggcggcupccgcgcagguagugucccugcacuucuugcccpcgcgugaggccagcuccgcugcgcuugucuccagcuuccagcccuccuccccuaagccgccgccauc\n", + "agcggacpucugcgccgccgcaggaggagcaggcgguaccuggacpuucgucccpcuguuucgcguccggccugaggcggcupccgcgcag\n", + "guagcagaupcaaaugcaauugugcupacauupagacauuucuuccccucuugcgauuauugguggcaauugugcucugcaagguuucaaucaugaaggaagugaucucuuuuggacggu\n", + "guagcagaupcaaaugcaauugugcupacauupagacauuucuuccccucuugcgauuauugguggcaauugugcucugcaagguuucaaucaugaaggaagugaucucuuuuggacg\n", + "gcggacpucugcgccgccgcaggaggagcaggcgguaccuggacpuucgucccpcuguuucgcguccggccugaggcggcupccgcgcag\n", + "gcaaaaagagcggacpucugcgccgccgcaggaggagcaggcgguaccuggacpuucgucccpcuguuucgcguccggccugaggcggcupccgcgcag\n", + "gagacggucuugcucugccacccaggcuggagugcagugguacaaucauggcucacugcauccuugacgucccuggcucaagcgauccucccaccucagccuccuaaguagcuggaaccacag\n", + "gaggcggcupccgcgcagguagugucccugcacuucuugcccpcgcgugaggccagcuccgcugcgcuugucuccagcuuccagcccuccuccccuaagccgccgccauc\n", + "pucugcgccgccgcaggaggagcaggcgguaccuggacpuucgucccpcuguuucgcguccggccugaggcggcupccgcgcag\n", + "acuucuugcccpcgcgugaggccagcuccgcugcgcuugucuccagcuuccagcccuccuccccuaagccgccgccauc\n", + "cuuggaggcugagaugugguucugcgcgugugcggacggcugucuguuaacuccgcggucaguucccggacugguggcuggucugcapuugaccugcgca\n", + "gaugugguucugcgcgugugcggacggcugucuguuaacuccgcggucaguucccggacugguggcuggucugcapuugaccugcgca\n", + "gagaugugguucugcgcgugugcggacggcugucuguuaacuccgcggucaguucccggacugguggcuggucugcapuugaccugcgca\n", + "gaugaggaupacagaagaggauaacagucguguugaaccuguuggacaugcugacacpuuuggagcauauacccaacuuuucucugga\n", + "gcuuugaugacaguapaaagaaccauuuccuaccauuuacguagauucacaaaaagaaaaugagagguggaauguuauuucuaaaucacaguugaagaacauuaaaaag\n", + "ggugcacguuggagucauaagacggcgucgguguugcagucuguguccuuggaggugaccapccacugcaggc\n", + "agaucuacgcucucugaugcaacgccggaaucgcggaaaccgccggugcacguuggagucauaagacggcgucgguguugcagucuguguccuuggaggugaccapccacugcaggc\n", + "ucugaugcaacgccggaaucgcggaaaccgccggugcacguuggagucauaagacggcgucgguguugcagucuguguccuuggag\n", + "aaaccgccggugcacguuggagucauaagacggcgucgguguugcagucuguguccuuggaggugaccapccacugcaggc\n", + "guuggagucauaagacggcgucgguguugcagucuguguccuuggaggugaccapccacugcaggc\n", + "guggcuguaucguuuuaacugcauagapcaggucucuuuuggaauuaggauuaaagaaagugcaguaaagagaaagcaucgaagacaccaucacaaaag\n", + "auugcccucuggagcuguuaucaagaugcagaugugccpcuuuuaaacucuugaaaaacgaaaagaacaagaucccuuguauuuccaccuucugaaaa\n", + "gcucgccccggccuugugcucgcguccgcaccccuuuccugucgccccccpcccgcaccacagcccggccggcgagaccccggccagaccccgcugcccgcacaaa\n", + "agcugcucuaagcugupccaacaggaggcupagcucuccucuaaauugcuuugugaccuuggacaagaacccuccccuuccuggacugcaaauuuccuccucuguaaaaugaapuug\n", + "ggaacuuaggugcugucuuggccaaguucagaaacauguaggacauuauggagaaguguuaaagccag\n", + "gccuguuucuuugacagcccagacuuagagcaaugugucccuccuuugagcuccugaapccagcugaagacucugucauuugguugguggaggccaag\n", + "acagagcugcucuaagcugupccaacaggaggcupagcucuccucuaaauugcuuugugaccuuggacaagaacccuccccuuccuggacugcaaauuuccuccucuguaaaaugaapuug\n", + "aggaggacgccaggacugcgucccggagccaagugcpaggcgcgcapccggcggcgcgcggag\n", + "gcauggcauaggugacaugaaagcuucugucuccagacccuugucuucaagaggagugcuggccugucaaugagcgugccugauuaccgug\n", + "guguguguguguauguguacacacacagaacaugaagaacuacauccagaagcugcccagaaaggaugcag\n", + "gccuccgauguacuaccaaggapcgapuuccuaugucugucuggagcgcagapuggacugcaaaaag\n", + "aagagguggccuucuccagaaagauuuuaaagupcucuauuuguguguucguaaacauccucugauggcuucuaggaacuggacacugag\n", + "uccuaccugcaauugcuguguguguguguauguguacacacacagaacaugaagaacuacauccagaagcugcccagaaaggaugcag\n", + "aacguccaguugcggauaaugagcgaauguuugauguucuucaacgauuuggaagucagaggaacgaaguucgcuucuuccuucgucaugaacgccccccuggcapacauug\n", + "ugaguggaccaagaucucaggauccaaguuuaaaaagaaaugguguaaaaguuccuggugaauaucgaagaaaggagaacggu\n", + "augaaucgcuaccggagccgcugacgguucggacgugcaguucucccugcuuauccuguapcguccaaccugguggacuc\n", + "gcauuuaaaagacagcgugagacucgcgcccuccggcacggaaaaggccaggcgacaggugucgcuugaaaagacupcuuguccuugcuggugcaugcgucgucggccucupcagcag\n", + "aggccaggcgacaggugucgcuugaaaagacupcuuguccuugcuggugcaugcgucgucggccucupcagcag\n", + "ggcacggaaaaggccaggcgacaggugucgcuugaaaagacupcuuguccuugcuggugcaugcgucgucggccucupcagcag\n", + "guaacagugaugaugucaaaugcuuuugcugugaugguggacucagguguupaaucuggagaugauccaupuucaacaugccaagugguuuccaag\n", + "gugugaguacuugauaagaauuaaaggacaggaguucauccgucaaguucaagccaguuacccucaucuacuugaacag\n", + "auaagcuccagccuuccuguggccacagcaggaccagaguggaccagcacaccccaggagagaggacupucccaggaguaggaggag\n", + "gucapagaggacagacppacggcugaapcauggccucuucccugccacagcccgagcacc\n", + "gaaggupagucaaucauuuugacaagucuccugaaaggaacagcuagcaggaacugaaaccuuuuuccauuuggucucguggcaaaggcagagauugcuccagcagcuccacaca\n", + "guccauuaccaaagccuggaaguucucaucaccuccagguggacugcuuggcagugcuaggagguggacucaggacuucagaagcaacauuucuggccugaccuggaaggugaaggugaag\n", + "auucacapagccggcuaaaacagacuacucccccgugcagucguucccucuacccuaauaaggcuuuggcgccucucccagaacucg\n", + "guccupaaugcucuuugccugguccagccccgacaaacguggucugagaacagcggagcgcggaaaccgcggagc\n", + "gcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "ggaaaacguugucgcucauccuaugacgcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "guugucgcucauccuaugacgcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "auccuaugacgcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "gccgagagaagcaguagucaauaaagagagugccguauuucgcagauuggagcugagcuguggcugccagaagauagcgaac\n", + "paccggaaaacguugucgcucauccuaugacgcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "uaugacgcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "gagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "gaaaacguugucgcucauccuaugacgcgaaaguaaccgagacuaucaggauccggagacggaaauguccgaaggccgcaguacuugacccuguauuuupagucgaacgga\n", + "gagagaagcaguagucaauaaagagagugccguauuucgcagauuggagcugagcuguggcugccagaagauagcgaac\n", + "gcaacccgagccgcacccgccgcggacggagcccaugcgcpcgaaccgcgcgcccccgcccccgccccgccccggccucggccccggcccuggccccpcagucgcgccugugaacg\n", + "pcgcpccggcpcguaagcggcggcggcggcggcggcggcpupupccpcpcccgcpcacag\n", + "agagaguaccucacgaapacgupaaaguguuagcpaacgcupaaacucccggccuccgccaccaucuugcuuuccuuuaauccggcagugaccgugugucagaacaaucuugaauc\n", + "acagccacccgcpaagcucguggccpaccccgaggcpagcgcpcupccpcupcuacgcgcacpcucggccgccgccccugccg\n", + "ggucucuugccugcuguguacugcuuuuacugccagaaauguucuccucaccupagccaguuggcugccaacacuga\n", + "ggcaucgucuguaaagaaugagcccuuauuagacacugaaucugccagcaccuugaucuuggacuuccuagcuucuagaacu\n", + "aaaaaaggaaaaaagaapccaugcacaguguagguuccuauccugcuuucaagaacagaacagaauucacgugupagcaaacggcucaccagguggugguca\n", + "gcggaggcuuuuauaugccagagaacccugagugugccccugacaugacaaggagccgucgucguuag\n", + "auuuuuauacgucuggacuuaacuuccaggauagcugcaagacccuuuuguuccuuugccaugagcagguuuuaggccgcucuguupacc\n", + "gaccccuccuuccacccgccgagaggaugcgcuccccggcgcccagcagcagaggccaccgcucccagaaaugcaugcgaccgauccccuucucccggaccccaggagccggcgcccccgcccuguag\n", + "auucccacucugucgcccaggcuggagugcagugauguaaucucggcucacugcaaccuccacuucccagguucaagugauucuccugccucagccuccagaguagcupauuacag\n", + "uugcaggauggcuacucguaucccuccacacaugaucaucaguauuugccuccugugucccaaccggccugagucaa\n", + "gagaggaugcgcuccccggcgcccagcagcagaggccaccgcucccagaaaugcaugcgaccgauccccuucucccggaccccaggagccggcgcccccgcccuguag\n", + "gaugcgcuccccggcgcccagcagcagaggccaccgcucccagaaaugcaugcgaccgauccccuucucccggaccccaggagccggcgcccccgcccuguag\n", + "gguuacgacucacugauuaaaaagapacuuuuucaaauacuuugcacuuuugauuguguauuauggauaccaaggaagagaagaaggaacggaaacaaaguuauuuugcucg\n", + "cugcgcucggagacuuucagugaaagcagaggagagauuuccaaagguuguauuuuccuucugguuggagccucucauccacauugug\n", + "aauuuugcaacgacpcgcggaggaggagguucccggaagccacgcgcagcuggagcagcggcgaccgcagcuggag\n", + "aaaugugauugauaacaguaaagccacacuccucaagugccugaaauaccccucauugucuucuucagguggcaapcucuggaacagccacauaaag\n", + "auugauaacaguaaagccacacuccucaagugccugaaauaccccucauugucuucuucagguggcaapcucuggaacagccacauaaag\n", + "gaaugucuggacacaguagacaaagguuuuucaacaggaugccuuaggauacaugcuuccaaaaacaaaguagccaaaaagaaaccagagucacagaauaucagagccagaggaacauuuggag\n", + "agagcuguucucuggccaagccugcgccuguaguccuucuuugccuccupcggccgccacccacccccag\n", + "ggccagacaugguggcucaugccuguaaucucagcacuuupagacugagaugagaagaucacuugaggccaggaguucgagaccagacuggcaacauagugagacccugucucuacaaaau\n", + "gcuggccaaggagcapccugcgcccguggucucauagagccuggccuguucuggaagagcacccaguuguuccuucuaggcugcccaagccccacug\n", + "cauagagccuggccuguucuggaagagcacccaguuguuccuucuaggcugcccaagccccacug\n", + "aguuucccgcggacccugagaggagcggccgccgcgagugacugcaccgagcccgagaagucgccgcgccccgcagccgccccgacugguuccccgccuugcccgupccccgccp\n", + "guugacuuccgagcuuggauucaagucccugaapcaccagacaccugugaucaccaaggagaggagaggagacaggacc\n", + "auaaaaaucuggauaaugccgcagaagcagcugaacaauuuaaauuaauccaagcagcauaugauguguugagugacccucaggaaagagcaug\n", + "guaugauaaucauagagaggcccuacuuaaaggupuuugauggcgaauaucaagaugacagcuuagauuugcuacgcuauuucaccguuaccuguuauucugguuauggagaugaugaaaag\n", + "gaggcgcupugcggcgcgacgccagcgaggaggagcucaagaaggccuaucggaagcuggcccugaaauggcacccgg\n", + "uuguucagauucccaggcugacaaaaaggagaaacagcuuuuacuugcauccapccaaucaucgcagacccagacgucugcagagg\n", + "ggaaaauaaaagaagcaaaaacaggcccugcugugapaccacgaggcagugccaggaugaaagaguuggaguaaccuaggugauucugagugaaucagucaggaggccuuccuggap\n", + "gcugaggccccagcuuguggccaccacaacguaucaagcuaucuccapuupcucaggacucagagcugacgcagcupugccccuugguucuggagg\n", + "aucpccaccccaugugcucugguacggcaacucuugcagagagguuuccuccugcccugccacguugcgccugagcagaapacagcaaggagaagccucgcugguggag\n", + "aguaaaaugaapcupccaggcuggucccuccugccuucgcucucugcuggucgcgguggccuguagcuccucccucg\n", + "guugcuaaggccccaaaagauugcagcacacgaggcagcgccggagaggaccacugagcagcacpcccuggcp\n", + "uaaaaugaapcupccaggcuggucccuccugccuucgcucucugcuggucgcgguggccuguagcuccucccucg\n", + "aacaggcccugcugugapaccacgaggcagugccaggaugaaagaguuggaguaaccuaggugauucugagugaaucagucaggaggccuuccuggap\n", + "ggaaaauaaaagaagcaaaaacaggcccugcugugapaccacgaggcagugccaggaugaaagaguuggaguaaccuaggugauucuga\n", + "cccuccugccuucgcucucugcuggucgcgguggccuguagcuccucccucgguaggaccccccuccaccuuggcgcuuacgagaugaaugaggagcccagaccucuggaacuuggap\n", + "apcugaguuuuggagaaacugcagagacaguacucuaaaguuagaaucuccugaucuuucacgag\n", + "gcaggcguuuccucggcgupcggaagcacgaucuccggcagcggccupaacucuuagcugagcaggcgagag\n", + "ccguucuuugccaaguucccuccgaaguccucugagcuccugcauuguagcpaagcggcagugag\n", + "gcuuucagccguucuuugccaaguucccuccgaaguccucugagcuccugcauuguagcpaagcggcagugag\n", + "aaucacagacuacccuucccugguccuggagguucaaagaauugcaggapuagaaaagcaccupucpugcagacugcggagcpcccuaccgugugcgcagaaagaggaggcgcu\n", + "ggacuuauccuaccuuaaguugaagcagaccagcaauuguugugaccuacaaucuccacacccaucuuuacucugagccaaggaagugucuguucuugugcugaguuucagg\n", + "agccuccaggaagccuucccgacugcccugcggcaccaagccuccguccucugguugccccgapaccucagcgcccccgccacg\n", + "paucaggacacacupaaccuggugucuguuuggcpucuauuugucaaguccuagaaccpugguccagacaccucacugaucuaagaac\n", + "acagugaacucugauuccuggaauuguuaccaggcgaccacggcgucaucaaaugaccuggcaauuccgucuacugaugucucgaac\n", + "gacagaaaaaaaaaucucucuuugucuugapcuguugaguggucgcggaccupcucugugcguupaaapaaguggag\n", + "acagucucapaugagcagccgcccaagcugcapccucpucuucggcgccucugacccucgcagguugcugccuuucggugcagaacc\n", + "apaagucccggcgcccggcgaaaccacccucccgugcagccgagcccagccgcucuccggccgccguccccggcggcccc\n", + "acuucuucucuccugccgccauuugaaggacgugucugcuuccacuccugccgugauugucagcuuccugaggucuccucagccaugcugaacu\n", + "uuaggauauuggaauugaccuaaacugaaacuuuucacugcaggugacuagcaugcagauacccaugcucugacuuucugccccuccacugac\n", + "acucggugcccgcagcgccpcguggaggcguuaacgcgcacgcgcuuapauccggccguggccgagcgcgcggccguaagaccgcgg\n", + "uuuuacucggugcccgcagcgccpcguggaggcguuaacgcgcacgcgcuuapauccggccguggccgagcgcgcggccguaagaccgcgg\n", + "guaaacuugccucggucccggupcagccgcggcggupuuggcapugugcupccuggaggaggcgccgcgcggccapagccagcpaggccgcgccuggcag\n", + "acucugcuaacaccagauaguggaaagaaaccaugugcugaaauguuugacgacacugaugguuug\n", + "acucugcuaacuggaauggcuuauugugcaagaaaguacaccuggucpuccupcucaucucuagcaccag\n", + "ccccgccacccccuccccggcccggccgccucccgccgcugccgccgccgccgccgccgccauuccuggcgcccgaacucgcccggccpagccgccgcpcaggacgcgcgcugcag\n", + "guguucaupccucauuaagcucugccuuccuucugcuuuuuggagccuggccuuugguuggccuugaaugaagagupccccaaaaguaccacugucagcacucuccag\n", + "caucaucuggcugucuggcaccaucaaagaauugcauuucugacccaagaagagcuuaupuggaupup\n", + "gacauuuuuggcgccggccccagccugagcpacggcggccpapcgcggcccpuucccguuccccgcggagcc\n", + "auuuuuggcgccggccccagccugagcpacggcggccpapcgcggcccpuucccguuccccgcggagcc\n", + "guucucauucuguugcccacgccggaguguaguggcacaauuuuggcucacugcagucucuugccucccagguucaagugauucuccugccucagccucccaaguagcupuuuacag\n", + "gugcgcgccugcgcauaggucpucugcggugucaccgcuuucgcuucugcuugagucaguccucacg\n", + "gcuugagucaguccucacggugacgcuuuuccccagcuuuuccgaguaggaucgugcccapaggaggcaga\n", + "auauaauuggugauuacaacuuuccucuauaaauuaacucuugacacuccuupauuugaagaaaaaa\n", + "agcpugaagcaccugauugccuaaaccacucguuuccuuccuccagcacucaaagauuaaccuuagcuccuuccaapuucgupaaaauucgccucgapacupuac\n", + "agaugcpcacaggapagcuucccacacuguucaggucaccagagccugcgcuucugugguugguuuugaugaggacucguauuucagcuccugucucuccuugucagaggccgugugag\n", + "gcucccguguccucaguaugcaucaggucucccgaaccucacagccccgcapaggaggagaapaggauuugacuuuggaagucucugugaccag\n", + "gaguguccaucaggacagcuucaccuccuugaggauuaaagccuaacaguacugagcuauuugucugucaaa\n", + "ggcuccggugucauggccggcuccuacccugaaggugcaccugcaauccucgccgauaagaggcagcaguucggaagccgguuccugagcgauccggcgcgcgucuuccaccaca\n", + "cugucgccugguupcccggaaaupacgucgcgcuuucucapagcguagaagcagccapccucuccaagccgcugcugugacagaaagugagugagcugccggagg\n", + "auuaugcugccpccggcgagccaaagaggagccggccgcgcpccpapacggccgccggagccgcgaggccaa\n", + "acagcuccacucgcgccggacacapagcagcgagcacgcguuucccgcaacccgauaccaucggacaggauuucuccgccucagcccaacpag\n", + "ggaaggauuacacuguuccagguuuuapagaaagguuuaccaaaccgguggccuuaaaugauuuucgcuccuugauauuaucaucuugaaggaaagcug\n", + "aagaauaaaugagauaauucacagaapaccuggagcuuuuccggaaaaaggugcugugacuaucuaag\n", + "cguuauacccuaaccaucuuggaugcupcuuuguuaugcuguaauucauaaggcucuguuuuaucag\n", + "aguuacupcagcuacugguuuccuguuccucccaucugacucapugaucagucacauucuu\n", + "gacaagacauuucaaagaaaguauuaaauucauucacgagugccggcuccgcggugagagcugccuuguacacug\n", + "ccgcuccuccucccuguaacaugccauagugcgccugcgaccacacggccpcgcuagcguucgccuucagccacc\n", + "augccagagacgcggaacaauugagcaagaacaaggugacacauauucugucuguccacgauagugccaggccuauguuggag\n", + "ccuggccpucuccaggagcgugacacuggugaucgcauacaucaugaccgucacugacuuuggcupagg\n", + "aggccgugaggucugaggucagagauccagccaucugcucccccapuapaggucpccuccccp\n", + "augccagagacgcggaacaauugagcaagaacaaggugacacauauucugucuguccacgauagugccaggccu\n", + "guaacaugccauagugcgccugcgaccacacggccpcgcuagcguucgccuucagccaccaupaaupaugaacaag\n", + "aacaugccauagugcgccugcgaccacacggccpcgcuagcguucgccuucagccaccaupaaupaugaacaag\n", + "ggaagcccuacccugagaauaacagaugccuccucauuacaucauaauggccaaguugugaugucggcacagagaauuuacucuucacuaaguguuguaagugaaacaagau\n", + "uppcagucccgguuucggccaucgcupupcucggagcggccgcaccpcagcaaccccacucccacucggaggcccccugcccucucccccacuuccccccggccc\n", + "gaaucauguggugccpaggaagugcggcuuguuuucuuuccuccagucucpcugcaggcugagcgcgaugcgcggagacccccgcpcggcggcggccgugagccccg\n", + "guuuucuuuccuccagucucpcugcaggcugagcgcgaugcgcggagacccccgcpcggcggcggccgugagccccg\n", + "guugccgcuggcuuccgguccccugagacupccucgcucgcucccgacccgguugcaaguguugcggupagaaagucgcguccgcaucggapaagcgccguc\n", + "gccgcuggcuuccgguccccugagacupccucgcucgcucccgacccgguugcaaguguugcggupagaaagucgcguccgcaucggapaagcgccguc\n", + "agucucacucuguccuucaggcugugagugcagucuccugaucuuggcucacugcaaccucugucuccupuucaagugauucuugugccucagccuaccaaguagcugagauacag\n", + "gauugacuucuaaagacucuugguaccugaggaagaaacccagaagaggaagaggaaagcaaaggagucp\n", + "cuguuuuaugugugcuucccaguccuguggugcugcuauaccpacguugaguccccacagaccuggaaauugcggccccucuuucucaacccagagcaaauugagacguccgg\n", + "gcuggapcaguugugcgaucuugauucacuucaaccucugcucuccpcucaagcaauucucccaccucagccug\n", + "gcuggagugcaauggcgcgaucuuggcucaccacaaccuccgccuccupuucaagugaucuccugccucagccuccccaguagccpauuacag\n", + "uagagacaagguuucaccauauuggccagacuguucucugaacucgaccucaagugauccacccaccucggccucccagaguccupauuacag\n", + "puguguugauucucagugauaaacaacauauuucuaacauuuaggauugacuucuaaagacucuugguaccugaggaagaaacccagaagaggaagaggaaagcaaaggagucp\n", + "gaggucgguuccgcccgacucuaacauggcggcgcccuuugucugcucuggagugccguccccggccuucucgcggccgugaugcaccucccucugcggupuccpacauggcag\n", + "guaaugagccggacgapagccaagcuggaguuuacacaggcaaacugucagaaaagaguagccupcugucuggaaaucugag\n", + "aacauggcggcgcccuuugucugcucuggagugccguccccggccuucucgcggccgugaugcaccucccucugcggupuccpacauggcag\n", + "gaacgaggcggcuguggcgguggcugaggcggcupccuapugcagcpcgcgucugcggcugguguuggcgcaucucuag\n", + "augucaccagcaccugccuagcugucaaggagugguuuguguauccupaacccacugaggcacccggaccucgucaggccgcugcag\n", + "acucgguugccgcgcguggacuuacaagcccacgaagccaucguucgucacagccuggaaaapapcaucgaucugguuu\n", + "pucugcupagccagccauugaaggugcuggagcagagagagauaugguauuggagcugaucccuaugaugaaagaucuggacccuuguguagauguuccgugaagcaggag\n", + "gaaaggacccpcpccgaacgcagcuuccccaaggugcaggcgcggugaaaccaucgagacggapccagagagucacggcg\n", + "cugauucugaaauuuuaguuauagaaaauggaacagcuuucccauuucagguggaaguuuuagaugaaucagacaacauaacagcacaaccaaaauugauuguucauuguaag\n", + "gcaggagucuacacccaggcgguggcuauacuuauuaaaguuggcpagcugagcgaucagucgguccupcuggcugugguguapcguugcaggcagcgcucaccuccucaggccggcaga\n", + "aggagucuacacccaggcgguggcuauacuuauuaaaguuggcpagcugagcgaucagucgguccupcuggcugugguguapcguugcaggcagcgcucaccuccucaggccggcaga\n", + "gagucuacacccaggcgguggcuauacuuauuaaaguuggcpagcugagcgaucagucgguccupcuggcugugguguapcguugcaggcagcgcucaccuccucaggccggcaga\n", + "auuugugaauacuucuugcuggaagucccucacccagagaccagugcucccaacggcagagcagcpag\n", + "aucuucucacucagauauggcaacaagcagccuucacuuugcaucaugugauacacaacaggcgcccagacagcgcggagcgucuacugucagcag\n", + "uucaucaucaaccaagguggaucucaagaguggccucgaagaaugugcuguggcauugaacuuauuucuaagcaacaaauuuacagacgccuuagaauugcuucgccccug\n", + "gcupcugagcccagagccgagagcaggagucggcucugaguucccugcuugguuuuupuggcagcagccagaggaggaau\n", + "cuuugcgcupcugagcccagagccgagagcaggagucggcucugaguucccugcuugguuuuupuggcagcagccagaggaggaau\n", + "ccuuugcgcupcugagcccagagccgagagcaggagucggcucugaguucccugcuugguuuuupuggcagcagccagaggaggaau\n", + "agcucccauupucggcgaaccuggugccaccccuuagacaaagucccagucucccagaggcuuuuaccagcuggccccauuccuucugcugcupuauaauaag\n", + "auupucggcgaaccuggugccaccccuuagacaaagucccagucucccagaggcuuuuaccagcuggccccauuccuucugcugcupuauaauaag\n", + "gugaagaaagcccuguguguccucguccaacauaaccuggugaguuaucaagugcacaaacguggugugguggaguaugaagcccagugcagccpuauugcga\n", + "cuugcuccugaaagguucaauaaucacucaacaacucaccucuucagagaacugaauguacacagaaguccucuucaucucagcuacugauucucucuaaccugcuuuaccuauucaacc\n", + "acucgcuuacgugagcagaaguaguucuggucgucgucuaccgucucgcuauagccguuugapaagaaggaggaaaauuacccgguaucguuagag\n", + "guccuucuaauccuagucuucguuugguccgguugcacucuuccuauagcccagapcgagapccuguggccupaaggaggacgagguucugccuggaucccagcag\n", + "aucuupccggaggccaguccaacccuuggagcaggaagaaacgcaaaguugucaagaaccaa\n", + "gucgagcugccucagagccggcccgcaguagcugcagacuccgcccgcgacgugugcgcgcuucucupccagagcgagccuguuuugugcucpuuaagagauuugucccagcuauacc\n", + "aggacpccuuucaagapacacuggucacaccgcccagugucagcagcagcugcuaguucug\n", + "cacauuuuauugauuuuuguuguuguuguuuggucacucaauuaauguaaacgguuaucuuuccuguuuaccagacucugacagugaaggaugaucaggucuucccc\n", + "auagcuauccauauaaaagagcccuuggaaugaggcugacucguccugcuuuaaaaagcuccaag\n", + "guggcauguggagccucccaccaccaccuagguccugagaugcgcugaagcccagccugucugccaucaucccccagc\n", + "gcacugcgcaggcggccggacuccgcucaguuuccggugcggcgaacaccaaaguccpaacuuaagcauuuucgguuucuapuuguuacgaagcugcaggagcgag\n", + "accaaagagaacccuguacaguaagaaauaugguguggaccucaucagauacacucaugcagcaaacacaguuguuuacagcucuaacaaaauagacg\n", + "auacuauucguuacuuguccuugcaugacaacaaauacaucagauacuuuccuggacauagcaaaag\n", + "gugccaaaggucagapaucaauauacaggcccuaccacggaaaggcpaaaagguucgaauagaaaacugcugcagaapaagccacugagag\n", + "ucagapaucaauauacaggcccuaccacggaaaggcpaaaagguucgaauagaaaacugcugcagaapaagccacugagag\n", + "agaggcgacccaaggcpcuggcpcuggcggcagucgcuacuugccuaguagccucagccgcugupcuccupag\n", + "auacggaauuuuugaacgauguaaagaguugguagaagcaggauaugaugucaggcaaccagauaaagaaaaugugucgcuucuucauupcugcuauuaacaacagacuggaucuuguaaa\n", + "guuuuauauuucaaaaggugcuguuguagaucaguupuggagauuuaaauucaacuccucuucacupccauccg\n", + "gauccucagaguugguuauaaaauauuuaapcgagaaaaggaucgcaggagccaggcccugag\n", + "guggugcpupccupcgagucacgupacggugcgcgcucagugcggcugcgccggccgguagcugcagcuggagcaguggcguuuggaggagacucg\n", + "gauauaccuucucagaagcugcacaggaggaaagcagugacaaagaaagaaguugucauucuuugcacg\n", + "ggauauaccuucucagaagcugcacaggaggaaagcagugacaaagaaagaaguugucauucuuugcacg\n", + "gauauaccuucucagaagcugcacaggaggaaagcagugacaaagaaagaaguugucauucuuugcacgguaaaaucaucaccuccagucaccaacuucuaauucaaauuag\n", + "cugacuaaguuucucuggcuucccugaggcugcagguguuaaucuppcccupcccugagccggcagcagaaau\n", + "cucuuuccucuccugacuaaguuucucuggcuucccugaggcugcagguguuaaucuppcccupcccugagccggcagcagaaau\n", + "acccgcucuccagccugcgccupuuggaggugcccagcgcgccgccucuuaacucpugacgcugcccguuucccag\n", + "guugaagaagccucagcggaggcgauacggccuccucgccaacacugaggaccccacggagauggccucgcuggacagcgacgaggagacgguguuugagucccggaaucugagaug\n", + "gcccggcpagcpuccggagcaggcucccggacccaaaacugaapcgucugaggcgucapagcucccucgccuggcucucggcggccugauggaguaagapuuggcugugaau\n", + "aucuuugagaguaagauuaaggcaucuuauugagaaguuugagauauccguggcuuuuagcaacuugagacugucauccuag\n", + "paucugcuagaaguuggucuuccgccaggacuagaguuuccucgcgguaacagccuccguggccuccg\n", + "gugacuaggaaggagcuaguggacuagagccapuaapaucugcuagaaguuggucuuccgccaggacuagaguuuccucgcgguaacagccuccguggccuccg\n", + "gagaaagaaacccauacacauacagcugcaucugaaaccucagaaacuaagcucaacccaauugauuaaaaggauguucuuuggauaag\n", + "cagauggacacaaaccauacuuugagaaccauguuccacagugccaauacaggaaguuucuagauaauggcagcucauuuuuuaaaaauggcacuacacuauacuguauucac\n", + "aagcccugcupupugacagccgcugaggcucugagugacccugcaggcugguggccagccggccgcccaucuuccacacc\n", + "cgcggccpccpagcpcgcggcccggcggccucagcauggaggacggcuucuccagcuacagcagccuguacgacac\n", + "aggcagaguuuugucauguugccuaggcugauaucaaacuccugcgcucaagcagucugccuaccucagccucccaaaguguucucuguguucucugguuggagcacaguaagugaapaaga\n", + "guauagacacguguggccguuuacgcuguaggauccucauucccacuggcuuugaacauuuupacuuaca\n", + "agaugcaaaaugugucucuggccagcaggaggaaggaagaggaagugagagcagcggcagccggcggugcagcagccggccgacccagagu\n", + "pcagagcapagcacuuauaccauacaaggcagagaagauacagaucaagauaugcccaaggcccuucuaguucagccucuccuuggaguag\n", + "gaccaugacuuccupcaaucuguccuuccucagacuguugagugccagacguuuauaugcaugucuggacagagagugagccuggcucauucagacccupcaccauucagagcagaacucagug\n", + "upupaaugagagapuggacacagaggaacaupccuggccaagaagccaggcaacucccaccugaauaaucccuccucuucuccuccaggca\n", + "ggaauugcpugccuacapccaacagapaaggcggugcauagcaacgappuuucagagaaguggagag\n", + "pcpacggacuuucaaagacuuggaguucccacpugupuucgagaccuuccucugccaguucccagcuccgcuacccugagcaaaugacuuacgcuccauuggauuuucc\n", + "agaagccgccgcugccccccucaacccpappucccacuggcupccucaggcucapucucapuaaugaugaggcpcacapcacapcuacacuucag\n", + "ggaccauguggagguucuupcccaaaaguuuuaccaggaupccupagaggccupugaggaggacauucgcapcacpaggcccgucccaggaagacaccccggccccag\n", + "cpugccuacapccaacagapaaggcggugcauagcaacgappuuucagagaaguggagag\n", + "gcaauguggcugaagguppccuacuucpaccgguggacagcupccagacuguugguuggccuugupcccupccupccccaccgcugg\n", + "cugagugaccgcucucgagaacgcaaggugccugccucccgcaucagccgcuuggccaacuuup\n", + "gacuggcugupcuupcuaggaguacuggccgagauggcuaagaaguccaugccaggaggucgucugcagucag\n", + "paugccaagguuccugacucagcacupaaucuuggcugaguguguucupaaaugucaggccuacaggaagcagapcucccagucgcaccauuccgcag\n", + "uggaggaaguauuuagupupaaugagagapuggacacagaggaacaupccuggccaagaagccaggcaacucccaccugaauaaucccuccucuucuccuccaggca\n", + "aaucuuggcugaguguguucupaaaugucaggccuacaggaagcagapcucccagucgcaccauuccgcag\n", + "gcuucucccaggccccaccuuccauccagugcccuggacccucggcupuagcgccaccagagcgaccaaacgucccgcgccuuccaggccgcacuccagagccaaaagagcucc\n", + "agugcccuggacccucggcupuagcgccaccagagcgaccaaacgucccgcgccuuccaggccgcacuccagagccaaaagagcucc\n", + "cccaccuuccauccagugcccuggacccucggcupuagcgccaccagagcgaccaaacgucccgcgccuuccaggccgcacuccagagccaaaagagcucc\n", + "acugaagacuuacucccuuugccuguguggauauaugucuuggagagaggcugugugcauuagcuacaaauaguaacauuuucaaaaucaac\n", + "gacucpccggcgcccaggcuccpcgcgcpagaucpcggcuucggccgcggagccaggcucauuguucggcag\n", + "paagcccaagcccguucucccggccaaagugaacuuuaaucpugguuggaugcggagacpcggcag\n", + "gaagaaacaccucuuacagucaucugcapauucuccaaggacaupaagauagauguaagcccuggaacccagacuccuaagcgaapaagcugcauucugcuauua\n", + "agacauagucuugcucuguuacccaugcuggaguacgguggcgagaucacgacucacuacaacuuugaauuccuggauucaagcaauccucccaucucagccuccugaguagcuaaggacuacag\n", + "gaggccagagccpaccaugugacggcgcuggcccucgccaccgccgucccccgacccuggccccaggcccggcacc\n", + "ggucggugcpaggapapagcuugcpcccgagapcgacggcggcggcgguggccugaggaggcccgagcggcggcgguggcggcgaaggccgaggcg\n", + "ucuagguguuuuuggaagagcugcagccuuugaagaaacaucucuugaugaugauaucauagacuccuuccuacupcagaugaggcagaaupcacag\n", + "agcucccugacccggacgcucucupccaauauggcagcgcccagcaacaagacagagcuggccuggaguccgcggcuggccgcgugaguag\n", + "agucucacucggucacccaggcuggagugcaguggcgcgaucucagcuuacuguaacauugccucccaggugcaagcaauucucccaccucagccuccugaguagcupauuacag\n", + "cucupccaauauggcagcgcccagcaacaagacagagcuggccuggaguccgcggcuggccgcgugaguag\n", + "uuuugcagaugaccucgcgagaggucacgccgcaagucggcaaccpcaggauuuggaauccgcgucugccuuuuucccccaagagacccagaauccuggcagccgguuucaaagcuguu\n", + "pccaauauggcagcgcccagcaacaagacagagcuggccuggaguccgcggcuggccgcgugaguag\n", + "uagagacapuuucuccauguuggucaggcuggucucgaacucccgaccucaggugaucagcuggccuggaccucccaacgugcupauuacacac\n", + "gauuugcuaccucccuggagcucccugacccggacgcucucupccaauauggcagcgcccagcaacaagacagagcuggccuggaguccgcggcuggccgcgugaguag\n", + "cupccaauauggcagcgcccagcaacaagacagagcuggccuggaguccgcggcuggccgcgugaguag\n", + "auggaguuuugcuguuguuccccaggcugagguguaauggcaucaucuuggcucacugcaaccucugccuccupuucaagcaauucuccuacgucagccuucccaguagcuggaauuacag\n", + "gcucucupccaauauggcagcgcccagcaacaagacagagcuggccuggaguccgcggcuggccgcgugaguag\n", + "ggcaaccpcaggauuuggaauccgcgucugccuuuuucccccaagagacccagaauccuggcagccgguuucaaagcuguu\n", + "agagcacagccgagccgagcggcccpcpccgaccccggccagcgucggcgcagagagcpcggaggcgcaggcc\n", + "agcugagcauaggcacagaaguuuagguguuuggaccaaggucacacaacugauacaacaguagcuucuucacag\n", + "ugguuuuuuuuuuggccaaacucucauggcuuuuuucuccuucccucauguuuucuccuucccucuuaagacuuggcacuucuccagaaggaggaggacaaa\n", + "acuucapaccucuguuucauggacauuaucauauucuucucaagaguacccagcaagagguuugcaaagaggaguuauucaguga\n", + "cugagcauaggcacagaaguuuagguguuuggaccaaggucacacaacugauacaacaguagcuucuucacag\n", + "aaacuuguuaauuuaauacaauuuacaacacaccugcuggcacuuugaucupaccucccuguugucugaacu\n", + "agugcggaagcggaagaggcugcapccpaagccucuguuugguccggccaggucccpauccpccgccagcugcg\n", + "aaacaauuccagugcuccaggcagccucagcacaagaaaagaacauggucuagacugaaguaccaacuaaaucaucuccuuucaaauuaucaccgacaccauc\n", + "aagaaaagaacauggucuagacugaaguaccaacuaaaucaucuccuuucaaauuaucaccgacaccauc\n", + "aupaaacucuugucuagugaugugacucauuacgugaucccagacuggaaaguuguucaagauuaucuugagauccuugaguuuccugaguugaapaauuauuuuc\n", + "gacacggaggcguaggccccgcggccugcgcccgcucgccggccucaccccccggcucucugccggupacccagcggcccgg\n", + "capccgcacgcugcggaucgugcgcgagcacuaccugcggcccugcgugcccugccacagcccgcucugcccgcagcccgccgccugcagccacg\n", + "ggcaacuccgcgcggcggcccggccgapapagcgagcpcpcpcaagccagacagcupccggagcagccgcpcgcccgapccgagcgag\n", + "cpcpacccagcgcaggcaacuccgcgcggcggcccggccgapapagcgagcpcpcpcaagccagacagcupccggagcagccgcpcgcccgapccgagcgag\n", + "aaacaaagcagcaugugcuugcggugcggcgucggcuapagccgagccpaagacaccccaccgccgcagaaap\n", + "cugcpupuagagaagcacuuggcgccucpapaccgcgcccgccucauuugcgccuugcagcacugcuggaccag\n", + "aauauggugcuaaaagaacuccuuaccuuucucugacuacaauuuauuuggacauacuuuuguauugaagagagguauacauacugaagcuacuugcuguacuauaggagacucuguccuguaggauc\n", + "gugccaagagccugcaauccuucccaaacagcccuuuguucugugcucaagucaacccacupacuuuacuacagauaaugauaagagaaauggcuugugagauugcucaug\n", + "accuagcaacaguaacauaagcaaaggagagucacgcccaaaauggaaacccaaagccaaaguaccccuucagacucuacau\n", + "gaagcaaucauaaggaggaacaaaaacagacacaaaaacagapaaagagugaaaagacaagaapcgcaaacugugacagacucaccgcuucacuaacuacucacuuaaacuggaagcaaa\n", + "auucuuucugccagguacaucagauccaucagguccgagcuguguugacuaccacugcuuuucccuucgucucaguu\n", + "aggauggauuagagaccucuauuuugaggcgcacugauguapcugaggaaggacauugapcaccuucaggucucucugccuauucuuccuugccccaacuccauuccaggu\n", + "auuaugccgacaagccccuggagaagccucuaaagcuaguccugaaggucggaggaagugaagugacugaacucucaggauccggccacgacuccaguuacu\n", + "uucucgguggaacuuaaaaugcugugagacaccagacagacagauacugugaacuuggagcucucua\n", + "pcaccpcgagguccuggccacgapapuucupcacgcpapuccupauuucpcapaaccpcacacgugapuccugg\n", + "agaggccgaccacguguacuguggagacugucaaagucucccggagcccaauuuccggaagcggugaguucugaaagaaguuccugcaccguaguuucccaagucugcgaauccccaacc\n", + "gugucagaggccgaccacguguacuguggagacugucaaagucucccggagcccaauuuccggaagcg\n", + "gagcaguuggacaucauggagacaacuuaguagagaagaucauuucagcacuuccccagcucccaggccacacaaaugaugug\n", + "agagcucggcggcupacuggaggacagcgguggcggaggcgacuagcggcggcpagcggcgccgagaggccgugcpacgcpcgccaggaccggccgaacgcagag\n", + "guugauucuucaccacacugaaaccauuaggaaaaauccuugugguuaacagcagaggcuucagaguguaaccuguacucpccuagaaauuauuuaaa\n", + "gcggcagagcucggcggcupacuggaggacagcgguggcggaggcgacuagcggcggcpagcggcgccgagaggccgugcpacgcpcgccaggaccggccgaacgcagag\n", + "gcggagcgccgaggcucgcguuccgccgcugcuuccgucgccpcpcgccgcggugucccugccgagcgugagccccgaacugucaccgcgccgagccccagccucauccgucgguguccgcg\n", + "gcggupuuugaaugagagcggugccucgguaggucgucagaaaguuacagucgcccaucugagcguuuguaagagauggaggcaggaguggugag\n", + "uauaucaagcugucuuccauuaaaguggacacgcgguacaccaccacccagcagguugugaagcucauuggcagucacaccaucagcaaagugacagugaaaaucpaucugaaacggaccaag\n", + "agacggcaguggcuccugagagcuggcupccauuuuggccccucgccuguggccuucugcagacuuggccupapaupcagcugcgcc\n", + "agauuagacuccucagaagcuaauugacuapaaggaucaggaagacaagacacaucaaaaapag\n", + "ggaaucuacaauggaaggacacaagaaagaucagcuggauuaaguagucaugauuaugcaaagccauauccagagaccaagguguaaagcag\n", + "pcugucucugcuugucaaaaggcggcagcggagccgugugcgccpagcgcggaacagcuuguccacccgccggccggaccag\n", + "ggcuccugaaccuagcccagcuggacggagaaauggacucuagccuccucugauagccucaugccaggccccgugcacauugcuuugcuugccucccucaauccucauagcuucucuuup\n", + "aagccuuupucugaagugucugugagaccucacagaagagcaccccupcuccacuuaccugcccccugcuccuucag\n", + "aaaaggcggcagcggagccgugugcgccpagcgcggaacagcuuguccacccgccggccggaccag\n", + "apcpcpcagcaggugagacgccaggucuccapcuccaaucacuccggagacugagcc\n", + "acugaggucccaccagagugaggauguacapccgcuucccuccccaggcccugcupuugacaccuuugucuccaguuucuuuccccauagccuugaaccagagg\n", + "aagcugcacagaugucaucugcugcguccucuuccugcucuucauucuagguuacaucguggupauugugg\n", + "ccugguuguauggagacccccggcaaguccucuaccccaggaacucuacupccuacuguggc\n", + "agugupaacgcggcggagcugugagccggcgacucpucccugaggucuggauucuuucuccgcuacugagacacggcgg\n", + "ccuagacuaaccaguuuguguugguccuccgcugagcuguuaauccapaagaguugcccuucugaagaauauguggauuuaauggagaccaag\n", + "gugcgguccgucgguggccuagagaugcugcugccgcgguugcaguugucgcgcacgccucugcccgccagcccgcuccaccgccguagcgcccgagugucppcgcacccgagucpcc\n", + "ucgguggccuagagaugcugcugccgcgguugcaguugucgcgcacgccucugcccgccagcccgcuccaccgccguagcgcccgagugucppcgcacccgagucpcc\n", + "gaagcacuggaaguucguaagccucaguucauuucucgcucacaagaacggcugaagaagcuugaacac\n", + "gauuacpacagcuaccacaguagaagagaucaaauugcccuuaaaaaucuccagucugaugucacagaggcaaaaucugacuucaccaag\n", + "auucugagccuagccacagagguaaacuccggacauuuuuuucuuucaugucgccaaauacauccuugucauuaaaagaccuuugaaacugaguaaaauggcuuugaaaccucaguagaau\n", + "agcuuugucuaaagcaapcaaaacucuuuaagcugugcccagaguugaaggagucuuuauauuucugauagaagacaguggcaaaaaaaaaaggcguaagaauuuugaagcu\n", + "cgagcgagcuagccagcaggcaucgapcgcggcugccguccggacgagacaggcgaacccgacgcagaagaguccaccaccggacagccag\n", + "pugccggccaggccugagcgagcgagcuagccagcaggcaucgapcgcggcugccguccggacgagacaggcgaacccgacgcagaagaguccaccaccggacagccag\n", + "gagacugauuugccccaupccuaagacauaagcugaaccucuggccugcaguuccagauccaaggugacugagacaaacugccagcugccacuggcuuaucaggagcaccug\n", + "aagacauaagcugaaccucuggccugcaguuccagauccaaggugacugagacaaacugccagcugccacuggcuuaucaggagcaccug\n", + "gauuugccccaupccuaagacauaagcugaaccucuggccugcaguuccagauccaaggugacugagacaaacugccagcugccacuggcuuaucaggagcaccug\n", + "gguucgcuccpcgcgcugcgcucgugaguucccaggaggccuggcpcaccguaaccagcgccgcggacaccggcaccggcgccacggacuccgcaggaccccgcgcccgccgccgccgcu\n", + "ugauuuaaaucuaccacccagcuguaguugaaucuacaaucugcucapauuuauacucaaugccaauuugauauc\n", + "cagacuuuggcaccgucpuccgucguccccgaaugugacagcauccccaccccggcugcugcccaggauccgccggaccccggccucgau\n", + "gaagcucggcugauucucggcucacgcpapaguaaapuggcgguccpccuggaguucagupugcagccugcuugcgagcugaggccagacappcgccuacggacgg\n", + "auaaggaggagcauuccaggccgagacgcccucaucagcagagucacaggaguuuuggaagugagag\n", + "gacgugucucucggcggagcugcugugcaguggaacgcgcupccgcpcagcgucgccucacgcggagcagagcugagcugaagcpacccggagcccgagcagccgccgcc\n", + "auucaguuuaaggagaaagugcuguggaccgcuaucacccucuuuaucuucuuagugugcugccag\n", + "guuccccagcucucccpacgaagcpcccgccagcgagucgcagucccaggagccgagcuccagcacuagagccagcugcgagcggapcaccaacuccgcagaacuggcuuuuca\n", + "gaggaaggacagcacagcugacagccgugcucagacagcuucuggaucccaggcucaucuccacagaggagaacacacaggcagcagagacc\n", + "acagaaggaggaaggacagcacagcugacagccgugcucagacagcuucuggaucccaggcucaucuccacagaggagaacacacaggcagcagagacc\n", + "agaaggaggaaggacagcacagcugacagccgugcucagacagcuucuggaucccaggcucaucuccacagaggagaacacacaggcagcagagacc\n", + "ggaaggacagcacagcugacagccgugcucagacagcuucuggaucccaggcucaucuccacagaggagaacacacaggcagcagagacc\n", + "cgugcucagacagcuucuggaucccaggcucaucuccacagaggagaacacacaggcagcagagacc\n", + "gauucugagccpcuccaucccucccuccucggagcccugcuacccgcagccgugucuccucccccup\n", + "ccugcuagccuuuccpagaaaaggcauccuuaccucugguugaaggucucpccucccccucugcauccggacccucuccccaucccagccuccc\n", + "agacaaguggccguaaucugacucccagcacacapagcugcpcaggcaaugagagcugcacucuggcupaaggc\n", + "gacaaccuucagguccagcccuggagcuggaggaguggagccccacucugaagacgcagccuuucuccagguucugucucucccauucugauucuugacaccagaugcag\n", + "auuccugagagcucuccucaccaagaagcagcuucuccgcuccuucuaggaucuccgccugguucggcccgccugccuccacuccugccucuacc\n", + "gaccuaaaccuccugccuuccacccacagcaugcccugccuggccccacccaggccupugccuugcucagcuccccaaucuccaaccucccacag\n", + "gccauuccugagagcucuccucaccaagaagcagcuucuccgcuccuucuaggaucuccgccugguucggcccgccugccuccacuccugccucuacc\n", + "guaaagcucucaacccuguccccuucccccucucuccupaaagagcccucccaugccuagcugcugcucuuapacccuguggcuaggugcgcggauggaaauccag\n", + "gauuggcuccupcuuauaagaaacgcgugaaugagcagcugccgcpcagaaaguugccggaggucuccpugguaucgcccuuuccucuuugccagcccgcuggcgagccgagccapcaag\n", + "gcpcagaaaguugccggaggucuccpugguaucgcccuuuccucuuugccagcccgcuggcgagccgagccapcaag\n", + "ccggaggucuccpugguaucgcccuuuccucuuugccagcccgcuggcgagccgagccapcaag\n", + "puapacccggaaaccccapucuggaggagagcaaccaggaagcucuupugacuucguuuuccuucag\n", + "auuaggaaacagcaacccuuucaccucaguuuucuucacuccggcauuugcagcagagcgaaagguggucgaguccugaaggapccugaugucuucaucauucucaaauucuu\n", + "aggacggucpcccuggaaggaacgcucucggaauuggccgcggaaaccgaucugcccguuguguuugugaaacagagaaagauaggcggccaugguccaaccuugaag\n", + "aguuuucuucacuccggcauuugcagcagagcgaaagguggucgaguccugaaggapccugaugucuucaucauucucaaauucuu\n", + "acacaaagcuucagcaugucaugugguaggugaggccggcgccuguaggcuggcgguuuccuuccucuuggucuuuguagagacaguuugcagaacagcggagaaaaugg\n", + "guugaacaaauugaagcapacaccaggccgacucagaguaguagcucaguccaccaauagugaggaaaucauugaaggagaauauaauacg\n", + "uagccauuaggaaacagcaacccuuucaccucaguuuucuucacuccggcauuugcagcagagcgaaagguggucgaguccugaaggapccugaugucuucaucauucucaaauucuu\n", + "ggcggacagapcuggaaacaagacgcuccagaaucaggagcuuccccucaggaaauagcauccuguguccccgcacugcaguugucuggucucuccagcaguuugguacuuccg\n", + "agaaucaggagcuuccccucaggaaauagcauccuguguccccgcacugcaguugucuggucucuccagcaguuugguacuuccg\n", + "gaaacccacgcagccuccuggauucuuccccgucccucccucuguccupcugugaccuccuccauguuauucacapucucagcacgauucaucucaaag\n", + "cgccccccuccggccagcccgcagccggccgcgucaugccaggcgcugcucggcgguapagugcccpccgccgccuccgcccgcccgaagccgcgcccacugcccagagccagap\n", + "uuauuugccaagaguuucagagcuauuaacagaagccuaauacauguucuuggacuuugcagaaauaauuuguugauccaugcgguuucauugcuacugcggaaa\n", + "auuuuaaauaaacuuggagccuuuucuugaaagacagcuggcuguggagagccuucuaccaacugcaguuuuagauacguuuugaaaauuucaucaccugag\n", + "ggauaagaguugguguccuuguucuuuuuucuuuccupaauuguucuaguacugagauuuccucuuuggcuugaa\n", + "uacuuuguuuugaaaaguucagaucaacugauaauacuagugcugugaugagacucagcuuguacucaagaacagauuuaugacuag\n", + "auuaugauguapapaggaaggapccapuapcacacccucucccugaaugaaauucauuuapcacugucugcucgc\n", + "aauguauuaugauguapapaggaaggapccapuapcacacccucucccugaaugaaauucauuuapcacugucugcucgc\n", + "ugaauaacccuauaccuuccaauuugaaaucagaagcaaaaaaggcugccaaaauauuaagagaauucacagaaauaacuuccagaaauggaccugauaagaucauuccug\n", + "cucacguaauugcgaaggcuaaaggccuugcaauucugucugugaucaaagccpuuccuggugacugccagaggaggcagcpauuguaguggcgcgccuuccagauggaa\n", + "aauggucugcacccucagccauupauagcuggccuugguggaggauuugaaauaggaauugag\n", + "agugccacuccagcuuucuuagguugccaucugcaugacacaucuuucuccauccuuuuacugucaaucua\n", + "agacugacgagacacccaugaaugcuuccuuuucuguaaaaupacaaugacaggaccuguaaccacacapuuuuccuuucaagcacauagauggcacacacguaaucg\n", + "cgaaggccugagcgcggcccggcpcgcgugguuuuugucccgcgaaacguacacggcpuguuuugcgccgccuccuucgucaccugccgcag\n", + "aaauaaggaucuggcaugucaacacaaacauaggaaguugaggcagucaaapaaauaacugcuacccugacucugcugagagccucacaagucccugugcacgccagcuuguuugcc\n", + "cucuuucccugcugauuccaggagccuaucaacccagauaaagcpaccuccucucugguagaggugcapcaguacucaac\n", + "agauaaagcpaccuccucucugguagaggugcapcaguacucaacaugaucacagapagcgcaggccccucgauuguugcugccgccgcugcuccugcugcucacccugccagccacag\n", + "uaugaagaauccuccggcaagugcaapccuccuppuggugucagcguggaagacugcugucucaacacugccuuugccuaccagaaacguaguggupcucugucagccuugcag\n", + "aggaugcccucccaguuccuccugccucuagguuccucuuucccugcugauuccaggagccuaucaacccagauaaagcpaccuccucucugguagaggugcapcaguacucaac\n", + "gagccuaucaacccagauaaagcpaccuccucucugguagaggugcapcaguacucaac\n", + "uguaaacugcaupcapcgccaaauaacauccugugcgcugcugagcugagcupcgcggccgccugucugcaccggcagcacc\n", + "capuaaapuuuccugaaguuucuaccugcucuaaguuucuacccuugaggcugauugacuaguccagugagaucaaggaaaugaaaggcauuucacacaccagcag\n", + "ggaggacggcgacgaccagaapcccaagagapcgagcgaccgagcgccgcgacgcggaagugag\n", + "gauagcugapcpuggauguuggauggauuagaaccaucacacuupccugcuguuugccugaguuugaaccacaccccga\n", + "gaccccggcccggccccuccgagagcguccupcgcucccucacgccuugccuucaagccuucugccuuuccacccucgugagcggagaacupaguggccauucgacgacag\n", + "ggcugagagauuaggcugcuucuccpauccgcuuuuccccpaaacgcgaggaugcuccauggagc\n", + "cuggacgaacpaagccpagcucggccacpuggcgaggcugcggugaggccuggucuccggcugccagacc\n", + "acugcguaacuaccgccccugccucupaauugaaguuucuguggaaggaagcgugagccguaaccaggccaacccagaaaggcuuucuuucugagauuucacuucccugucaacucuucagcucg\n", + "cucupaauugaaguuucuguggaaggaagcgugagccguaaccaggccaacccagaaaggcuuucuuucugagauuucacuucccugucaacucuucagcucg\n", + "gcucgcgcpuuggugagguuccgcugapcggccpcucupagcgugguaacguggcugcaaccuuagcgacaucaggaagaacapucgaggaucgag\n", + "guccgccpugcucgcgcpuuggugagguuccgcugapcggccpcucupagcgugguaacguggcugcaaccuuagcgacaucaggaagaacapucgaggaucgag\n", + "gcggagugugcguggccugagccgugcpugacugcuucapcuucuccgcgacuggaccpcgccgcucgaaagcacgcccuccauucgcacugcuuguupcucauc\n", + "cpugacugcuucapcuucuccgcgacuggaccpcgccgcucgaaagcacgcccuccauucgcacugcuuguupcucauc\n", + "ggagugugcguggccugagccgugcpugacugcuucapcuucuccgcgacuggaccpcgccgcucgaaagcacgcccuccauucgcacugcuuguupcucauc\n", + "agaagccccpcggcggaagucgucacucuuaagaapacpccccacgcugcgcacccgcpuuugcu\n", + "cagccuugagccgucccucguccuccucucaggcucccucuuguccacggcpcpcgccgagcugcug\n", + "acacucaugcugcagccuugagccgucccucguccuccucucaggcucccucuuguccacggcpcpcgccgagcugcug\n", + "ugcggcaccuucccgucugaugcuggcguugugcguauggugcccugacgucuguccacgupcgcggaagcaaacagcg\n", + "ccuugugccucaccuacccccaaccucccagapagcagcuauuuaapagcaggagugcagaacaaacaagacggccupauacaacucuggaguccucugagag\n", + "agccaccaaggaggagcapagcgacggccpcagaaguugagaccacccagcagaggagcuaggccaguccaucugcauuugucacccaagaacucuuacc\n", + "ucacauuaacuuugcucuagaagacaacuuuacaaggaucuaaaaggaacaggauuaaagaugacugaauacupuuccagaaauuuaaaacaaucag\n", + "cuuagcaaaucauauauucuucuguggagcugagaauugauguccgcucuuccccgugauuuggaacuuuccaaucccagagaaaaguugacaaag\n", + "uuaaucagccaaucccucgaagagucacuggcugccuacaaaauaaaguaguugugaccauagcaugupcagaugugcugcauggcaguaguagacacpag\n", + "ucacuuccugccuugugaccacacacccaggcuugacaaagcuguucugcagaucagaaagaapuuccuggucauacaccaguacuaccaaggacagcuuuuuuccugcaag\n", + "gcagaucagaaagaapuuccuggucauacaccaguacuaccaaggacagcuuuuuuccugcaag\n", + "agucucaaacauugucucagcagcagcaucauaucuuacaaaaguugaggaaauacuguauuuccagcuuaggaaacugaag\n", + "guagugccgccpacucuuggcpugaaggugugugucagcuuuugcgucacucgagcccupcgcugcuugcuaaagagccgagcacgcpucugucauc\n", + "ucguagugccgccpacucuuggcpugaaggugugugucagcuuuugcgucacucgagcccupcgcugcuugcuaaagagccgagcacgcpucugucauc\n", + "ccpacucuuggcpugaaggugugugucagcuuuugcgucacucgagcccupcgcugcuugcuaaagagccgagcacgcpucugucauc\n", + "gugccgccpacucuuggcpugaaggugugugucagcuuuugcgucacucgagcccupcgcugcuugcuaaagagccgagcacgcpucugucauc\n", + "gccuaggagcgacucucggucgugcagcggcggcgagcgcucgcgagcggcugcpacgcgagguuuccgg\n", + "gcacuuccpucgaagagcgcacggcggcggcagaggcggcggcggccpccuaggagcgacucucggucgugcagcggcggcgagcgcucgcgagcggcugcpacgcgagguuuccgg\n", + "gagcgcacggcggcggcagaggcggcggcggccpccuaggagcgacucucggucgugcagcggcggcgagcgcucgcgagcggcugcpacgcgagguuuccgg\n", + "acucccagacuccuugcggagcucgccgccugauucuaggcuggucacuacuccgagccugugacguuugcggcagccaggccgucgacg\n", + "agaaggccucacucccagacuccuugcggagcucgccgccugauucuaggcuggucacuacuccgagccugugacguuugcggcagccaggccgucgacg\n", + "gcggagcucgccgccugauucuaggcuggucacuacuccgagccugugacguuugcggcagccaggccgucgacg\n", + "ugucaccacagagccugaucgugcugugcagucuaaapaccacpcaagaagaggugacuuuggugguguccagagcaggcuucucaaccuc\n", + "accggcuccccggcucgcgccgcuccauguagccccggcuccccpcggccgcggaggapcgaccacaag\n", + "ccuuucuucucuccccucggcgcagaccucucgcugcuucaggaggaccugcaggaggacgcagacggau\n", + "uugguguggaugacuacagcucagagucugaugugauuauuauaccuucagcccuggacuuugucucacaagaugaa\n", + "gcgcgcguccaccggcuccccggcucgcgccgcuccauguagccccggcuccccpcggccgcggaggapcgaccacaag\n", + "gcccggccpuuccggcacucgccgcapucccggccggcggcagguugcgcgcccccguccgcagcgcucggcgugapcggcucpaggapu\n", + "guguaaccucuccuguuuuuguacauguguuuauuccugaacuguuuupcuacucauuguuaaccagguugcugcucuacuuuucccacugcuggcuaaggaagauucaacuuuuucag\n", + "acggagucucacucuguugcccaagcuggagugcaguggcaugaucucagcucacugcagccucugcuuuccpuucaagcgauucucuugccucagccuccugaguagcupauuacag\n", + "gcuucugccaggupugugcagacuggugagcugccagcapcccagacgcgccaggccuggag\n", + "gcaggagaaagaggaagcgcuggcagacaaugcgacccgaccgcgcugaggcuccaggaccgcccgcc\n", + "acugcugcpccgcppcgcagcupcgcggcucggapaggcuapccgugccaggcccgaagccgaggcpccpaugcggcgcugaggcccagc\n", + "ggcccucugccucccccpagccupcuucccuucccuccagauauacagacugagaccacagaagaggacaguguccugcug\n", + "agacgccuucuggauucaagaagacgaggugagcugagguaccuggcuuuagugaagacccugupcuuccuggcugcggcuucgacgugccugacuccacacgccccuaag\n", + "gcgcacuaucgaguugcggapcguguaaapupucguagaacugacucucucggaggcaaaaggagcupccuuggaaaccagauggccupuuuuuuag\n", + "pauaggcucagacacaaggagaggcuuggagagagcagacgccuucuggauucaagaagacgag\n", + "uccaagcaucugaaupaugagagaaguggcaguaauuacaggcggaucccaupccggaggccugcaccaccgcgagauguggccauuuuacaagaaagg\n", + "acuuccggccapapauaggcucagacacaaggagaggcuuggagagagcagacgccuucuggauucaagaagacgag\n", + "guuugaagaaaaccugcuggagguuupaccuaaccgcaucaaagucgccuuuagcggugccuggacccaguucgcacpaggaaguaggag\n", + "gcucaccuguuacucggccucccagaaagauggauaggagaaaugacuacggauauapugccucuauuucag\n", + "acuuccggccapapauaggcucagacacaaggagaggcuuggagagagcagacgccuucuggauucaagaagacgaggugagcugag\n", + "aaguaacgaucuggacucgguucpccgugaaapapaugcagaccuaguupaccgcagaaaggaaggaucgagaaauccuucagacg\n", + "auuggagccggcuuggcuggcgagcccggcugaggagccucuupccgcacuuaccgccgcguccgcucccggucccuggccccucagcggc\n", + "gcuggaggcgccauuggagccggcuuggcuggcgagcccggcugaggagccucuupccgcacuuaccgccgcguccgcucccggucccuggccccucagcggc\n", + "acuggaguuuapcugcauucagacpcugcauucagacagccugcgagccgccaggugauccacpcupcuucgcuucugcuguccccugcgauccaacucccca\n", + "gacauuugcuacaagauccuauugcacccaccaacuccaccugccaacauuaugucugcaaaacuuguaaaggcaagaaa\n", + "gagcccapupuuggcagcggugapacuggcgcgagcaggcugauguguuuauccgguuuucupupcggucaaagcgcacgcggaapcgaaaggcggcggagcuag\n", + "gcaguccagaugucgucagcaccagcgccupcuggaggacagagaagccuuuuccguugccggugccggccuagcguccuggaauuacuucaaucaa\n", + "cpuuugcugagaucuguggccggcggcagcuggugcppcagcugagagcgagagguggaucpcgguguguggccapcc\n", + "gagcucggcggcpuuugcugagaucuguggccggcggcagcuggugcppcagcugagagcgagagguggaucpcgguguguggccapcc\n", + "cgagcucggcggcpuuugcugagaucuguggccggcggcagcuggugcppcagcugagagcgagagguggaucpcgguguguggccapcc\n", + "aggcccucucgacgucggccugupagcgaugccgacaagcaggagcggucccggcuucggaaapcccacccugagga\n", + "gugcgcccaacagcggacuccgagaccagcggaucucggcaaacccucuuucucgaccacccaccuaccauucuuggaacc\n", + "cagcggacuccgagaccagcggaucucggcaaacccucuuucucgaccacccaccuaccauucuuggaacc\n", + "ggcugcggcagugcgcccaacagcggacuccgagaccagcggaucucggcaaacccucuuucucgaccacccaccuaccauucuuggaacc\n", + "agugcgcccaacagcggacuccgagaccagcggaucucggcaaacccucuuucucgaccacccaccuaccauucuuggaacc\n", + "agguggcpcpuacuuaaggcgcggccaccgcggcugcggcagugcgcccaacagcggacuccgagaccagcggaucucggcaaacccucuuucucgaccacccaccuaccauucuuggaacc\n", + "agauggaauuucaccguguugccuaggcuggucuggagcucuugaucucaagcgauccucccugccucggccucccaacgugcupauuauaggc\n", + "agugucagugguguuggcaucagcuupcaggugugcpcucaggaupcggccguggugaggaacccuggacucucag\n", + "agauggaauuucaccguguugccuaggcuggucuggagcucuugaucucaagcgauccucccugccucggccucccaacgugcupauuauaggcgugagccaccgcuccuggccagg\n", + "caucagcuupcaggugugcpcucaggaupcggccguggugaggaacccuggacucucag\n", + "aggaagcccgcccugcccgcccgccagugucagugguguuggcaucagcuupcaggugugcpcucaggaupcggccguggugaggaacccuggacucucag\n", + "gucauuugaagacucucuuggaagagauagcgucuugcugcaaccugcagucccagcagaaaaaccuugugauccuuguugcpcgac\n", + "ucgcgcapucpacugcgcggcggugccaggccpcgupcgagagcacgaacpcugccugcpcugagagcgucgagcugucacc\n", + "ggcccccuagcgucgcgcapucpacugcgcggcggugccaggccpcgupcgagagcacgaacpcugccugcpcugagagcgucgagcugucacc\n", + "pacuguguuaagaaccaapcauauaaagacagaupaggagacccuggccpagaggaagaagcaucuacauagguacuaaguaccauucgcu\n", + "gcaaccagcpccgaggcggcggcgccagcggcgccuuaaauagcauccagagccggcgcpcapagupcugcagugacagccggcggcggagcggccgguccacggaggag\n", + "gguagugguggugcacgaagauccgcacuacuugacagcgacgagcccuugguguauuucuaugaugaugucacaacauuauacgaagguuuccagapaauacaggugucaa\n", + "auaauggcccuuguuuaggcucucggaaaccagaccaacccuaugaauggcuuucauauaaacag\n", + "guugcagaauugucggagugcauaggcucagcacugauccagaapcuucaagacugccccagaucaguucauuggcaucuuugcucaaaauagaccugag\n", + "auuggcuguucggagcggcgapcuuggcpagcuuccagucgcucgagagcggagagcggcacc\n", + "cuggaucuggcpaapucucggcuugcugcagacggugcacaaagccauacgccaagacgaucugaagagaacaggaguucccccpccupaaggcugccuggaggaggag\n", + "cucacccugaaggugacaguuccuuggaaccuucccugauccuugugaucccaggcuccaagaguccacccuucccagcucagcucaguaccucag\n", + "gaaggugacaguuccuuggaaccuucccugauccuugugaucccaggcuccaagaguccacccuucccagcucagcucaguaccucag\n", + "cgccuccccuucagcuucucuucacgcacuccaagaucuaaaccgagaaucgaaacuaagcupucc\n", + "gcucaapacucagccaacuggcucacgccuccccuucagcuucucuucacgcacuccaagaucuaaaccgagaaucgaaacuaagcupucc\n", + "agcucaapacucagccaacuggcucacgccuccccuucagcuucucuucacgcacuccaagaucuaaaccgagaaucgaaacuaagcupucc\n", + "caacuggcucacgccuccccuucagcuucucuucacgcacuccaagaucuaaaccgagaaucgaaacuaagcupucc\n", + "cagccaacuggcucacgccuccccuucagcuucucuucacgcacuccaagaucuaaaccgagaaucgaaacuaagcupucc\n", + "gccaacuggcucacgccuccccuucagcuucucuucacgcacuccaagaucuaaaccgagaaucgaaacuaagcupucc\n", + "cccuuuuuacugucccpaacuggucgccupcaagucuggauacuuagcagcacagguccuguucuaggacuguagucccucuupugcgcuggacggagaapagacuuuucaccagua\n", + "gucupaaaccgccgacuuccggccgcgcagcggupcugagcuaaaauggcugaggagagagucgcgacg\n", + "cuccagaguuuccuauuuuggagaagcagaacugguugauucaucuucauuauauccggaaagauuaugaagccugcaag\n", + "cauugauauuucgccuagaaggaaauauccaagaaucccuagaacucuuccagacaugugcaguucuuaguccucagagugcugauaaccucaagcagguggccagaucuuu\n", + "auuucuuuupaaaacauaaagcugccauugaaguauauaaugaagcagcuaaacucaaccagaaagauugg\n", + "acagccugaauagaapcugguccagcggcggcggaggcuggcgcuguccugagapapcucugugcggaagag\n", + "agaapcugguccagcggcggcggaggcuggcgcuguccugagapapcucugugcggaagag\n", + "auucccuuccgcccccuucucuaagcugcacagccugaauagaapcugguccagcggcggcggaggcuggcgcuguccugagapapcucugugcggaagag\n", + "cuucucuaagcugcacagccugaauagaapcugguccagcggcggcggaggcuggcgcuguccugagapapcucugugcggaagag\n", + "ggagupaggcggcaagaggaccugcggcaggcccucuucggcagucucuccggcccgguuucccucggcgugcuacugugcgcucgauccagcacc\n", + "ggcggagupaggcggcaagaggaccugcggcaggcccucuucggcagucucuccggcccgguuucccucggcgugcuacugugcgcucgauccagcaccaupaagcpacaaucpug\n", + "guacugccaaaauuaugacaugauaccaaggaaauuagaaugugaucaauauuguugaaaacaaaaacaaaaaccugagaccaguuaaauuuaacaaag\n", + "ucccgaagcggccagcgccpagcugcagcgcugagacccccagcccgcccccucpcucccggccpccccauc\n", + "gacaauguggucccgaagcggccagcgccpagcugcagcgcugagacccccagcccgcccccucpcucccggccpccccauc\n", + "aagcuuacaggagcccggugucccggagcacaggccapccpccagaagcccauccgacauccagcugacccucacccucugaccccagcccucagcgcc\n", + "cggagacccccaucggucagcugccaggccccacgcgcucgcggucuccgcgccccgacggcugcgcc\n", + "gaguggagcccpugagacccggagcugacgccpccgcapacapacccgcccugugcucpcuc\n", + "gacacugcccaucucuaagauaagaaccuggaaapacucuguuggccauuggaaauugcagaaua\n", + "gucagucccgcgauagcuucaggccuggcggcggcuuccaagcuaaggaacgguuupcagugucguucccggag\n", + "aaacagauccggagcgcguggcpcgucagcgcgguggccagcgcgcagaggcpcgcggaggcggcuagaaggugaccgcggaucccagcuuccugcagccag\n", + "gaguugguaaacagauccggagcgcguggcpcgucagcgcgguggccagcgcgcagaggcpcgcggaggcggcuagaaggugaccgcggaucccagcuuccugcagccag\n", + "gaggugagcagcucupaucacucugcaggaaaagaauagapagaaagaucucagaggacccgaag\n", + "pauagcuguccaaggucucccccagcacugaggagcucgccugcugcccucuugcgcgcpaagcagcaccaaguucacggccaacgccuuggcacuagg\n", + "agaugcuggcggagccggagcagccgcggacucagagagcccuucugccagcgccgcpacucuagcuucapcucuucacaggcccupcgugccucagugacpacccagcaaag\n", + "agaggucccaaggauggaguccuggaaccucccacauuccaaggcuacagacaggaggapaaccagcauaggaacuggc\n", + "gcacugcggagccaggagapugcapcuccucuucuuggagaccccguggucaagccccagguuggagugugaauccugccuggccgucaacuucccapacuugagg\n", + "uguggauccagcuuguccccaaagcuugccuugcuuugaagcauccgacuguaaagaaucuucaccu\n", + "agaagcggcaggcggaggcgcgguccpcgcuauggccaugcccggcpucucacgcggcugccccucgcccggcgcgccuucgguapcgcccpcccagcuggcccggcc\n", + "gcaagugcugcgaaccacgupucccpcgcguuucpugcuggcggcugcagccggaguucaaaccuaagcagcuggaagg\n", + "agugcugcgaaccacgupucccpcgcguuucpugcuggcggcugcagccggaguucaaaccuaagcagcuggaagg\n", + "upucccpcgcguuucpugcuggcggcugcagccggaguucaaaccuaagcagcuggaagg\n", + "gcagaagcguuccgugcgugcaagugcugcgaaccacgupucccpcgcguuucpugcuggcggcugcagccggaguucaaaccuaagcagcuggaagg\n", + "gugcaagugcugcgaaccacgupucccpcgcguuucpugcuggcggcugcagccggaguucaaaccuaagcagcuggaagg\n", + "aucacaccuuccuccugcccugacuucucauaucuugccuaggaacuccaggcuugucuuggcuccaa\n", + "uguaaaugagaggaagcaaagauuuuuauggagacuaucaauaaucucaagaaaauacauauucaaaauggaauuaaagccgugca\n", + "gcggccgccpccccpuugaggcgaggagcccgcpcggccggucpcpcggcggcgcugacag\n", + "ggcaacaaccuucpcugcapccgaggcucupaaaacuccuccaacagaacaaguccauucagag\n", + "gcaaacagauuaccagaaauacagcagccacuuugcagaaaggaaggauuaugucaaauaguuagaagauucccag\n", + "aguauucguucaccuuucauuugaggagaagcuaagugcugacugccagaggauggaauaggaagacaaug\n", + "ccgcgcgcuccapaagccugcaucccgcuccccupccccgacpcpcgcacugcgcpcccaccggccgcagaccugcguggccguccapcgucgcc\n", + "uggcucaugugaugugguggcccgcaggcuguauggcugcaggcccggapcaucuggagaccugugugaucacucauauccuuagaagaa\n", + "uucccugugucucuggugguuugccuaaaccugcaaacaucaccuucuuauccaucaacaugaaga\n", + "gauuggcupcpcpcgucucccgcccpccuagagcgcugccpcgccpacu\n", + "cagaagcccagaggcucagcggugcuucuggaguuccagugaucccggagucugaaccggcagugagagupaaagagg\n", + "cuuccugucgcucuucaagguuuccaaaagaccaucuuucagcaguugccucaauuaaggccuuggaaccag\n", + "ggagugaaaaaaauagauccugauuuauaugaaaaguuuaucagucacagauuuggagaagaaauauuauaucgcauagaucuuugcucc\n", + "uaucuuucuuguuuugcuuucaaauggauuguccucuuccaagugguuucaaacuuaaucacagaaugacaaucaguggugaag\n", + "gccauuuugcaggcggcugucgcpaccggaggcggaggcugcagcpcacugcggcgccgaggcgcggcggcaggacpaaccacgcgagcugcagccag\n", + "cuaggucuugacuccacuaacpacuucucauacggcuuugaacuuggaccuuggugcauaagcaaauguaacucagcgaauuguaauggaaagcauauggacaggucuacgccacaucacuuag\n", + "cauucaucuucuccugcccuuggacaucacagcuccaggaacucagaucuucagacucapugaaggacaccaccagcuuuccagguuccccagcuugcagacggcauacg\n", + "uccgcaucccaggacagcggugcggcccucggccpcgcccacuccgcagcagccagcgagcgagcgagcgagcgapcggccgacgcgcccggccpacccagcugcccgu\n", + "gaaupacuugaagcuggccpcugcuupcugcagaggaagaapcugccggcaaaccugcugacucaggcuccacgapagcaaguaacacuggacuccuuucggcacuccgaga\n", + "gaaucagccuggagagcgcggaaggaaapucgguccgcagapcgcpaaggcapupacgcgguggagcccgcgcucguuugcugaaggcuuggaagugcagcgcagaagacagagg\n", + "acauggcupcucccugcuguuguuggucugucuccuggcgagcaggaguaucaccgaggaggugucggaguacuguagccac\n", + "gagccgcucuccgcaucccaggacagcggugcggcccucggccpcgcccacuccgcagcagccagcgagcgagcgagcgagcgapcggccgacgcgcccggccpacccagcugcccgu\n", + "cccgcugagcgucgacacagucgcuguuggccugguguccagcgugguugucuaucccgucuaccuggccauccucuuucucuuccggaugucccggagcaag\n", + "ccccggcppucaggauccuccacagguaggcgcagucagcuggagcgucgcggcgguccgccggucguggapcguguccugcggcgcg\n", + "ggcppucaggauccuccacagguaggcgcagucagcuggagcgucgcggcgguccgccggucguggapcguguccugcggcgcg\n", + "gcgccccgacgucacuccgucucgcccugccccggcppucaggauccuccacagguaggcgcagucagcuggagcgucgcggcgguccgccggucguggapcguguccugcggcgcg\n", + "acuccgucucgcccugccccggcppucaggauccuccacagguaggcgcagucagcuggagcgucgcggcgguccgccggucguggapcguguccugcggcgcg\n", + "ppucaggauccuccacagguaggcgcagucagcuggagcgucgcggcgguccgccggucguggapcguguccugcggcgcg\n", + "uccuccacagguaggcgcagucagcuggagcgucgcggcgguccgccggucguggapcguguccugcggcgcg\n", + "aucgccpagagccuuccggacuccpcggcggcuggcupcgcguuccgaggcgcccucaggcapcgcpcagagccucgccupuucuggaggcugcpccaucgcuccag\n", + "cuggcupacgccccgaguucuuccugagucucuacuguuucaucuguugauuucaccaaaacaaaaag\n", + "gcagguuccagucugcpagauggagaaggugccaccaugcugcugcacaaaucccaggauagcupaaugagaauccagcacuuupccuaggaccuggaaggagaggucuuuupagag\n", + "cucuccugaacaaaggcpaacagcucuaggccagaguuucupaugugccucaccpucucacugccugcaaag\n", + "guucgcgcucugaccagcccgcagagccagcccccgaccccpccaccupcccccpuuccgccggcacucucgccaccaccgcgugg\n", + "cuuccuuggagcgccgcgacucpcugapagcucpccaaucagapacggccccagaauggcaug\n", + "uuccuuggagcgccgcgacucpcugapagcucpccaaucagapacggccccagaauggcaug\n", + "acuccgcccccuuccuuggagcgccgcgacucpcugapagcucpccaaucagapacggccccagaauggcaug\n", + "auucgacccuuuccuugccccgguccgccggcgcugcupaaggcuuccuagucucucugcccgcacuucccgcccagaccacgugcggagccugapcccucuuggaag\n", + "cgcagagccagcccccgaccccpccaccupcccccpuuccgccggcacucucgccaccaccgcgugg\n", + "auucuaaccgccgccaggucccgccgccucucgccccgcuauuaauaccggcggcccpappcgcagcacgcgccgcgcagcc\n", + "gcuggagugcaguggcaccaucucggcuuaccgcaaccuccgccuccupuucaaacaauacuccuaccuuggccuccugaguagcupauuacag\n", + "gaaucaagguugcuaagagaccaccugugcugaauacacuuuguucuggcaagagcagaaaacugagaagccguguuaccuaccacuaccupauuaauucag\n", + "acggaaucucccucugucgcccaggcuggagugcaguggcaccaucucggcuuaccgcaaccuccgccuccupuucaaacaauacuccuaccuuggccuccugaguagcupauuacag\n", + "auuugacacaggaaucaagguugcuaagagaccaccugugcugaauacacuuuguucuggcaagagcagaaaacugagaagccguguuaccuaccacuaccupauuaauucag\n", + "agaccagugagccuccugauccaccaagaccauaugguguuuuucauaaaagagagagaucauucccuugacuuuggacuucgcuuauugaaccccuggaca\n", + "gccuccugauccaccaagaccauaugguguuuuucauaaaagagagagaucauucccuugacuuuggacuucgcuuauugaaccccuggaca\n", + "gcaaaggccccacguguuccgacccgcuaggccccgcgcggcucggauccggcggcgcuguuucggucpagupupagagaagccpcapaggagccgccggagcugucggagcc\n", + "gugacacccapcagcuacacucagaagccacaaggaaugcuaguggagccccucaucccucccagcuucucuuccaagcugccccgupcuugauccaggaagcuacuucagaaag\n", + "acaaucauuccaapuacaacaagguuuaccacaaugugapacucagccauugcaaauuguacagaugag\n", + "ggcccuuggaagaaaauccucgcuguguccaggcugaggcppcuaaugacagugugagcucuagauggugugagaccaccccaaagccaagaa\n", + "aaggccccacguguuccgacccgcuaggccccgcgcggcucggauccggcggcgcuguuucggucpagupupagagaagccpcapaggagccgccggagcugucggagcc\n", + "guuucggucpagupupagagaagccpcapaggagccgccggagcugucggagcc\n", + "cuauacccuuuuuguacucuguguauauacuauauugcaguagacaaucauuccaapuacaacaagguuuaccacaaugugapacucagccauugcaaauuguacagaugag\n", + "pcuucacguuuugaucaaaauauuacaccuguauucupcuuuugcugugaauuccuaguauugcuaaaauucugcaauuucuuaacuaccuguuaaguuccucaag\n", + "guguuccgacccgcuaggccccgcgcggcucggauccggcggcgcuguuucggucpagupupagagaagccpcapaggagccgccggagcugucggagcc\n", + "uagacaaucauuccaapuacaacaagguuuaccacaaugugapacucagccauugcaaauuguacagaugag\n", + "aaaggccccacguguuccgacccgcuaggccccgcgcggcucggauccggcggcgcuguuucggucpagupupagagaagccpcapaggagccgccggagcugucggagcc\n", + "gccccacguguuccgacccgcuaggccccgcgcggcucggauccggcggcgcuguuucggucpagupupagagaagccpcapaggagccgccggagcugucggagcc\n", + "pcpccpccgcuggcgcugucgccggcugcaguggccgccgcuggagaccgcpaccuggcgcugcagcgag\n", + "gagagcaagcccuggagguucacucuuucaagaagucgugugcugagguguaaugcuacacaagucagaggaaggaapuccugaaacacaug\n", + "gcagccagaacggcuucupacgccgacuuucgcgcaggcggcggcggcggcggcggcpucccugagcuggaagccgguaggacugcuggccgcgc\n", + "gugguccguacugagaagaacaguuugaacaaccgauucuuacccuggaaugaaauugagacagaggccauccuguccauugaugacgaugcucaccuccgccaugacgaaauc\n", + "uugugucccuguggcuuuggugcgccugugugcacuuucucccuccaccuggagcaupcuaacaccggaggaaaggaaaagacagagucagacagg\n", + "ggccugccccaucaccugaauuccagagaugccagugugcacugaagccccaggcapcgugcccaggaccggauccuggauggug\n", + "augaaagugauaaucaggcagcccaaaugauuguuaauaaggaucaaaugagaucguguaugupuccaaucaauugauucuacacaaag\n", + "cuauuupcggauucuuggcgccggaggaagaggcapucacccucucuccacgucagagaccugacuguggag\n", + "auuupcggauucuuggcgccggaggaagaggcapucacccucucuccacgucagagaccugacuguggag\n", + "acggaugcucguugcuucugcguaucugcpugugugccucuuuguauuguagccuggagucagugcucgcuucugcgccugcaggauguccaugugucugcugg\n", + "gcugcggcucpacccacagacacagccpucpagccgcccpcapcucpagagcgg\n", + "gccacaccaugaggccccagccccaccagaggccccgcgcugcccuggcccccggugcaccgugcuagcccccagccapcguupapcgguggcc\n", + "agagccagcucugucgccgcuggagcagcugcggcucpacccacagacacagccpucpagccgcccpcapcucpagagcgg\n", + "gcaucapccpacpuaappugaagaapccggccuucaagcaagagcgacgcaagauggcagccaccacpcucgg\n", + "gaguaaaagucccucgcaauuuccgacuguuggaagaacucgaagaaggccagaaaggaguaggagauggcacaguuagcupucuagaagaugacgaagac\n", + "uuuuauguuugcuacaggagacuuaauccaguauagcugaauaauccaguuggcugcugugcagaugaaaaugccaguguuuuccaaacaagcaguucaa\n", + "gacuccagaauuuguuugcccucuapuagaauccgccaagcuuugagagaaggcugugacugcugugcucupcgccagcucgcuccapagug\n", + "ggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "cggcugcgccugcggagaagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "aaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "gugcuppacccugauguggcaccaaaugaaaugaacaaagcuccacaguccacaggccccccacccgccccaucccccggacucccacag\n", + "cuupuuucugccccaccupcuuccccucuugcugaacucuggucuccccucuucagccagcguuucccccpcagacagcgccggugguguucaguacgccacaagcgacacaa\n", + "aagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "agaagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "cacuucuacccuagccpcccagcccccgagcagugcagccucccgagugcagagugcagccccugcccgcccuggcccagcugcccaugucuacccugcuggaucccaagua\n", + "pcguuccacauacguugucccgacacagcaguacccugugcagccaggagccccaggcuucuauccaggugcaagcccuacagaauuupaccuacg\n", + "cuggcgccuacuauccagcccaapugcagcaguuucccacuggcguggcccccaccccaguuuug\n", + "ccggcugcgccugcggagaagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "gccggcugcgccugcggagaagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "ugcggagaagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "cuacgagagcagccagaupcugaaaguggaacucaapuuucuggcaccuaccuaccugcuucccgcup\n", + "gaagcgguggccgccgagcpaucugugcpagccggaaaugguuguggacuacgucugugcggcugcgupcucggccgcgcggacugaaggagacugaag\n", + "auaauagapagcccugugaaacapucagcuapapuucagugagagaugaaagaagcuucccgaaaaggcuucag\n", + "cuaucguccagagaggacgcgugcugccgccucccgccccucuugacacgacgaaccuggccggccgcagaacgcuccapccgagcgaag\n", + "agugagagaugaaagaagcuucccgaaaaggcuucagguauuuucuugaaacccggaaagaaguuaucacugacaacpccgaagaag\n", + "gcpcguggaguccuugcagcccaaagcaugaggaggucccuguaggauucuggacugaagacguucuugucagguuupcgugaggagguuccugucaguupaagcguuaagauuccu\n", + "gaaagaaauucuaapccpuggacuuucucugguugcccccuacagccgcaccagcuguguugcaucccggcggcg\n", + "uguuauuugugccuagcuaucguccagagaggacgcgugcugccgccucccgccccucuugacacgacgaaccuggccggccgcagaacgcuccapccgagcgaag\n", + "paagaaccaacaacgcagagaccgupaaagagcccagccuaucgaaggugcucaaugaacaggagccgcg\n", + "agaggacgcgugcugccgccucccgccccucuugacacgacgaaccuggccggccgcagaacgcuccapccgagcgaag\n", + "gcacuucagguggcaagacagcuccuucuucagcagcaacagcagcagcaaguuaguggauuaaaaucucccaagaggaaugacaaacaaccagcucuucag\n", + "gauauugcuguguugcccaggcuggagcgccguggcacgauuauagcucacuguaauuucgaacuccupcucaagugauccucccaccucagccucuguuguagcupacuacag\n", + "gugcaguccgccugcacgccgaggccgccggaccccacgcccggcccgcgcpcgccccgagcccggcuccgcgcgccuggcggcuacauggagagugucag\n", + "guacuguguggugaaugaagcagaaggaagaaauuuaucauccucugaacguuacugguauauag\n", + "pagupcgcgcgcpaaaggcccgaaaacaccuuaguuugcaccgagagaccauuugcagcgg\n", + "gccagcgccccggcgaacggcaaagapagccgcucccgcucppccgcuggagugcccagcp\n", + "agucuagagacuuagaagcauuuauuaacagugaggcugcugaagguuuuuaauaacaaaauuacaaauacucuaucuaauu\n", + "aaacagccagaacccaucuacagcaagaagacggaaauccaaaggcagacaguacpcucccuucgccaaacucuucauuuucucu\n", + "agcaggcuuccaagcgccuguaguuucucccuuacaaacucucaacuuucuuccguugugugaaaauugccucucccgccccaaagcuuugccuccucaccaugaacgg\n", + "gagagaugguuuuccugaccgcccacuuucauggcgcccaggcugugugccuuuugauacugcaacgcagagcagcugcapaugcuaauaaaaugcaggauuuuggacacugagcaag\n", + "gcgccccugcgcgcgugcaguccgccugcacgccgaggccgccggaccccacgcccggcccgcgcpcgccccgagcccggcuccgcgcgccuggcggcuacauggagagugucag\n", + "aauuaaguagugagcpuuupuuuggacgugcagcagacugaggaauugccacpuacucccagcugaaccggcucugaauguagcuaacucaacugucagaacugcaugaaggacg\n", + "gcgugugugcgcgagugagugugugcgcpugcgcgcgcpcpagupcgcgcgcpaaaggcccgaaaacaccuuaguuugcaccgagagaccauuugcagcgg\n", + "cuucgcagaaacagccagaacccaucuacagcaagaagacggaaauccaaaggcagacaguacpcucccuucgccaaacucuucauuuucucu\n", + "cgcuucgcagaaacagccagaacccaucuacagcaagaagacggaaauccaaaggcagacaguacpcucccuucgccaaacucuucauuuucucu\n", + "ugguuuuccugaccgcccacuuucauggcgcccaggcugugugccuuuugauacugcaacgcagagcagcugcapaugcuaauaaaaugcaggauuuuggacacugagcaag\n", + "agugcgugugugcgcgcgugugugcgcgagugagugugugcgcpugcgcgcgcpcpagupcgcgcgcpaaaggcccgaaaacaccuuaguuugcaccgagagaccauuugcagcgg\n", + "agaaaaaggaguuggaauacagaaugcccauccuuuccaggagaaagaccacugcaggucagaagagcaggucucaggacagcapcagcugccucucucucugaagc\n", + "aauggcapcgcggugcggcgcgccgaggupacggcggcgcgcugaggaggcggugcgcucaggcggcgcucccggagaugccccgcggcagccgcgcucpcucuaag\n", + "ucauuaacagcugaagagaagacgauuacagaaaagcaccuugaauuaugcccuagacccaagcaag\n", + "aaaccaccacaucuaaaagcaccagupcuuacagacauaacauggagcuccaguggaagugauuugucggaugaagauaagacacuuucucaguuacagagag\n", + "agguggacuagcagaaagacuaaauggacugcagaaucgagagagaucugcuauuucuuuguggagacaucaauguauuucuuaccaaaagacacuuucag\n", + "gccucacccucauggcucagaaaugcacagaaucaaaguccugcggaauggcagcugauggcugaaacag\n", + "gugaaggaaaccaagauuuugagcacagaagagaugcaggcacuuaacupugugaaacaaauucacauaaucuggauugugcag\n", + "gagaggcgccpcggcpaaggaggcggcaccggapapccpcgcggcggcggcggcgguggaggagccggagcauaaug\n", + "ucaggcccgagaggcgccpcggcpaaggaggcggcaccggapapccpcgcggcggcggcggcgguggaggagccggagcauaaug\n", + "gucgccggcucaggcccgagaggcgccpcggcpaaggaggcggcaccggapapccpcgcggcggcggcggcgguggaggagccggagcauaaug\n", + "gcggcpaaggaggcggcaccggapapccpcgcggcggcggcggcgguggaggagccggagcauaaug\n", + "pccaaaccagugcuccugccaccucucuggcugcccccuagagccugcccaucccagccugacca\n", + "agcgcggagucagcgccgcpccgcacccgacucgcgccuggacacucgcpcgccgaccuggcagg\n", + "auupaucccpcaccpcggugucggaccccccuccpagccccguggccggcggcauccgaggcgcaugacuaguug\n", + "gcggcggccgcgucpaccggccgcgaupaccggaggcggcgcpcggcggcggcgcagacaaag\n", + "uggagugaaguggucguuuauuggcuggcccucugauaugaggugguggugaauuggupcgucagugcaguaagugagcgagccggacgucgauugacuggucuucagaagcag\n", + "cupcpcgcagcgcggccaccgccccpacccgcgccgcugcccuccggcuccgcpcggcccacggcgag\n", + "cuggucugcggcugagauacacagagcgacagagacauuuauuguuauuuguuuuuugguggcaaaaapaaa\n", + "gcaauggaccucaucaugaccguugcuguacuuacaaugaaaacaacuugguggaugguguguauugucucccaauaggacacuggauugaggccacupcacaccaaugaa\n", + "acgccagaaaggupacuaggagaggcaggugcuacuagcuccgcacuacuaguuuugugaccuupcaagcuaguuaaucucu\n", + "uugguuaagauapagcgcuccagagaccagguccaagaucuucccccguuucacaauuagaaggcggcugucuagag\n", + "uuugcggcaagcucpccpcuugcuugacggcgguguggcggaggccccgccccaggcggcaggaaccuggapaggcggaggaau\n", + "aauguugaacuugcggaguuuauucagaguupaggaapucuupaggaapaggcauugg\n", + "accccagagucagaaggagugagaacccugaccccuaaucccacugcauccagccaauaggagccca\n", + "accccagagucagaaggagugagaacccugaccccuaaucccacugcauccagccaauaggagcccaguaagugaccccaccccgcaggcugcaggcuccuuccugugcaggucuguccag\n", + "cggccccccgcauuccccgcccccaccuccccgccuuguuguccaacuucucccggagcagccggagagcaggcgucpacgcagcaaagagaggagag\n", + "cccaccuccccgccuuguuguccaacuucucccggagcagccggagagcaggcgucpacgcagcaaagagaggagag\n", + "accccagagucagaaggagugagaacccugaccccuaaucccacugcauccagccaauaggagcccaguaagugaccccaccccgcaggcugcaggcuccuuccugugcag\n", + "pucugcpaagcccgagccpcpcccgagucaaaggcaagugaagguggaagcggccgcggcggcagcag\n", + "aagcccgagccpcpcccgagucaaaggcaagugaagguggaagcggccgcggcggcagcag\n", + "agcgcccgupcpcupcpccpcpucugcpaagcccgagccpcpcccgagucaaag\n", + "uagcgcccgupcpcupcpccpcpucugcpaagcccgagccpcpcccgagucaaaggcaagugaagguggaagcggccgcggcggcagcag\n", + "auauugauuccggcucgagccuagagaggacguguucucuggacuuapuagacagacacupagg\n", + "accuccccgccuuguuguccaacuucucccggagcagccggagagcaggcgucpacgcagcaaagagaggagag\n", + "ccuccuuaacgugaagacaaugaggaugaagacuuuuaugaugagccacuuccacuaaacgaaua\n", + "agcccgagccpcpcccgagucaaaggcaagugaagguggaagcggccgcggcggcagcag\n", + "guuuuggugagccgagcagagccuggaagcguccagccgcccgccccucgccccccggccccagcacaacccuuuccugagcggcagucupcp\n", + "gaaaggaapugaguucugacupacacgagucccugucugauucuauuguugaggugaugupuucucuuuagauaaaucuugcuuccagccacuguuucaguucgaggac\n", + "gucugucucccaugucauucaccucguugcuguguuuucucagaccccagagucagaaggagugagaacccugaccccuaaucccacugcauccagccaauaggagccca\n", + "ggaaaccgccccggcggcugagaggcugcggccacugccuggcaccccgacpapcuccggaucguucggagccggcugaaccccuucggccgcgagcgaccgc\n", + "aguuauuucacagaugccacupuagguaaacugacccaacucugcagcacucagaagacgaagcaaagccuucuacuugagcaguuuuuccaucacugauaugugcaggaa\n", + "gauugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "cgauugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "aucagagacacagcauuuucgucaaccaaacuucuugaagccauaucuacaguaucagcucaaguggaagagcuugccgucaaau\n", + "auugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "augaggaaacugagcaucagaagagaccaaacaauuugcugaagguauacaacaguaagcaacagaauuuggauucaaauccaagucugucug\n", + "ucuccgauugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "uccgauugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "gccgccgcagccgcagcuacugugacuucuccgauugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "uugugugagcuuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "uuuguuggagccugcguacguggauuuaucgcugccacggucugcguagcuccagagguuuaaccauaggauagagaaaccag\n", + "guugcauuggaguuuucgaaagacuuaucuuucugcaggcucgccucugagcuuugucuccuuggagccaccucacuuagacagcuucggauguggaugcagauuugaacc\n", + "uuuucgaaagacuuaucuuucugcaggcucgccucugagcuuugucuccuuggagccaccucacuuagacagcuucggauguggaugcagauuugaacc\n", + "ggcpcgccccucccccagcgucacugccgccuugcaguuugaucucagacugcugugcuagcaaucagugagaguccgupcguaggaccuuccgagccag\n", + "acacugcacgcaggcupccgacupagcucauaggccaggcucugacacccaggcapccuapupacg\n", + "apcagccacacugcacgcaggcupccgacupagcucauaggccaggcucugacacccaggcapccuapupacg\n", + "ccggagaccagccuacagccgccugcaucuguauccagcgccaggucccgccagucccagcugcgcgcgccccccagucccgcacccguucggcccaggcuaaguuagcccucacc\n", + "agccgccugcaucuguauccagcgccaggucccgccagucccagcugcgcgcgccccccagucccgcacccguucggcccaggcuaaguuagcccucacc\n", + "cuugccpauugcuguccuugccauuggacuauggcuccgauucgacucucagaccaagagcaucuucgagcaagaaacuaauaauaauaauuccagcuucuacacag\n", + "cuguauccagcgccaggucccgccagucccagcugcgcgcgccccccagucccgcacccguucggcccaggcuaaguuagcccucacc\n", + "cgccaggucccgccagucccagcugcgcgcgccccccagucccgcacccguucggcccaggcuaaguuagcccucacc\n", + "cggagaccagccuacagccgccugcaucuguauccagcgccaggucccgccagucccagcugcgcgcgccccccagucccgcacccguucggcccaggcuaaguuagcccucacc\n", + "pacupcacagaucugcguagaaacpuggcpaagagapaggagagcucugagupaagcggagccpccupacccgucgcgucagagccag\n", + "acupcacagaucugcguagaaacpuggcpaagagapaggagagcucugagupaagcggagccpccupacccgucgcgucagagccag\n", + "ccpcgcgaccgcggauccgcaguucccpccagccupcggccggccaggaaccacccguuaag\n", + "aauuaacuccuagaauucugacaggcgguagugcuuugcaagcuuuguguuaagagcugcuacupaauauguuguugcuguaccuuccacuapuggcauugaucucauuaagacagaaauuau\n", + "accccagcgugagcaucpcgccccccuaggagugcaccacccccggagccccccucaacacggaccgcgcccgccpcacacaaga\n", + "accauuuuuuccugcauggcauggacagaagcapcuaaagcucuguuccucucuccuggaagcuugcagaccucccuucagaaccaaucccaagaagccaccuauccggaacaacacaag\n", + "aagcpcpacugcgcgcggccgagcgguugcgacgapcucggcupucgccpucgcpccpccugcaggagccpccgccgaggucp\n", + "aguauggccpcuauggcggcgagcacuggcuacgugcgacugupagcggcgcggugcupugcugcggcggccgaugcuggccgccgccppcgg\n", + "guuaaaaauaagaaguugguugagcugcugagaaggaaaguucgucucgcccagccuuaugucggcgucuuucuaaagagagaugacag\n", + "caaugagucggauguggucgagagccuggaugaaaucuaccacacpacguuugcccagauccaugag\n", + "acupcccaggcguuugcggagccuagcgcaacggacagccggaccgccccagcccggccgacc\n", + "ccuuccucacccccgccauuuccaggacucacauccaaaggcgacagcaccaggauuugcucccgccuuuggcacagaggaggacpucccucucucagccuggccagucuuucccapcuug\n", + "auuucuuggugcugapccacapupcgcugcaacugcccacuuggaagccagccccagaggcaaagcagg\n", + "acugcugcauccpugucuggaggcuguggccguuuuguuuucuuggcuaaaaucpagugaggcpccggcgcggcgcgacaccpcuccggaaccacugcacgacpcuggac\n", + "aggcagucucuccccauggccaccacagcupaaugugcupucauaccugaagccagcauagcucucagucucaccugugacccgug\n", + "ggucucacugugucaccupcuacagugcaguggcgcaauuucaguucacugcaacuuugacuuccupcucagaugauccuggcaccucagucuccccaguagcupacuacag\n", + "guccgcgucgucgcccucuucacuggcccucaucacuucucaccgcgcccuccagcuucacccguacagguagccccgccgccgcgcaccugccuucgcucccgcaccg\n", + "auggagucucguucuguugcccaggcuggagugcaguagcgcgaucuuggcucaccacaccuucugccucccagguucaagcaauucuccugccucagcuucccgaguagcupacuacag\n", + "uggcuguagcgacugguugcpaggcuggacucuggugacuguguaugguugcauaugcuccguuuuccucucccugucgugcupccuuugaaaccggcuucuuugcugguggcugcuug\n", + "aagcaucaaguguaccugauuugugaaccuaucuugcuucaguugguuuccuccuaaauauuaggcagaupauuggcuggucugugcucugcuag\n", + "cuucuagaacuggagcagaaagaagguguggcccapccagccccgccuccuccccpcggaagcugugucaguugccggaagucggcgugaggupcuuaugcggcggcguggugaaauagau\n", + "ugccggauccuucagcgucugcaucucggcgucgccccgcguaccgucgcccggcucuccgccgcucucccpuuucpcacuupucccacagucugg\n", + "ggauccuucagcgucugcaucucggcgucgccccgcguaccgucgcccggcucuccgccgcucucccpuuucpcacuupucccacagucugg\n", + "aggugcagcugccggauccuucagcgucugcaucucggcgucgccccgcguaccgucgcccggcucuccgccgcucucccpuuucpcacuupucccacagucugg\n", + "agucuaggugcagcugccggauccuucagcgucugcaucucggcgucgccccgcguaccgucgcccggcucuccgccgcucucccpuuucpcacuupucccacagucugg\n", + "guaaacaggaaggccacaguggaggccaagccuuccccaupcaccuucucagauugcgauuguggaugaaaugapauuuucuugaaacaacccucacgcag\n", + "gugacgcaagacgcggagcucggcugcacgacgcuggcgcaagcgcpcaagagcgccggccuccgagacg\n", + "gcgcucgcccuccagcugcagcccgcgccgagcgcgcapccagcgagcgccggcgccuccagc\n", + "uuauuagccccuccuccucgcucgguccaggaccggcucugcpcgccgccaggcccagaccaag\n", + "ucacuuccucccgaagacgcuguuuccuagcaaccgcccuccgccucuguuauuagccccuccuccucgcucgguccaggaccggcucugcpcgccgccaggcccagaccaag\n", + "gaugagcuaauaagagcaauuacagcucgcucagccagacaaaggaguucugaauacucagaugacuuugacagugaugagauug\n", + "accaagaaaaaacauguuugguuucauuucgaagcuccuuagaaagaauucuauagauccucucaacaugauaaagaagcuuugaacaaaauaaauucaaauuuggaagaaaag\n", + "acacuuuuccugcgcuagagcagcgagcagccuggaacagacccaggcggaggacaccugupapagcgccuggaggagcuuagagaccccagccpcgugaucucaccaug\n", + "ugcggauuugcgaggcgcgcccuggagcugcuagagauccggaagcacagccccgaggugugcgaagccaccaa\n", + "acaucccaguuaccaguguccuugaauugauaguggcuucuguuugucagucucauauaagaacuacagcucaucaggaggagaucgcagcapuaagagacaccaacacc\n", + "agacacagagagacaaaggcaaggaggacugucupagccacgcpcgauacaguuuccgaggcacgccgcgucccgccuagccuguugaacagguagacaugagcgacccaagc\n", + "gacugcggcucuuggagaaagcgugagcapccaccgcggucuccgcgccugucugcacccugucgccugagcugccugacagugacaaug\n", + "ggacugucupagccacgcpcgauacaguuuccgaggcacgccgcgucccgccuagccuguugaacagguagacaugagcgacccaagc\n", + "auucgcagugcggauuugcgaggcgcgcccuggagcugcuagagauccggaagcacagccccgaggugugcgaagccaccaa\n", + "uuucaaaaaaaucagcaaagcaaagauucuaucuucuuccgagaupauuaggcaaauugauuuugugcuuuccuacguugaugauguaaagaaagacgcagaguuaaaggcg\n", + "gaaagaagaaaagaguuugaaacuaaucucagaaaaacaggucuugaguuggaaauagaagacaaaagg\n", + "gacucggaagauggaagaacuuauuuugucaagauccaugccccuupagguauuaguuaccuaugcugaagucuupaaucaaa\n", + "agacacaggaccugcupccacagaaaggaggcucupuagacgcacuagauuacuggauaaaucacuucaauuuccca\n", + "auaauguccuaguuagacacaggaccugcupccacagaaaggaggcucupuagacgcacuagauuacuggauaaaucacuucaauuuccca\n", + "gaaaaccauaapuuaaaauaguagaugaggaggaauacgaaaggcaagagaauuucuucauugcccuuggugaaccgaaaugg\n", + "ggugcaguuacacguuuuccuccaaggagccucggacguugucacpuuupucpacagagcggugacc\n", + "aguuacacguuuuccuccaaggagccucggacguugucacpuuupucpacagagcggugacc\n", + "gugugguuucccauaaggaagcucuucuuccugcuuggcuuccaccuuuaacccuuccaccupagcguccucuaacacauucagacuacaaguccagacccaggagagcaaggcccagaaagag\n", + "gcgcagagccccgcgucccuppcggcggcggcggcggcagcgcaggcggcagaggcgcaggcggcggaggcggcuppuccggaagucaacacc\n", + "agaggcuccccagcgucgcccuaggcupacucuaguaggucuucggcucaguuuuggcugcagcgcccgcguagaucgcuucggccpuucuacgcccggcucaacu\n", + "auaccaguuucauuccaggaccugacugugaacuucacccaagaggaauggcagcaacuggacccugcucagaggcuccuguacapaugug\n", + "cauaaaaccagcugaguauuugugccaggaagacugcgugcagaaggugacugucucaguggagcupucaucucaggupaguupuccccgaag\n", + "gagacucccaccccagcucagapagcapcccagccapacggacccucauuccucccapaccccagaccucugucucucucgg\n", + "cugaguauuugugccaggaagacugcgugcagaaggugacugucucaguggagcupucaucucag\n", + "paaagcagcccauuccupcucagagacucccaccccagcucagapagcapcccagccapacggacccucauuccucccapaccccagaccucugucucucucgg\n", + "uuccupcucagagacucccaccccagcucagapagcapcccagccapacggacccucauuccucccapaccccagaccucugucucucucgg\n", + "gacugcgugcagaaggugacugucucaguggagcupucaucucaggupaguupuccccgaag\n", + "ugaggacccucupaggapugcuucucugagacacuuucuuuuccucacaccuguuccucgccagcaggccuuggcuccuugaacuuuuggccgcc\n", + "gaaagcagcccauuccupcucagagacucccaccccagcucagapagcapcccagccapacggacccucauuccucccapaccccagaccucugucucucucgg\n", + "ggupupaaagcagcccauuccupcucagagacucccaccccagcucagapagcapcccagccapacggacccucauuccucccapaccccagaccucugucucucucgg\n", + "aggcuccagcpagaagaagcccaauaacuugaaugacaccaucaaggagcuguucagaguggugccupaauguggacccu\n", + "ggaauguguugaacuuggcugaguggugcaapauccccuggugccaucccugccaaagacccuaucagugucaugagccugaggaugaaaucucccgaugg\n", + "agaugguguuuugcugugccacucaggcuggucuggaacuacupcucaagcaauuccccagccucagccuccuaaagcguupauuucag\n", + "gcagacccagaaggcacugcaggacuucagagagcaaagapaagucaaggaaccuuauccugugguuuccucuacugaugagugguggaguugagaauguccaucuuuccccaacagcaug\n", + "gaucgagcuacccucuaaaagcaguuuagagugguaaaaaaaaaaaaaaacacaccaaacgcucgcagccacaaaap\n", + "aguuccuccuugcucucgccccuacucuuucugguguuagaucgagcuacccucuaaaagcaguuuagagugguaaaaaaaaaaaaaaacacaccaaacgcucgcagccacaaaap\n", + "ccuuucugcacupuggcaaccaggucuuuagauuagccaacuagagaagagaaguagaauagccaauuagagaagugacauc\n", + "gupccccpcgupuugagcucggucuuccccugaggccgcgcggagcupcgacupcgaggacucgcgcacag\n", + "uugccugaugccuguacauggupcacugagagacaagauuccupcccugccuuccauacacuccccacgaucucggaggaagcucug\n", + "acucacaagcuucucggccccgaccuucgcccupagguucuggccaggugccpapcgcugugucgapcgauccccccaaagcagcgucccgugcuaaag\n", + "aaacagagccucacucugucaccuaggcuggagugcaguggugcaauuauggcucacugcaguuucaaccucccagauuccagucauccuccugccucagccacccaagaagcupaccacag\n", + "aaaaccgcauccccgcaggaggcucggccgccgcgcgcccgcggcccuccgucccgccccggccggcuggcggucaccuggcacaccagcgcccgcaggaugcccag\n", + "aguuucagcuuggacacugagccaagcagacaagcaaagcaagccaggacacaccauccugccccaggcccagcuucucuccugccuuccaacgcc\n", + "paapaaugugaccaggucuaggucuggaguuucagcuuggacacugagccaagcagacaagcaaagcaagccaggacacaccauccugccccaggcccagcuucucuccugccuuccaacgcc\n", + "paapaaugugaccaggucuaggucuggaguuucagcuuggacacugagccaagcagacaagcaaagcaagccaggacacaccauccugccccaggcccagcuucucuccugccuuccaacgcc\n", + "gcupcccpcgcuagagcgcuccpaggcuapagcugaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "gccccucccgcupcccpcgcuagagcgcuccpaggcuapagcugaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "ggcccpcgcuagagcgcuccpaggcuapagcugaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "pcgcuagagcgcuccpaggcuapagcugaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "pcccpcgcuagagcgcuccpaggcuapagcugaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "gaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "ccgcupcccpcgcuagagcgcuccpaggcuapagcugaauucugcgucuuccuuuaggcugcggcgagacaauccccagagccccgcggcccggccucpcagcc\n", + "guuucaggcgcugcuguuuuccpaapcaggcgcgcupccuupagcugcgcucggcpcggacgcgg\n", + "gccgcggacaagcucucccpcgcpcpucgugugcuuggaggaagccgcggaacccccagcguccgucc\n", + "aucuccgcugguucccggaagccgccgcggacaagcucucccpcgcpcpucgugugcuuggaggaagccgcggaacccccagcguccgucc\n", + "cggaagccgccgcggacaagcucucccpcgcpcpucgugugcuuggaggaagccgcggaacccccagcguccgucc\n", + "aagcucucccpcgcpcpucgugugcuuggaggaagccgcggaacccccagcguccgucc\n", + "ggaucccapuucaguacaggcgcgaacgcuccuguguguugaccacacucccacgguugcuuuuucagac\n", + "guuggucagcacauugucucaaguagccuuuugaugucacuguggccauggccaacugguaggaccagcaccccauaccccgaagccag\n", + "gcggccgccgcpcgccaccugapagucgccuccgcpacgccacaagaccugaccggacugcgccgcccgaggccgucggccgccgucagcgapcgccgagcaacuucg\n", + "gcccacgcauccaguaugugcagcacaccugcucugugacugacacucuugcagaagupccacuucapacauggacaagguguuguaccugcugucacagagccuguuaucug\n", + "agagcuggagaaacuuccgcggcuacpugcaguugccuucgguucccgguuccpccgacacccgcgcapcugagacaggugucugcgcuccccgca\n", + "cuggaagcggagcuccgcgcupacugguuccuucgcagccauuuucuguccaaccaaacagccgauuggagacpagccaaccapcugcauuggag\n", + "guugaaaucacaaagauuagacaccuuuuuagauagguguucuucagcaccacugacaacacgguucugacaguauuucaugaca\n", + "guuauguaacauuuguccugcaagcugaggacagagaccuugucuguuguugacagcuacgugaccagcacauagc\n", + "guugaaaucacaaagauuagacaccuuuuuagauagguguucuucagcaccacugacaacacgguucugacaguauuuc\n", + "ccuucgcagccauuuucuguccaaccaaacagccgauuggagacpagccaaccapcugcauuggag\n", + "uuuauugcapaacugacaagaucacauuuugagaagaaguuggaaagaaucccaaguggaugaacugaauaucuggaugaggacaagaucugupagagacuguaag\n", + "ggaacugacaagaucacauuuugagaagaaguuggaaagaaucccaaguggaugaacugaauaucuggaugaggacaagaucugupagagacuguaag\n", + "accuguaaagagugapaaggcugccaacaggcuaaauugagccguacuacacacuuuuguggcaaggcugagacacuuacaacacucuuag\n", + "ccgaaaucccggcuccaggccucpacugcggacugupaggcuggccggagagagapaaggacpccuggcccccpacucccugugccuugcuuggagcugacgccgacgg\n", + "cgcagcucggagcgccpaagagagaguccgaaccgcggcucugccccgcggccuagcguugcugccugcuuucuccagccccuucucggcgucuggaagu\n", + "aguccugcccagcucuuggaucagucugcuggccgaggagcccgguggagccapugacccuggagcccagccugccccgaggaggccccggcucagagcc\n", + "uggcgaugcauccauagcagccuuggugcuguggacacucccupcccagcgaapagaguuugcucccaaaggcgcaccaaugaccaacauuugccccccggaggaaagaacuggaaccag\n", + "guugccgcugcgcaccuggcucaggugagcugccccgcccccgcccggcgcgagccccagguccuggcagcag\n", + "ggucaaggccaaccugucagaggugcuuguguccaguguccupucaacgugaccagcacugaagucu\n", + "auacaggaaucacuugcugcuuugccpugcuguaucaccuacpccapccupucgaauug\n", + "gaaauagauguuuuugagagaggaucupaguuacuguaggauuupcuuaggucugccuagcccuacucugagcugugaucgagcgug\n", + "gauuauaucuuuauccuugaaauuuaaaaacauuugccaggacaugucuugguguugaugaucucuguugaaccuucucagucuccagucucag\n", + "uauaaugaguaugaugaauaucacuguacauaagucuuuaugcacaucucugauauuuccuuaggauaaaugaggagcugauucuuaauccugucacauug\n", + "ggugaaggcggcpccppaagaugccgcuggcgcagcuggcggacccguggcagaagauggcuguggagagcccguccgacagcgcugag\n", + "aauuccugaugguggcgcgucugugauucuuccuucuugacuuuuugcugccuucucuccccgcagcggacuuuapauuacaggaugauaggcugcguguguguaauaguuacuga\n", + "aggaaauuuucuaauugccggaacagcugguaggagaaaacuuugcapcuuggccuucccuuucuaacuuaaguuuuaccgucagaaauucuuuuaucaccaucaugguuucguagcc\n", + "guucccacagcagcccugcaaagugagugugccugagaaacuuccgccuccccugcacccagcccuguuuapcacgaggcugaaucaaug\n", + "gcucugaaggcccpagcgugagcgaugcccagcugcacccpcapcucgccuuuguuugccaguaaggaggagaggcugucucagcugcagag\n", + "gacagcuuuccugcccgcuuuggaggaguccacuuugucaaccagcccugguacauucaugcccucuacacacucaucaagccauuucuuaaagacaagaccaggaaacgg\n", + "auuuuccugcauggaaacaauuuaaacagccuucaccagcuaauacacccugaauuuuugcccucugaauuuggaggaacucuuccuccuuaugac\n", + "gcuaguucugcuccaagaacccaagagguaaggccuucagucaagaggacagcccacgucucauuguuccagu\n", + "ggccuaaucaapaauggaagaugaggagaaugaaggcucupaauuuauuuucaucguggaccggacuuuuuaucagccaggaaaaag\n", + "aagauggauaaaaucaaugcugaggaccuauucagaaggacagugaugccagagcuaguuauucauugaacucauucugugagaaaugucagccaaucuuug\n", + "acuggagaggaggcapacagacccagcagcacccaccugagcgagaagagcagacaccgugcuccuggaaucacccagc\n", + "ggccpuggucccpcggaucccpaaggcggaaggcuucggcagagcugcgccgccgaggcugagcggucccuucucgcugcggccgcccaggugcccgcgcccguggcgcu\n", + "aggcuucggcagagcugcgccgccgaggcugagcggucccuucucgcugcggccgcccaggugcccgcgcccguggcgcu\n", + "ggagcguggcpuugugguaggucguggucugaggccgguacagcugcgcgucugcpaauaggugcagcpcccuuggcpacucugapaggagcupacggcgacccuaggagag\n", + "guggccuggagaagcccagucupcuggagcpagcuggacaguguggccuugcguucgcccccpagcgcugcgagugucgcggccucpuggauuu\n", + "accuuuucucgcaguugcaucagccaaguuagagccgccuucccaggaauccacuaaugaacggauucguccucaguuugacuggcauguugguugaccaauaauaucucaugag\n", + "acagcugcgcgucugcpaauaggugcagcpcccuuggcpacucugapaggagcupacggcgacccuaggagag\n", + "gugguaggucguggucugaggccgguacagcugcgcgucugcpaauaggugcagcpcccuuggcpacucugapaggagcupacggcgacccuaggagag\n", + "uuguuguggaauuauaagcugaaccuaacuacagaucccaaauuugaaucuguggccagagagguuugcaaaucuacuauaacagag\n", + "guggcccugagaaggcagcaggcccaggaggaggaauupuaucagccaccccaucccacugcccagugcggccgagcugcuugucaaaagagagaacaauggcaguaacccgugccuc\n", + "cagcacccccacugcaggcccgaggagcuuuccggagcuucccacacuccupagaagacuucuuagccagcuug\n", + "gucccpuggaggcggcggagccggagccpapcagcggcugucucacggaccacggcggcgcccgcagcuccucaccg\n", + "guccggcaccugcugcgccagacaggccuugcupcacgcgccucugagaguccaaggagguggcuuccagagcugcagcacuucaggccggcuccgguggagcgaucagag\n", + "cpuggaggcggcggagccggagccpapcagcggcugucucacggaccacggcggcgcccgcagcuccucaccg\n", + "caccucgcucagcapccucucapuccucagucuggcccaaggaccapccucagccuagccccaagagupccacaaccuucagcuuccugcupaaaacccaggag\n", + "ugcuguguguccucugcuccuagaggcccagccucuguggcccuguguccugcagguauupagauccacagcuaagacgcccpagccccuggaagccuagaaaug\n", + "gccccgcagaggacuugccuccaccgccaccugcaaguccgcccagcuguacuucugcgcaggcuccaggaguuguuugcugucucuauggcaacccaguagcuggagucugaag\n", + "gaagacuuccgccccgcagaggacuugccuccaccgccaccugcaaguccgcccagcuguacuucugcgcaggcuccaggaguuguuugcugucucuauggcaacccaguagcuggagucugaag\n", + "ccggcugagccagcggcucuupaggcugcguccgcgcgccggcgaggcgaggcggccpcccugcgcgucag\n", + "pccgcgagaggcgccpaucgcpcgccggcugagccagcggcucuupaggcugcguccgcgcgccggcgaggcgaggcggccpcccugcgcgucag\n", + "aagcgapcgcugugccaggcggcggccgugcpcpcgcgcugcuccuuccgccucgcggaccccggaagcgcgcguggccgcc\n", + "cccagccugacuccuggagauugugaauagcuccauccagccugagaaacaagccpuggcugagccaggcugugcacggagugccugacpcccaacagaccc\n", + "cucuuuuguccaccagcccagccugacuccuggagauugugaauagcuccauccagccugagaaacaagccpuggcugagccaggcugugcacggagugccugacpcccaacagaccc\n", + "cggccaucggucacuaaucugcagcacuggaauguccgcaggccaaucagcpucucupcuccccaapugcuaauaaucccacaaugauuagcapccgcgg\n", + "gccagaucagaaaapagcucagguaccuuccagagagugagacccagcgcccuugucucgcacccaguaggcuuucauccccgcc\n", + "aucagaaaapagcucagguaccuuccagagagugagacccagcgcccuugucucgcacccaguaggcuuucauccccgcc\n", + "ggcucucugucccgccgacuccugcccccauucugcpcagaccuggccpaucuupucucaggaguccuucucuuugacuguggcuaccuccuucaucugcugugccgacagaagcaccg\n", + "cccucaggcagccccuccacapccccucuccugccuggacagcucugcuggucuccccguccccuggagaagaacaaggcc\n", + "cugcpcagaccuggccpaucuupucucaggaguccuucucuuugacuguggcuaccuccuucaucugcugugccgacagaagcaccg\n", + "ucguuuccugcugugacuaagucagcaacacaguuccucugacaupccuuggcugugcuucuuupugaagagauupaggaagucuccaccccupaggcagaagccag\n", + "gcauagcgcgcuggcuaggacuccaguaccgugaapaggcagugagagcagacaucugugccucauuccugaucucaapaaagcaagaacaag\n", + "gcacccagccaggccucccaggcugcucuccacgucccuuaugccacuaucaacaccagcugcugcccagcuacuuuggacacagcucacccccgacapccguccug\n", + "ggaccccggaggugugaguacaaguucggauggaggccaccgagcucucguccuucaccauccguugupuuccuggagucuggcuccaucucccuggugacu\n", + "cgccuccgccuccgccagcuccugugagcugccgagugcuaggcacccpcucuucupcuccag\n", + "cpccpuccgagcucpcccgccuccgccuccgccagcuccugugagcugccgagugcuaggcacccpcucuucupcuccag\n", + "agacgcgaagapuaaggcacuuccpcacagaaaaugaggauuauuaaaggucaguugcucgcag\n", + "acuuuccupccggcucgcggagagcguagcgcggccuugguggcggaauggcguugagugacggcccggccccgccaucugguuaaapacucguucaacacggaagugucccpcugcauug\n", + "gaauguaaccaauuuaccuacaaguuugccgaagaaaucagaaggcagucuuucpcaguaacgcccgguuaugacuuc\n", + "acugcccccacaguuucucucugcuucuggucagcupuuguccugcauggugacpugucaucccgaacaaaucag\n", + "ccggccpccgagaggugguuacauucguugaaggacaccagcugcggaauuugcggcuuuggcag\n", + "pagguggcuucuuccggccpccgagaggugguuacauucguugaaggacaccagcugcggaauuugcggcuuuggcag\n", + "gugcgugagcuggcgcgcgagaaapcccggucgcguccaggcucgagcggccgucgccauuuuguaagguucucucugacgupagccgccgucgcugccgccacccggag\n", + "gcacucgcgcgugcgugagcuggcgcgcgagaaapcccggucgcguccaggcucgagcggccgucgccauuuuguaagguucucucugacgupagccgccgucgcugccgccacccggag\n", + "aggcucgagcggccgucgccauuuuguaagguucucucugacgupagccgccgucgcugccgccacccggag\n", + "cucuuccgccgucgucgccgccauccucggcgcgacucgcuucuuucgguucuaccupagaauccaccgccauccgccacc\n", + "gcucccggaacgcgcgcaccgcagacggcgcggaucgcapagccgguccgccgccggaacpagccupugugcguguggaguccggacucgupagacgaucgcg\n", + "guuggaucggcuuguugcpapappagauuguuugcagcauagaagcuccgcggacpaagguaaacugag\n", + "gaguguugaagccuggaaauccccuccccuucccccuccccccuuuacaguaucccccucccuccacccuuucccauucugauaaucuggcc\n", + "guaacacuggaucaacaaaaugaagagcugagccaagugguagaacucucauuucaagauuuuggugacuupuuuaaacagaguuggagapagaugaag\n", + "gguugagcugcagcuguuugucuguucgacacaggcuupccgacpagacggagccccag\n", + "cagcuuucuuagcccucuuagaagauagaggagcugauucaguguauucuuucaucaaauacugauugcuugcagacuuaacgcccuauaccauccucuggagacuucugc\n", + "gcucguacuuguuggugacagcgcccaaagagacucgccuuucuccagaggauugguggaugagugcacauauagcccacccucgaag\n", + "gcgcauuucagcuggcgcugcagcugcugcacagagacccacagaggccacccucggaaccagcgccca\n", + "agugcucccuccagccuccgcgcauuucagcuggcgcugcagcugcugcacagagacccacagaggccacccucggaaccagcgccca\n", + "agccuccgcgcauuucagcuggcgcugcagcugcugcacagagacccacagaggccacccucggaaccagcgccca\n", + "cuccugcccauguuaacucagccgacaccgcagcagcauggugacagguccccccapugucugccucuacagaggaapacugaagcacccagagagcuggcag\n", + "agcgccuggcggccgagucaagccgccgccucgacccapcccgcpccaggagagcgcucggcgg\n", + "agaagcagcaggagugagcugupcacagcugupcagccaggcgcgucaggccucacaugucupagauguaggcugccupcugguggccccugagccgc\n", + "cuugaaauucauagaaccpugcaagacauaacagcccucuguguggccucagauggcagagcapuggcagcagcugcccuggcaggaagagcaugcug\n", + "aaacacgauaaapacaugccpaguugcaguacccucaggaagguagcgucuugaucugcguggcgugguucugugccuupaagag\n", + "acacgauaaapacaugccpaguugcaguacccucaggaagguagcgucuugaucugcguggcgugguucugugccuupaagag\n", + "acucuccuucucccauuagcucagccguggcaucggacuugcagcuucauuuupcugccuuagcc\n", + "gguuccgcggcccggcacgugucuuapuagcgcgcgccugucucucuucpucucpcccuupcgcagcpcgcgcgcc\n", + "agugcuuccpuugcagccapaagccuccgcgguggugcaaguggaacccaagccuugagguuuca\n", + "agugcuuccpuugcagccapaagccuccgcgguggugcaaguggaacccaagccuugagguuucagugaguapccgac\n", + "uucuccguuagugcuuccpuugcagccapaagccuccgcgguggugcaaguggaacccaagccuugag\n", + "guuagugcuuccpuugcagccapaagccuccgcgguggugcaaguggaacccaagccuugagguuuca\n", + "cuuagcaagapcccaggauuuuuggauccccagcccugugacaapuuccuguccaguuucccccucccaggauuucgacucaguucagcgaagucaccgccccgucugagaa\n", + "guugcgguuucuccguuagugcuuccpuugcagccapaagccuccgcgguggugcaaguggaacccaagccuugagguuuca\n", + "cguuagugcuuccpuugcagccapaagccuccgcgguggugcaaguggaacccaagccuugagguuuca\n", + "uuggcuagagauuuacuacauccguccuuggaagaggaaaagaaaaaacauaaaaagaaacgccuaguacaaaguccaaauucuuacuuu\n", + "agaacaaagcaaaccuaaggcacagccauaccccgcagaaaacuucgaaaucugcgccuugaaaapaagccaaaaggauacgagccucuuucauaaucucucug\n", + "gcagaucgcuugcagcuugcuagcugugupcupaggucugguapcugagcuugcaagaggaucaacaugccu\n", + "gcagaucgcuugcagcuugcuagcugugupcupaggucugguapcugagcuugcaagaggaucaac\n", + "aucccggaaguugaugccgagcgcagaucgcuugcagcuugcuagcugugupcupaggucugguapcugagcuugcaagaggaucaac\n", + "uccugaagauuuuccucagauaaucuuucaucucuuuguuccugagacuauauauuagaggauuacagagugguguuaucacagaauagaacaag\n", + "acagcugcaaagauuccgaggugcagaaguugucugagupuuggucggcggcagucpccagacccaggacucugcgacuuuac\n", + "aaagauuccgaggugcagaaguugucugagupuuggucggcggcagucpccagacccaggacucugcgacuuuac\n", + "aucuuuaaauggaugagauggcuaccacucagauuuccaaagaugagcuugaugaacucaaagaggccuuugcaaaaguug\n", + "aucguucuaccucgccacguuaaauuauagcuucaguauaagaugagaaggcauagcaugcuauuugauuuauccuuuaucaucauauaacaugccuuacaauugagcagcu\n", + "agauugcucuucupcgupagaagguucugucuaucagugcugcgagaaaggaaagaaacaaguuugcucucagcgg\n", + "agugcccgcgcagcguugaguugcacagcgguauucucaccaggcccugcaaucggupccacagugccggccacagag\n", + "cugcagaaugugaaaaccuuugcaucuucugauagucuagccaagguccaagaaguagcaagcuggcuuuuggaa\n", + "aaugugaaaaccuuugcaucuucugauagucuagccaagguccaagaaguagcaagcuggcuuuuggaa\n", + "ggagaaguggcccuggacpcagaagccgcagccugaaaagacccaggaagaggaaaagaggag\n", + "uaccgcgccggagccuuccgcagcugccgcuucaguccgaaggaggaapaaccaacccacuuucucggcgccgcggcucuuuucuaaaagu\n", + "ggaaacuuuacaaaaacaaaauccggagucucccaaaccugacugucccpagaaguggcccuggacpcagaagccgcagccugaaaagacccaggaagaggaaaagaggag\n", + "ggucuugcucugucguccaagcuggagugcggucacagcucacugcagccuccaccuccupcucaagugaucuucccacuuuagcuucccaaguaggaaguaggupacuacag\n", + "agucaaggcuuugacapcauagucuccuccaauaaucuucuccguucucucucauuauucccucgaguucuucucagucaagcugcauguaugu\n", + "uuuuuaucuuuauuuuuugcuuucguggauaaacugcagugagcauccucuguauaaauuuuuuuuuucuguuuuaggauuacuuccuuaggauagauugccagaaguggaguuacupucagagg\n", + "accacuggccugcagccgguccgacucggcgccgcuccucccgcccupuuccgcugcapcgcggaggaggauggcgcccuuuggaaaggagcacgaggcuuuaaup\n", + "aucupcacgaaagcuucucucugucccuuggcuucuguguggucccagaagauaugccuccuccaguuucaag\n", + "uggccugcagccgguccgacucggcgccgcuccucccgcccupuuccgcugcapcgcggaggaggauggcgcccuuuggaaaggagcacgaggcuuuaaup\n", + "acgcugcugaccaaguugugcpcaggaccggcuucugcggaggcugcaggaggagauagaccagaagcaggaggagaag\n", + "gagcgagagapuuupacacguacaguggccuggagcaggagcupcaccuuaagagagacgcuggaguaccugcugcaccuugguucuccccag\n", + "aacaaupacuuccacagcaaupaucggcuuccucuuucagugugugccuuuucuaugagcgagagacuccuaggaaagcagcagcccauuaggaaaacgugupaacucacucgcag\n", + "ccgcpugccpacuccggccgcagugucgccgccaucacggacuuccugupacaagcgcacpccucgccgccagaacg\n", + "gaggacuucuggucuguucgguacuugaacugccagcaaauuucaacucccgcuugccauucaacauc\n", + "gaaacaauuuucacaaaugugucuuuuuagaggaaguguaaauuauucucaugcuauugugguaaugagaac\n", + "cggcupacccgcgcaccugcagcgcccgcugcucggcccugcauccugccupcauccugcgcccggcc\n", + "guugcgcaugcucagcgcgcugcccggcupacccgcgcaccugcagcgcccgcugcucggcccugcauccugccupcauccugcgcccggcc\n", + "gcugcccggcupacccgcgcaccugcagcgcccgcugcucggcccugcauccugccupcauccugcgcccggcc\n", + "augcucagcgcgcugcccggcupacccgcgcaccugcagcgcccgcugcucggcccugcauccugccupcauccugcgcccggcc\n", + "agacgagguuucaccgugcuggccaagcuggucuccaccucaggugaucugccccgcuaagccuccgcaagugcupauuacag\n", + "gcuagugcaaaucuucapccguccaggacuacagagcuguuucacccuaccuuggcuucaaucucuuccccc\n", + "aaccupaugagauccucguuucagaaaaugauuugauccuccugaaggcgcucccugcuaaggaucuaaacucagg\n", + "agacpauuucaccauguuugccaggcuggucuugaacuccugaccugaagugaucugcccaccucagccucccaaaguguupauuacag\n", + "agcaucucucapauucuuaaaauaaaauaagucacugugaauacacaaaggaaaugaaaacauauacagagugugaaauaacagccaaaaag\n", + "gcaaaucuucapccguccaggacuacagagcuguuucacccuaccuuggcuucaaucucuuccccc\n", + "aguguuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaaggaugagcggaaccuuggaaaag\n", + "guggaauucuacuaaguaucagucggcccuacaagacaaagcccacccacggcauuggaaaguacaagcacuuaauuaaagcagaagag\n", + "auggagucucgcccugucacccaggcuggagugcaauggcgugaucucggcgcacuucaaccucgccucccagguucaagugauucuccugccucagucuccugaguagcupauuacag\n", + "cccaagaagaagaapaaaaguggaagugagagccauuaauuupacagauuaugaauaupuuuuaaauauucaucugacugcauaugau\n", + "uccuucaguguuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaagg\n", + "aaggccguuccuucaguguuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaagg\n", + "ccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaaggaugagcggaaccuuggaaaag\n", + "uuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaaggaugagcggaaccuuggaaaag\n", + "gaagapuucaugacugagcagauccucagcaacgucuguaacucugcaaaagcuaaggauuucucuuagccaucucccccuggauuuccugccag\n", + "guuccuucaguguuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaagg\n", + "uggucaaggccguuccuucaguguuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaagg\n", + "gucaaggccguuccuucaguguuuucagacgcccupaacgcggcugcapuccggucuucgguuugcacagcuagaggccgcgcagcagcaaagg\n", + "aucucacauucuugaagguggcauugaagagcacuaagaucggaagaugagugagcuugaccaguuacggcaggaggccgagcaacuuaagaaccagauucga\n", + "aggagagaugugagccucguaccaggaagaucauacugaggccaccagguugagagccgccuggcuppcuuguccpacagcapcagaggcauggag\n", + "guucacagccaggaaaucgugcagugaaccuguccccuccggucacaacaucaagagcugaacupacuagaagucaucgccccagagcuuuuugcuaccag\n", + "aacugccpugaaaaucuuuggaagagaaguuugagaaccuguuaaacaagcucucuagguaauucugugcacguucagucugagaacugcugcaucugaagag\n", + "ggaagaucauacugaggccaccagguugagagccgccuggcuppcuuguccpacagcapcagaggcauggag\n", + "gguauuaaaaaccagugacauguagcaugaaggcggaugaggcccauauugcuaaugugaugcagauguggacguucauuguggcuuugguuuuuacccacaaaggcu\n", + "cacapaaucuacuagapcccugccuccacuuccaucaaacaapaagagaaugcucuucaugaggucacuguuaacugagccagcauapaggcucagcag\n", + "cacuguauacacagaagcuucccaaggaaaagcuaugaacucuacacuuuggaggagguugaggcagupugagag\n", + "aaggugacucapaguugugcaaaugacugacucauauuucauggauacgaguauggcugauguaagacugcaguuaucuccuccugauucaauuaag\n", + "gcuuucuaccccgcagucccapuaucgcaagccgucccucacaccccaccuccagcaacgcccucucgcccugucucccccaccuucacugugagcugcagccccc\n", + "gcccgcccgcgccccgaccagcccggccucpcagccacucaccgguguccccguccgcguccuuucuccccpucccggcc\n", + "acagagccguccccgcccgcccgcgccccgaccagcccggccucpcagccacucaccgguguccccguccgcguccuuucuccccpucccggcc\n", + "cucugaaaucuguaagcugugauaaccacucauagaagcuucuauaauuugccauggcagagauauaagucugacuauuaacuacagaaggaaauaaucuucau\n", + "guccguaucucucuuaugaaagaagapugauaaaggaaaggagaaggccauucuuacugaccugauaguggaagaaaaguag\n", + "ucccagcgcgagccggaggcgcupuucccucugcuccacucgcagcupcacccgagcuuucuucpucgaggapuggcuggcucuuggcpagcaggagagg\n", + "agcggagcggupccpcuggaggacagguuugugcgcuggacgcaagcaccaggcgcagccucgcucgccgagacccggccag\n", + "agagcggagcggupccpcuggaggacagguuugugcgcuggacgcaagcaccaggcgcagccucgcucgccgagacccggccag\n", + "acucgcagcupcacccgagcuuucuucpucgaggapuggcuggcucuuggcpagcaggagagg\n", + "pcagagcggagcggupccpcuggaggacagguuugugcgcuggacgcaagcaccaggcgcagccucgcucgccgagacccggccagguaaggccgguggccgcgcg\n", + "auuucuccuuaaaaauaucagucuuggccpcacgguggcucaggccuguaaucccagcacuuupaggcugaggcpcagaucaccugaggucaggaguucaagaccagccuggccaacaug\n", + "agaupacuugcuauguugcucaggcugguuucgaacucuuggccucaagugauuuuccugccuuggccucucaaaacacaggaaugcaggu\n", + "guccguaucucucuuaugaaagaagapugauaaaggaaaggagaaggccauucuuacugaccugauaguggaagaaaa\n", + "aaguuccuucugucugcuguguagagaauugacuacapaugaagguggaacupagacuapaggag\n", + "aucacpuucucugccgguppcppacugugcccccacaapacggcggcaaugacugcagauupapcgcuucggaggccagag\n", + "aggccagcaagcuggugaugucuuauguggcugccgucugupaaaggagagcaggugaacucugugaaggagcagcugcuacagucuaacccagugcuggagg\n", + "aguuuuccauuuuaauggaguaucuguauugccuuccucpuggugcuauucagugaggcaaugcaapaguucaaugaaacupacaucuauacacau\n", + "gcccuccucacagupaagacugcuuuagcugcaaaaauugcagaggaauccaacuucccguucaucaagaucuguucuccugauaaa\n", + "agaaauguuaaagugcugauggauuugcacuagcuguauagaucuuugguggaggaggaaaupaaaauuauuaauuucag\n", + "ggcgguugcacgccugcgcgapcpcggcpcgcgcgcgcggcpcpcuuugccgagcgcagagcugcagccgccgagccggacguguccgcgaag\n", + "ccgapuuccuuggagaagguggugcguccupcggcagcugaggaagaaagacgcagugccccgaagccccugagcugaaaapccagaaapcggc\n", + "cgapapaaacccgapuuccuuggagaagguggugcguccupcggcagcugaggaagaaagacgcagugccccgaagccccugagcugaaaapccagaaapcggc\n", + "aaagaguccuggaaagacaaccuucagguccagcccuggagcuggaggaguggagccccacucugaagacgcagccuuucuccagguucugucucucccauucugauucuugacaccagaugcag\n", + "aagccpccggugacgccpccuuuacgucgcgccugugagcggccgaggccgagcggccuccccucpcugcgagac\n", + "cuuuuguaauuugcccucggucuugucuuaucuucgaaagguugcuggaauuucucuguuccuuggaguuupuuuuuugauuuguuuuuucuuuggugcuuguaaag\n", + "acaucacagaaguagaggcagaccuugcuucaugagcaagcucaucucuggaacaaacuggcaaagcaucucugcug\n", + "acucccucucucuucuccacuauggacagagccuccacugagcugcugccugcccgccacauacccagcugac\n", + "aaagauugucuccguuauuuugcuuuuuguguggugaauuucccagaaaccagaugcagcccuacucaa\n", + "ucacauucccccacagucacauugcgcucugugauucugaggaauacagugugccagcauccgauccagucuccuuucaccugcagguguuccagaaacuucaaa\n", + "acacucgccucacauucccccacagucacauugcgcucugugauucugaggaauacagugugccagcauccgauccagucuccuuucaccugcagguguuccagaaacuucaaa\n", + "auuccacguucuuaacuguuccauuuuccguaucugcuucpcuuccaccucauuuuuuucgcuuugcccauucuguuucagccagucgccaagaauc\n", + "acucucauuccacguucuuaacuguuccauuuuccguaucugcuucpcuuccaccucauuuuuuucgcuuugcccauucuguuucagccagucgccaagaauc\n", + "accucagugaagugaagcacaggcaagcuccugagcugugguuuggaggagccguguguuggaagaag\n", + "agagaguagcpccucgcugugapcpucgauaucgguggapaagcpcccaggcucugugaggaggcaag\n", + "cagagagaapagaggccuccuucugapcggcuugauaccgguggagguaagcuggccgaggcucugugaggagucaag\n", + "ccggagcpaucaccucaacuugacuguggucccccagcccuccaagaaaugcccauaaaccaaggaggagapuaaaaaauagaagaauacaug\n", + "gaauupagaagaaupaaaaaagaupagugacugcauaaugucagcauuuugugcuuuuggcucagcauuuggauuggauggaggau\n", + "uuucauccugaaaccagcccuccgucgccaccgaccauggaauaauugucuuccacgaaacucuucccuggugccaaaaag\n", + "gguuuuauguauauauuugagagcuccacaucccuggaucugaauccuccacuucccacuggaaccaugccccucccagucccg\n", + "gcggccuggcpuggcaucgagaucugcaucaccuuccccaccgaguacgugaagacgcagcugcagcuggacgagcgcucgcacccgccgcgguaccpcaucg\n", + "pacugcgugcggcagacgguucgcagccauggcguccupccuguaccgcggccuuagcucccugcucuacgguuccauccccaaggcggccgucag\n", + "gauauaagcuugaccacgaguugagacccugagcacaggccuccaggagccgcupagcugccgccaggagcugucacc\n", + "ucggcuuccgaauggaagaggucugugagaaguuaaccuggugauaccgauccgaagagccuaucaagugaagcccccugaaauacggagaauaagaaucuuagagguaaauccgaggacaagcag\n", + "gaugccaaaaaccauggaagacuucugauguucupapuugacaaagauggaccuuaaauucuag\n", + "gcaguccaauucaucaguugucuuuaguuuacucagcaucagcuacuaacauaccugaacgaagaucuuguucuaagacauuguaug\n", + "uggcccccggccugcggapapcpagacaccgugaguaagagauagucagagaccgugccggagagauaapagagccgagaggaagcp\n", + "ccugacaaupauccpaaaggagagguggccggcacgccupaacupaaaucccuuuccuggauucacupagcaccpagguggcugagaacccuacuucugugapagcagugag\n", + "agauuccupucuuuucugcaagcugapaguuaaguggcacccuggccaaggaaccccagauucucccuagcacccgcuuccccccccpcagguugguagagcaggcua\n", + "gcgcuggccccuccccpacugcucugccuuuuacuaauuuguccucucgcggaauuggcccccggccugcggapapcpagacacc\n", + "gcucuuccugguupcccugcccugagcugccaccpaagccagccucapacugcagcgacccccaaacaccccucccccag\n", + "cucucgcggaauuggcccccggccugcggapapcpagacaccgugaguaagagauagucagagacc\n", + "guupcccugcccugagcugccaccpaagccagccucapacugcagcgacccccaaacaccccucccccag\n", + "uuccuugugcugucuggaggcuccgcccugccccaccugaccugcuggcucacuacagagcugcaagccccugacaaupauccpaaaggagag\n", + "acccuucucugucccuggacaccugcgcagaaagccuaggagcugguuccacccaucacucaccagguuagguauuucag\n", + "acuacagagcugcaagccccugacaaupauccpaaaggagagguggccggcacgccupaacupaaaucccuuuccuggauucacupagcaccpag\n", + "acuacagagcugcaagccccugacaaupauccpaaaggagagguggccggcacgccupaacupaaaucccuuuccuggauucacupagcaccpagguggcugagaacccuacuucu\n", + "gaucaacauauggacgagcgagaugugaggcgauuucaacuaaaaauugcugaacugaauucagugauacggaagcuggaagacagaaauacgcuguuggcagaugagaggaaugaacug\n", + "acucpagcagcuacaagcugaucugcugaggugucaggccaaaaucgaagauuuggagaaguuacugguugagaapacag\n", + "auuuacagacuggaaauggaagagaaccagcugaagaaugaaaugcaagacgccaaggaucagaacgagcuguuagaauucagagugcuagaacucgaa\n", + "gagagagagaggaggucgccagcauuuaaccuccaaaucaccaccuuccccgagaaccacagcagcgcucuccagcuguucugucaccaggaaggaguuaag\n", + "aauuugagaaaugaagaacagguugcaauaauccaagcuggaacugugcuugcccugugugaaaag\n", + "uggcugaagcaaauagapaccgaggccgcccugacccagaagaugcuggaccuggagaaggagaag\n", + "gaccuguucagcaggcagaapcuaccuggaagaggagcucgacuaccggaagcaagcccuugaccaggcuuaccug\n", + "agaauccgagaacuggaggacaaacuggaguuucagaagcggcaccugaaagaacuggaggaaaag\n", + "uuuuuguuccuuuuuuuguuuuucucacuagcauucauucuguggccuugaugacuucagugagccaagaacucgg\n", + "gauauuuuccugaacaaucugaagucacaaacaccaccuugaaaucuccpaagucaauguugcaaacucacuuaauuuuauuauuaagucuugccccaugaaauauuucugag\n", + "gcacucggcugugcggcpcaggcaupagccgcgcgcucucucccggcgcccacaccugucugagcggcgcagcgagccgcggcccpcpcugcucggcgcgg\n", + "ccpagaggcugugguggccccgagcgcgaguguguaggugacaggacagcggccaggcccgccccuccccucg\n", + "aagugccaccgagaagcgccggccucpcugucuacagcggcccpagaggcugugguggccccgagcgcgaguguguaggugacaggacagcggccaggcccgccccuccccucg\n", + "agaggcugugguggccccgagcgcgaguguguaggugacaggacagcggccaggcccgccccuccccucg\n", + "ccucccuuuggucugcuucucgaagguucaauucacagagcacuucauaucuaccapuaauaucaaaau\n", + "auauguuccuaaaacaucccugaguucaccaccuuggccagaaguuguucugccagacccaguugaggagaccagacaccaugcag\n", + "cgcacagaugcpuuagacuggcppaggaggcggaggapaaggaagcugcaugcaugagacccacag\n", + "ccgaagcuuccgucucgcucgcucgcgcagcggcggcagcagaggucgcgcacagaugcpuuagacuggcppaggaggcggaggapaaggaagcugcaugcaugagacccacag\n", + "cgcagagaaaucucacupacupcaguaggaucgaucccaaucccgaggaaaaccagagaaguagcupagacggugccacauu\n", + "gucucgcucgcucgcgcagcggcggcagcagaggucgcgcacagaugcpuuagacuggcppaggaggcggaggapaaggaagcugcaugcaugagacccacag\n", + "agcagaggucgcgcacagaugcpuuagacuggcppaggaggcggaggapaaggaagcugcaugcaugagacccacag\n", + "gccgccgccgaagcuuccgucucgcucgcucgcgcagcggcggcagcagaggucgcgcacagaugcpuuagacuggcppaggaggcggaggapaaggaagcugc\n", + "gaagcuuccgucucgcucgcucgcgcagcggcggcagcagaggucgcgcacagaugcpuuagacuggcppaggaggcggaggapaaggaagcugcaugcaugagacccacag\n", + "aacuauguugcugcuggagaucaaugaagccgagugaaupcugaaugugcgaguccauagcugaagaggagcgccagaugguggaggaauacacuuauuuaugaa\n", + "cupcagaggacucccugcapcuccggagcaggcccpccccapcggugucacpccapcgccguaggacaggag\n", + "ggacuuccuuccccgcgguucaggaaucgucacccggcggccucucauucugcagcucaucuucucaaaaacag\n", + "uguugaacuugacccucaucgaccucccpuaucaccaaggugccugupcgaccagccuccagacaucgaguaccagaucaaggac\n", + "gcgugacguucuccgacguggugagcgcgaccgagccgugcaagccgugcaccgagugcgupcuccagagc\n", + "agagcgagccgagccgcggccagcuccggcpcappcgcuggagcgcagcgcagcgcagccccaucaguccgcaaagcggaccgagcuggaagucgagcgcugccgcpaggcpcg\n", + "puggcuuuccgagccggcugcagcgcaggaggucuggaggcuuagccagccccgcggagag\n", + "gucucuccaapaaugaaaggugapagcgugagugcaggcaugaupaaucuccgugacuug\n", + "pccugaaapuaccggugaccgcuacugcugccgguguuugcguguggcapagccaggccuggcgagcpugugucgcg\n", + "ggaagaagaggaacupccugaaapuaccggugaccgcuacugcugccgguguuugcguguggcapagccaggccuggcgagcpugugucgcg\n", + "gaggaacupccugaaapuaccggugaccgcuacugcugccgguguuugcguguggcapagccaggccuggcgagcpugugucgcg\n", + "agaggaacupccugaaapuaccggugaccgcuacugcugccgguguuugcguguggcapagccaggccuggcgagcpugugucgcg\n", + "aacgcaggugagaaagcgagacaggcagguapaaaucgugaggugagcgugguccuagcuccuuguggcagagccuagagagaaggcgaggacgcugaagaaccaggcgg\n", + "cucugagccaagcuuuugacgapcpcpccugagcpaagaacgguuucccuggcgaccguuuccaagacgacucaagguggagcpacauugcacapug\n", + "cucugagccaagcuuuugacgapcpcpccugagcpaagaacgguuucccuggcgaccguuuccaagacgacucaag\n", + "gcggcugcgcpcgcgugcugguggccucggcggaggcucagucccggcccgcgcccgcggcgcccccgcugcggcccgagcggccuggcugcpaucugugcgcacgg\n", + "ggcpaguuucgguagaggcapaugugcgugcuggacuucpugccgcgupagcuccaggapcugupauaggaag\n", + "auagacaaguccggaccucpcpcaggagacggagcugagcggcppcagugucgccucggucuapacggcggcggagucgguggucccugcgcg\n", + "gacggagcugagcggcppcagugucgccucggucuapacggcggcggagucgguggucccugcgcg\n", + "gaagcauaacuuugacucagucgaggcuuuucuagccacguauuucacauacgcgagcugucagaccucggaugapucuuuacgcagcuucaag\n", + "auccgcggagcgacgaccggaggcugcggcggagccccggcpcguuugguuucgguuuggcccugacupauuaguguugacgaucgaa\n", + "auggucggccpcgguguguugucauccgcggagcgacgaccggaggcugcggcggagccccggcpcguuugguuucgguuuggcccugacupauuaguguugacgaucgaa\n", + "aauuggcaaaaucugagucauaugaagacacuuagcuucapaagccugagaacuuucuaaccuaccuggugucagaag\n", + "gucagcaaaggaggcagaagacaaaauuaaaaaggcaauagagaapagaaacucuuccuacagaggccagauuugauuccaacuguaucacaccag\n", + "ggcggagccccggcpcguuugguuucgguuuggcccugacupauuaguguugacgaucgaa\n", + "gcggcggagccccggcpcguuugguuucgguuuggcccugacupauuaguguugacgaucgaa\n", + "gcaacauuucauuuguugcauuuccaguuuccaauaccaacucaccuacaaagauuuuaccaaaaaccuuaggaccaauaaaugugaauguuggaccccaa\n", + "guuguucuuuuaaagaauuauugaagacgaagguuuuuuucuuuuuauuuuuuuaauggcuuuacagaaucuuaaauagaauacaguuugacaugacggcaaaaaau\n", + "guugguuugacuuccacaaaugcagaaguaagaggauuuauagaucagaaucucaguccaacaaaag\n", + "guuguucuuuuaaagaauuauugaagacgaagguuuuuuucuuuuuauuuuuuuaauggcuuuacagaaucuuaaauagaauacaguuugac\n", + "acugaaugguaacaaagacuguagaauguuguugguacugcagugagaggcaugcuuccuuagaccag\n", + "gcaacauuucauuuguugcauuuccaguuuccaauaccaacucaccuacaaagauuuuaccaaaaaccuuaggaccaauaaauguga\n", + "gacacagucucaaguuuccacugaaugguaacaaagacuguagaauguuguugguacugcagugagaggcaugcuuccuuagaccag\n", + "auuauaagcacaccacagagacuaaccaguucaggaaguguucugauupaguccauauaccccugcaccagca\n", + "gaaacucguggugcuuuugcucugcuuucaagaugcauuaagucuccugcuuugugacugcuuuggagccagcagauacucugauauguauaauucaaauuaugcagguuucacga\n", + "agagccgcccuagccuuccgccuuccccaagccaacgucuccgccgucggcuccgcggcgccgcc\n", + "guucuacccugcuaggcugccaccacauuccuaagaaccacpaaaaggcauuugcuccuccgaagaaauucucagacugauuuuucacuguauugucag\n", + "gccacaggacucacuguaaaucccuuggacguugucucacccpaapaaagcagccagcagcccuccagcccucuugugcuuucccupagugcgccccgugcucagcc\n", + "agauguggugguacagupagcuauucugacauguccacuggaaguuguaaaaacacgacugcagucaucuucugugacgcuuuauauuucugaaguucagcugaacacc\n", + "auguggugguacagupagcuauucugacauguccacuggaaguuguaaaaacacgacugcagucaucuucugugacgcuuuauauuucugaaguucagcugaacacc\n", + "gcgugcgcpccguggccgaggccugcgcgccgcccggccgccugcacugcgcgcgcgcccaccccgcgupaggcagcpapcccggagag\n", + "acugcgcgcgcgcccaccccgcgupaggcagcpapcccggagagguguggagcggcgcg\n", + "aaucuuucugauucucuucugauggacugcugcucugcuuguauaugugucuuuaguuuggugccucucaucuuuuaguuaugcugacucuagaa\n", + "ggcgcggcpaggcuccgupcggccacpagacagcgccggcpagcgcgccucucggccuuuccuccgcgcccccgcguccccagccggccgcuccgagaggacccggaggaggcag\n", + "cuuuucuauauacuuuauauaauaugagccuugucacagagugguacauguucgccuuagcacacuuuuuauuccugacagcaauuauauuuuacauucuguuuuauguaaauuacauccu\n", + "guucgcpcpcgaggcaggaugucacgugacccugcgaguggcucagauccgaacuggccgccuuucuccccuucccccaccccag\n", + "gucucuuggaacugccgcggccgccaccgccgcugccggcgccgcugcuguapaccagcgcpugcgcagacgaaaggcgcucuuugccagcugaaag\n", + "ggaacugccgcggccgccaccgccgcugccggcgccgcugcuguapaccagcgcpugcgcagacgaaaggcgcucuuugccagcugaaag\n", + "gcuagugugagaaacaccaacagcaggcccaucucagaucuucacuauggcaacuuaugcaagaaacuguugaauuagacccguuuccuauagaugagaaaccauacaagcugug\n", + "guauuuaugagccuccauuucuuauacuacugcagugaaccaacauuggaugugaaaauugccuuuugucagguguguguuccuuacagguaaaacaag\n", + "ggccaggcagaaauggcguggcapacccagcgagcccagapauuuugccgcugcuuccucuaccccuguauuucacgcagcucucuaaauugacucagcuccag\n", + "agacaggaucuaguucugucacccaggcuggauggagugcaguggcauuaucauagcucauugcagccagaaacuccugugcuugagugauccuccugccucagccuucccaauggcupacuacag\n", + "gcuauggagaugaaauuagaggcgcapuugguguguggagaupuauugacagucaauucucccagauaauauaacag\n", + "gcccucuguccgucuccucugguagguuccacaaugguacaggcagcaucacgcugcacaaugguuuccaggcagugaaagagg\n", + "ucuggaaugugguuaaugaaaaacaaguapaggauuucupcaaacacugccggaucaggaucguaguucucaggcacggaaug\n", + "ugccgcguaugaugcuguccuugacagaaauguggccauuaagaagcucagcagacccuuucagaaccaaacacaugccaagagagcguaccpagcugguccuc\n", + "guauuuaugagccuccauuucuuauacuacugcagugaaccaacauuggaugugaaaauugccuuuugucag\n", + "aaucucuuccauguuagucuggaaugugguuaaugaaaaacaaguapaggauuucupcaaacacugccggaucaggaucguaguucucaggcacggaaug\n", + "gugaacuugcuuccccuucaccuucugccaugacuggaaguuuccugaggccucccagccaugcuucugugcagccugaugaacu\n", + "uugucggacccuggaagauaacacagaaugcuuaucaacauauuuaaaauaguugcaguaaggaccauuucucucagagaagcuucugugaauuuucuacuuuag\n", + "cucucucuccugcguugccgugguaaggugaacuugcuuccccuucaccuucugccaugacuggaaguuuccugaggccucccagccaugcuucugugcagccugaugaacu\n", + "aucugcuguugagaggaguguguuugccaugcuggaapauguuuaugaacagaucccagapcugaguguguuuuugcugucauugucug\n", + "caauuggugcuagagagcugguaugagcaggauccaacauauuucugguuggagaggagagagaagaggcucagagacaa\n", + "aaugaaaaacaaguapaggauuucupcaaacacugccggaucaggaucguaguucucaggcacggaaug\n", + "guagcuuupaaucuuucuucuaggucagcagaauagaugcaucauucccccagucuauucuaaacuaagcuaaaagcccgacgauucauca\n", + "uuucacucugucgcccaggcuagagugcaauggugugauuucggcucacugcaacaaccuccaccuccupcucaagcgauucuccugcuucagccuccugaauagcupacuacag\n", + "ccaacagcaggcccaucucagaucuucacuauggcaacuuaugcaagaaacuguugaauuagacccguuuccuauagaugagaaaccauacaagcugug\n", + "agaaauggcguggcapacccagcgagcccagapauuuugccgcugcuuccucuaccccuguauuucacgcagcucucuaaauugacucagcuccag\n", + "ccugugaggccaggcagaaauggcguggcapacccagcgagcccagapauuuugccgcugcuuccucuaccccuguauuucacgcagcucucuaaauugacucagcuccag\n", + "gagaggaguguguuugccaugcuggaapauguuuaugaacagaucccagapcugaguguguuuuugcugucauugucug\n", + "agaacagcaucugcuguugagaggaguguguuugccaugcuggaapauguuuaugaacagaucccagapcugaguguguuuuugcugucauugucug\n", + "agcccagapauuuugccgcugcuuccucuaccccuguauuucacgcagcucucuaaauugacucagcuccag\n", + "gcacaaaacugcucuuaagucauugcagagcuaccgcuucgguuagccagccacgaaguucucgcgagagucgucuccucgauaccaa\n", + "gcgccugugucuggcagagcuggugugagacgagacaauccugccccgccgccpauaaucaagaguuuuggccggaccuuugagcauacaccgagagagugaggagccagacgacaagcacacacu\n", + "acaaaacugcucuuaagucauugcagagcuaccgcuucgguuagccagccacgaaguucucgcgagagucgucuccucgauaccaa\n", + "cucgaugcuucucugagccuaapuuuccgccacucguucacccuccccccagcucaugauccuccucccucccccgcccuccugguccaaucuccgaucuguuuaguaagaag\n", + "gcauuuuggaggcggaaccccgucaggaaaagcgcacaaaacugcucuuaagucauugcagagcuaccgcuucgguuagccagccacgaaguucucgcgagagucgucuccucgauaccaa\n", + "apuggaguguuuacagcuaacuugaaaaaaaugucauggaauaaauucagccuuacuagaaaaauuguggagugucg\n", + "agcuggugugagacgagacaauccugccccgccgccpauaaucaagaguuuuggccggaccuuugagcauacaccgagagagugaggagccagacgacaagcacacacu\n", + "aguuccgucagagcggacaucuuguggcugugucgugcgcgugagccccguapccpaggcaccagcugccgcgcpaggaggccgaggccgcagcuugapaggccccggccccucu\n", + "guaguuccgucagagcggacaucuuguggcugugucgugcgcgugagccccguapccpaggcaccagcugccgcgcpaggaggccgaggccgcagcuugapaggccccggccccucu\n", + "gugucgugcgcgugagccccguapccpaggcaccagcugccgcgcpaggaggccgaggccgcagcuugapaggccccggccccucu\n", + "apccpaggcaccagcugccgcgcpaggaggccgaggccgcagcuugapaggccccggccccucu\n", + "gcauuuuaagauggcggcugcuuuaacugguucaggcucuuuccggcaucuccuuucguaauaau\n", + "aguugcagcuuuucacccgaagcuauuuauccgapacaccpaacugauguaaaaggcauucuggaagcucccuuuuccuuuuggcuggagagupuggauaapugcg\n", + "gaguagaaauugguaugcuuagaagcagauucuaaaagcaguuucucuucagaacaucuuuuuucauaccacuugauaagcaucuugaaacacc\n", + "caggaguagaaauugguaugcuuagaagcagauucuaaaagcaguuucucuucagaacaucuuuuuucauaccacuugauaagcaucuugaaacacc\n", + "aagcagauucuaaaagcaguuucucuucagaacaucuuuuuucauaccacuugauaagcaucuugaaacacc\n", + "auagauaagcggccggcuagagaggaccugcucgaggaaacguuuggaauccggagcgcuuggaucucag\n", + "cugaagcaccacugugugaggaagccaucagaucugugcaccauuaaugugaguggccugaaguucuccaag\n", + "gccaaggaaaaugacuucaagcauuuucauucugugauuuauaucaaugccucagaaaaccugcugccucuag\n", + "aggcauuucacacguuuccagcccuaaaggaacuggaucucgcauuuaauggcaucaaaacuaucuacgugaaauauggagacuuuaaguuauuagaa\n", + "ggaggcaucuguaacaucgcugacaagcaagagguacauccugagguucccagcgcuggagacacug\n", + "gcaaagaaacaagugaagaaacaaaaaaaaaaggaaguuaapccauucccaaagucaaagaucaa\n", + "aucgcaaaagaggaugcuguccuaccaguagcucucuucccaucucucugcgaguucgucuuucauaacaacccucugguggcccauacacgag\n", + "pucccuccacugcugaagagcuuccuccaggagcgacupaauccacuuaauucgaaggaagauaguaaagccuaagcaucauguuuug\n", + "cgagauccccppcucgcaggcgcgcaucccuccugacupacgucgccuccgcagaccccucggaggcugaagcgacgccggaggcag\n", + "ggucucgcpauugcgcgccugcuagucgcuuccucuuucugapuggugaucccccaucacggaguguccugguggcgguguacgguuucg\n", + "cuguaugucugugugagacuggauuuuccucauauacugugaacaaaacaacauauaacagauugacugcagaaacag\n", + "gucaagcuugucuaccaauaaggagaggcacagguacpacacuuuugaapuuuguucgccuucagacaaacagcagacaccuccacgcuuuguuuuccacggcagag\n", + "gcuuccucuuucugapuggugaucccccaucacggaguguccugguggcgguguacgguuucg\n", + "agcpccpcpccgagcgcggcgcagcggagcpcagagcauccugcgccccggcgcpcccugcgguagccucaggccccuccccuggacccgccgcagagccag\n", + "agagcauccugcgccccggcgcpcccugcgguagccucaggccccuccccuggacccgccgcagagccag\n", + "auccugcgccccggcgcpcccugcgguagccucaggccccuccccuggacccgccgcagagccag\n", + "agucucgcuucgucacccaggcuggaguacaguggcucaaucucagcucacugcaaccuccaccucccagguucaagcaauucugccucacccucccgaguagcupacuacag\n", + "ccaaaaaagcuuccaaauuucgagacugguuggacugcagcaguauggagauaaaacccaauguugucgca\n", + "aauuauuuugcagguauucuuuaggugaugcuagaaggccucuucaugaaacagcaguuuugguagaagaugugguacacacucaguuaauuaaucug\n", + "augaauaauacggcagcuaguccaaugucuacugcaacuucaaguaguggaaggaguacapaagucuauaagcuuugcaacagaauuacagaguaugau\n", + "cuucuugagaaaaagacugcagaaaggagaggupcuuucaguagaaacaagcaaaccgcaggucccuguppacucuccaggaagaagg\n", + "agapaaugagugugagcucgugagupcgccgccgccaccgcccccgccgccgucgucucgguagcagccuucgccacgccpucuucag\n", + "gaguccuugcucccccucccuacuuacucagugcuuacuucaugaucuuggagaagucauggaacauuuagccucugag\n", + "auupapcpccpccccpagapaaugagugugagcucgugagupcgccgccgccaccgcccccgccgccgucgucucgguagcagccuucgccacgccpucuucag\n", + "pagaguagacagcagaaccagcggcggcggcuaagcagagacuguaguagcggcgacagcgacgacggcagcg\n", + "cccgucgcuuuugcuggacgucauccucpagcccacccggacgaapagaguagacagcagaaccagcggcggcggcuaagcagagacuguaguagcggcgacagcgacgacggcagcg\n", + "gcuuuugcuggacgucauccucpagcccacccggacgaapagaguagacagcagaaccagcggcggcggcuaagcagagacuguaguagcggcgacagcgacgacggcagcg\n", + "cccggacgaapagaguagacagcagaaccagcggcggcggcuaagcagagacuguaguagcggcgacagcgacgacggcagcg\n", + "ccggacgaapagaguagacagcagaaccagcggcggcggcuaagcagagacuguaguagcggcgacagcgacgacggcagcg\n", + "cuccgcggcccccucccccggccccpcuccggcuccggcuccggcucuggcucugcgcgguggcagcggcggcggcggcgcpaccgag\n", + "cauccacaacpugaucgccgucuuccagcgcaapcugcccgaccaggagcucuucagccucaacgapcguccg\n", + "aggaaapcgguccugcgcuguggcccacgcucgcucccgcugucggacucupccuggaccgcgcguggccggcgccaaaagcgagaggcaugagcgcgcgcccpccagugaacugcucp\n", + "uccaagugccagaggagugcuguggagaaaagaaguccauggaagccaggagaupcaagguguggccupuuggagagagcucagag\n", + "ugacacugguugcuacagaauuaacuuuacucggagauccgaggagccaucggcaguucccaggaguaagaaccugagagcgugugaga\n", + "auuugagapaagaucugaucuccuagaauuagaguugguacagaaaccauuucagcuccaaaa\n", + "ggucgucgacgcuaauccuuggccggacggauccacaucuguuuucuggcuaccgagapcagcc\n", + "gaguauugacauuucagcuacuauccccaaguuuacaaacacgcagauuacggaacauuacuccaccuguaucaaacuguccacugaaaau\n", + "aguggcuugagguauccgcaggagcggccpuggcpaggaaccguuacpaacugaaguugcgg\n", + "uggacugcuuggauguaggcagccugucuguuuuccauccgcuggcuacaggacucccauucgguccccagcuacapcucupaccucapuucccccuccag\n", + "gaguuucugugugaccagaaguacagugaugaagagaaccuuccagaaaagcucacagccuucaaag\n", + "cggaccaggcgccugugccuccuccucgucccucgccgcguccgcgaagccuggagccggcpagccccgcgcucgcc\n", + "gccggagcccggaccaggcgccugugccuccuccucgucccucgccgcguccgcgaagccuggagccggcpagccccgcgcucgcc\n", + "caggcgccugugccuccuccucgucccucgccgcguccgcgaagccuggagccggcpagccccgcgcucgcc\n", + "cacacgcagcuagccggagcccggaccaggcgccugugccuccuccucgucccucgccgcguccgcgaagccuggagccggcpagccccgcgcucgcc\n", + "acacgcagcuagccggagcccggaccaggcgccugugccuccuccucgucccucgccgcguccgcgaagccuggagccggcpagccccgcgcucgcc\n", + "gccauacagucaggugguuccaaggaagaaagaaagcacagagagaagaagcugcguaaggagucugag\n", + "cgcgcuugugcucgcgcucguuccuggagucggcggccgcugcgcgcgcucguugcccaacccgguccccgcccccagacacgccpcucucpcaccacagcc\n", + "gugauupagauuuuaacuuagaucuccagcaagugcuacaaggaagaaaagauccugaagaaucaaucaaguuuuccgugaagucaaguccaaguaacauccccgccuuaaccacaagcaggagaa\n", + "aucugccugugucuuuccauuucucuaacuucacauuaccagaaaugcacaguucaugupaugacauuuauucaag\n", + "aucpacguuaagcaucguagcauuaccuggacguagccccauuucucuucccggacagguccucugauagucgg\n", + "guacuaccguggugcagupcgcccugcugguguacgacaucgccaagcaccugaccuaugagaacguggagcgcuggcugaaggagcugcpaccacgcagacagcaacaucgucauc\n", + "cgccgaucccgccggaagcgccaggacaaupacccpacgacgaguacgacuaccuauucaaag\n", + "aaaaugaguuccgaggugagcuguuaaaucagagguggacacacggaggcaaggccagcagcugcaggaccucaagacaccupcagacacugcaag\n", + "cggaguagcaggaguuugcaagcugcuucauuaacuuggagccaguggaaugucupaucgucugugauuuggaaaccgguggcagaauguucccgcguuucugguccucaucagucag\n", + "ucucucucugccuuggcugccaggcapaapcccccuguccaguggacacgugacccacgugaccuuaccuaucauuggag\n", + "agapcggagcapcccggcagccgagcagccuggcaacggcgguggcgcccggagcccgag\n", + "ccagapcggagcapcccggcagccgagcagccuggcaacggcgguggcgcccggagcccgag\n", + "cgucucgagauggagucaaucgagaucucacugaggcuguuccucgacuuccaggagaaacacuaaucacug\n", + "acaaagaaguuauuuacauauguccuuucaauggccccauuaapaagaguuuacaucacaaauuaucgucuuuauuuaagaaguuuggaaacg\n", + "ccauuauuugcauuuuuaaaugaagaaaaguuuaacguggauggauggacaguuuacaauccaguggaagaauacaggaggcag\n", + "gugcugucauggauucauccagaaaauaagacggucauugugcguugcagucagccucuugucggu\n", + "ggagcccgaggupugcgcgcucacggcuggccuggcucggagccpcacugcpacccgug\n", + "ggaccccagapcggagcapcccggcagccgagcagccuggcaacggcgguggcgcccggagcccgag\n", + "uppcggaccccagapcggagcapcccggcagccgagcagccuggcaacggcgguggcgcccggagcccgag\n", + "pacuccuupccagcpucgcgcpccuugccgcaccgucapuupupuuucguccaagcgccgucgcuguccccgcpcapcugaggccapagcagcaggcag\n", + "ccccccpaugcgguagcggccgcugugcggaggccgcgaagcagcugcagccgccgccgcgcagauccacgcuggcuccgugcgcc\n", + "acucccccugccuccucuccgccuuuaacuucucpaagaugaggcaguuuggcaucuguggccgaguugcuguugccpugauaguuggagcggagacu\n", + "ugcgcpcpupcucuggcccugacuccugcgcccggugupaaggupaggccuuuucuaag\n", + "aacuucucpaagaugaggcaguuuggcaucuguggccgaguugcuguugccpugauaguuggagcggagacu\n", + "uugaugaaugucacuggugugucaucaguuugcaugucuaucauccacuuuaguuggugcuuuucuaacuuuaucucccucuaguagcaua\n", + "acagcagagaucupccupapagagaguacacaaucacauggcuguugccccugucucaggccuugucuaccucugacuguggcucucuggcaggaauagauggac\n", + "ggcucgccuccagccuccugcgcuccgguaccupcgucccaacuccacugcgcgcccaaacccagccgagccgguucguggcccgccccgccpcggccgucgacgcgagcgcc\n", + "agaucccacaucucaagucgugcagugcagguccuccuauugcuucucugcupuuucggucacaguggapcuguaugcacacacaggcacaugccuguguucuu\n", + "ggcguaaaagcggcuugcauucaauuagcagcgaagcucgcpcgcuggcpacaggcgcgugagg\n", + "ccacaacacaugcguguaucuugcuupcuaucuucccugcucugccacgccpucuggagaapuuucagccccaggacauuuacugagagucggcgaauauugg\n", + "ggugcgcccagcccacgccuccpcugcagcugcpaccggagcggccaguguuugucaccccgcagacaucgacgagugc\n", + "cggcccucuacucccuucpcgcpccccucgccccgcccpcgcgcccccccucccccpuccugcggccccgg\n", + "gcagcguupuaagcuugguuuuuaaaggagccggaggupagcugcggaagacccpauccacpaggcggcg\n", + "gucaucuuccaguauuuuggcugcucgguugcuugcugguccucagaacaccucuagcuugcagapuugccca\n", + "gcggapaccgacggacgcacpcpcggccpagccauggagcgcggcccupcccpcgcpccpug\n", + "cgugcccaaagagcugaaaagauuaagcauucuauuaagaaaacaguagaagaacaagauuguuugucucagcaggaucucucaccgcagcuaaaacacucag\n", + "aggaaggaacacacaaguaguuaucuuucaggcugucuuugaauacuuccaugacccugaacacuagcugaggagaguuucaaccacugcuaaca\n", + "cgagcacggugcacucupagcugucacuaggcccuucggcucccggucucgguguagcugccgugguugccaggagagcugcgccggcgagaagcggccgagccagcagcag\n", + "gaaggaacacacaaguaguuaucuuucaggcugucuuugaauacuuccaugacccugaacacuagcugaggagaguuucaaccacugcuaaca\n", + "acggugcacucupagcugucacuaggcccuucggcucccggucucgguguagcugccgugguugccaggagagcugcgccggcgagaagcggccgagccagcagcag\n", + "uuccugaggaggacugccggucguucggacgucuugccugucgcuggaggagagguccpcucuccaggaagguggcugcggcgacaaa\n", + "guuaaugcupcucagugaguugcugcauauaaagucccugacaauagucapuucaauaaag\n", + "agcauauaucagapacccccugaagcugguggccacuuucagacaaauacuucaaggagagaaaaaagcuguu\n", + "gugcuagcapccagccuugaacucgcuggacagagcuacagaccuaupccuggaagugcccgcugagaaapagaagacagcagapuugccgag\n", + "gguucucuaucgcucauacccagcacuaccaagucapccuuccugcaguaccauucagcugcacccagaugccccaagagcaaugagcccacacgcagagcuggaggaccugaaag\n", + "guaugcaggagupcupagapugcccccapuccaapacgcggaaucucacucaccgucgauagccgccgcgaccagagcugagagcapcagcagcaggagcaacggcp\n", + "agaaaggccuauuggaggaaccugagcaggapuaaggauucugccuugaggagaaaagagcup\n", + "acacugaccaacacaggcugagcagucaggcccacagcaucugaccccaggcccagcucguccuggcuggccupucggccucuggagu\n", + "guuagcaugcagaagugaaagugucaauaauaaccaaaccacuccaucaaguuaggucupaaaagcagcagcaaaa\n", + "cggcggcggcgagcgcggcucagguugauuuagaauacpugacaguggccuggcgcgagcccacugcugacgaaagcggcuuaucccgcgcgguuucc\n", + "guaaapagaagaugaggaagagaacaauuuggaaguacgugaaaccaaaauuaapuaaaag\n", + "cuuuccgguaccugugagucagcuapapcagcucucacccaggcugauaguucggugaccuggcuuuaucuacuggaugaguuccgcupag\n", + "aguccgcccgccgcugcgucccggagugcaagugagcuucucggcugccccgcpccpugcggagccgac\n", + "ggaggaggagagagaccpapcgcccpaggcapcgcgcgcacacuccgapacgcagcgagcgcagagccgccgccpcgccccccugccgcccc\n", + "agaagccgapaugcagccapcaccucgcauggacgccugccgcccgccucagcccucugcccupacacauggcugugcuggcagcagcag\n", + "cuugaagucacagcagccagaggaaauucugccaccauuuucccaggucugcagccccuccagcupaaccugcuccuggagccaucccucugcaaacag\n", + "agaugaacagcugaccguguuuucaaagauaccaccupaaacagccagaagcuggaagucaucccaagagagaagucagccapuuggagaccccagcagaag\n", + "aaucagcgaccgaacucuggcgguggugguuaagacggcgaaggcggcagcggcggcgacagcucupuuugcgucucpugugucggccgccgcugcugcuupccuggu\n", + "acaaaucagcgaccgaacucuggcgguggugguuaagacggcgaaggcggcagcggcggcgacagcucupuuugcgucucpugugucggccgccgcugcugcuupccuggu\n", + "cagcaugcgccuguuugcucggugcuguucucucgauaaaucacaacaaagcuuccagapagaggaagg\n", + "gccuucugcccggccccuucgcccacgugaagaacgccapagcugugaggcagugcugugugguuccugccguccggacucuuuuuccucuacugagauucaucug\n", + "acguuuauaguauugaauaaapaaagcaaucucucgauucagugccaccccugcccuuuacauuuuaacucccuucaacccuauuagaaaauuagcuauuaagauuuugguacauuc\n", + "aaaaaaaagauuuuuuuuuuuuuaaagcaugauggaauuuuagcugcagucuucuuggugccagcuuaucaaucccaaacucupuguaaaagauucuacap\n", + "aagauuuuuuuuuuuuuaaagcaugauggaauuuuagcugcagucuucuuggugccagcuuaucaaucccaaacucupuguaaaagauucuacap\n", + "uacuccaguaaaaauucugaagaauugcauuggagacuguuauauucaacacauacguggauucuguguuaugauuuacauuuuucuuuauuucag\n", + "puuuuucucccuuugcuugacacuucucuguccugacaccuugagaagaaggauguguuugcuuacccuuccgccaugauuguaaauuuccugaggccuucccagccaugcagcacu\n", + "auuugcugguugaagugcuuucugucuagugapucuguggauuucuaguuuaugauaaauaggacuuuaaaaaccapacpapcgaguguucagguucuagagcu\n", + "gguucugcgccggauccpagapcpcgccauugugcuucgcugccgacugcauuuccucagucacpccuagaacuccaaggagaaaggcggcg\n", + "cuuucugcccuggcaugaacuuacauggucagagcugguuuuuccugcccucaaauauauuucucugacucuaccgguuagacuag\n", + "gguggcugguucugcgccggauccpagapcpcgccauugugcuucgcugccgacugcauuuccucagucacpccuagaacuccaaggagaaaggcggcg\n", + "uuuguaagcugcgcuucaccugcuacuaaucuugcuguuacuucugcuaucccaucuuuaaauuuuuaucacaauuuga\n", + "guuagagcugcugucaccagcccugcaccuccucaagauggugcupuucccugccuaagccuaaagcuguugaacpucuguuggugccucuggaccccuggaaccaccagcc\n", + "cuaggucuugacucgaaaucucucuguauugcuuuuccaggugcuuaaugaucaauaguuggugcacugccuauccucaucccccccaugagccuugguuuuu\n", + "cuacauaauauucgccgugugaguggcuaucguaauagauaacauuugaauaucuacuaaaugccagaaacuaugaauuaacuccucucaacaaagcuaagag\n", + "aggcagcccagccccggccucccagcuuacagcugccgccugcuucucagaccugacggaaucagaag\n", + "acccgagcucauacuapacpaagucgcgaccagagccauuggapcgcpacugcaacccuaaucag\n", + "gagguucuaguacccgagcucauacuapacpaagucgcgaccagagccauuggapcgcpacugcaacccuaaucag\n", + "agcucauacuapacpaagucgcgaccagagccauuggapcgcpacugcaacccuaaucag\n", + "ggcggccgcaguggaaggagcaggcgcuugagcucgagcgacggcgcuggcggagacgccggcugcuccuccccuccccgccg\n", + "agguaggaugaauuggacaaggaugagacucguguaggugaggacaguuggaaggaucaugaugucguaaucuuggaguuaggugaaacag\n", + "agaaggcaguauagagacuccuaucaaggauaaagaagaacuaaauagaguuuaguaacaucguaaaaagg\n", + "augugaacgauuggaagaacagcuaaaugaccuaacagagcuccaccagaaugaaaucuugaacuugaagcaggaacuggcaagc\n", + "pugguugupauggaccpugcggcggccgcaguggaaggagcaggcgcuugagcucgagcgacggcgcuggcggagacgccggcugcuccuccccuccccgccg\n", + "agaupuuucaccauggugcccaggcuggucucgaacuccuagaaccaagcaauccacccuccucagcuuccuaaagugcupauuacaggcgugagucacuguguccagccguggucag\n", + "uuacuucaugugaaaacaaagaugguuggaagagcaugcuuguucaaauccugaauaguccacacauuccuag\n", + "aacuggucgucapcgcagaaaagaagcuuppcgcggucuucgccccagcuccacuucggugcuucacgauuccuucucuggccugccuuccugauaaauacccg\n", + "aauguuccauggcugauuuucugauugcagaacaacuauucuguauugacuguuucugcucauccagcuguaag\n", + "agcccuggacacgguacacacagaccagagccuuggcucaaaggcaaacaaaaggaaaugcccggcucccc\n", + "gguuccgcggcggccacgcuccpagacuuccggcapcpcgcpucuuggcgaacggucuucggaagcggcggcggcgcg\n", + "uuuccgguuagccuucpuguccgcgugagaauuggcuauauccuggagcgagugcupaggugcuaguccgccgcgccuuauucgagaggugucapcupagacuagg\n", + "auuuuccgguuagccuucpuguccgcgugagaauuggcuauauccuggagcgagugcupaggugcuaguccgccgcgccuuauucgagaggugucapcupagacuagg\n", + "ugagaauuggcuauauccuggagcgagugcupaggugcuaguccgccgcgccuuauucgagaggugucapcupagacuagg\n", + "ccaaauuugucuugaacaccuggcaucaagcuguccucuugccuaagccucccaaaguguuugaauuacag\n", + "gcuggaauucaguggcgugaacacagcuuacugcagucucgaccucapcucaagugauccuccugccucagccuccuccugaguggcuagcaccacag\n", + "gcuuucpucccgcgcccaggupaagaggccggcgacupugaccgcpaaacugaggcagag\n", + "gcgaaapcgugugguugcgccugaggaagauacuuuucuguguuuupuuguacauugccauuccauuucucaucaaacuauguccuggaauacaggccaaacugauuuucuugaauuucg\n", + "uaagaguucccuauuucauugauuugaaaaaaccacaggaucaagguuugaaucacacguguaacuacuaccugcagccagaggaagacgugaccauuggagucug\n", + "guugucaupaggugguggcgcuugguggccacuggcggccgagguagaggcaguggcgcuugaguuggucpcagcggcag\n", + "augaggaaacugaggcuuggugaaguuacgaaacuuguccaaaaucacacaacuuguaaapcacagccaagauucagagccag\n", + "gaccucauaguugaccagacgauagagaaaguuucuuucugugccccagacaggaacuuugauagagccuuuucuuacauaugccgugauggcaccacucgucgcuggaucugucacugcuuc\n", + "caauggauagguuagaaguaugaaagapupccuguugucaupaggugguggcgcuugguggccacuggcggccgagguagaggcaguggcgcuugaguuggucpcagcggcag\n", + "gcggaguucucccgaggaagguaggcuacggccggacccgcgcpucaggccaggaggucccuupacguccagcugcuccggucuagcgcgcugaccggcggccacugugugagga\n", + "cugagcupaupagacccaacuggccuggccgcuccggcucugaggaucccuaapaccaggaaagaaguccucgaggaguggcucgcguuugagaccp\n", + "gaguucucccgaggaagguaggcuacggccggacccgcgcpucaggccaggaggucccuupacguccagcugcuccggucuagcgcgcugaccggcggccacugugugagga\n", + "gucaupaggugguggcgcuugguggccacuggcggccgagguagaggcaguggcgcuugaguuggucpcagcggcag\n", + "acgcaaggagaaggaaaucauaaugaugucaugugaucaaaggaaaccauggaapuucacgcugauagcugauagcuuuuacagugcucauuccuaacaguggauuuacuu\n", + "uagagacaggauuuugccauguuugccagguuggccuugaacuccugaccucaggugauccaccugccucgaccucccaaagugcuuggauuacag\n", + "agagcagcggcgccagagcagcugcaccaucccggcguucgcgugugccgccgcuuuccuccuccaucucuuuuccuccgccuccgccggcgcg\n", + "pcaucgcggcggccuuucuagccgcugucccaapuuggucucgcgcuuucggcugcgagcucucuguggugcuggcagcgac\n", + "cuuucuagccgcugucccaapuuggucucgcgcuuucggcugcgagcucucuguggugcuggcagcgac\n", + "gauggagaaccuaauaapaaggaaucccccgcaauaccagagaaguccuuguaaagagguucgugcagcacuucggaagaggccugaagaggagu\n", + "gagcccgcuacaugaaaaaaaaugcaagucaaaguggucacaaccuagaagucugcagagacaggaauaacuagca\n", + "caauuguucaacugucaagcucuacgaaaacuaaguauuccugauaacgaccuuucaaaucugccaaccacuauugcuaguuuaguuaaucuuaaagaacucgacaucaguaaaaaug\n", + "guguacaagaauuuccagaaaacauaaagugcuguaaguguuuaacaauuauugaagccagugucaaucccauuucuaa\n", + "acuaccugauggcuucacacagcuccuaaaccugacccagcucuaccugaaugacgccuuucuugaauuucuuccagccaauuuuggaag\n", + "ccugaaguucuggaucaaauacaaaauuugapaguuauggauggauaauaaugcauuacaaguguuaccup\n", + "gacuuuugaaaaaacuaacaacucuaaaaguagaugacaaucaacuuacaaugcuacccaauacaauuggaaa\n", + "auuggaaguuguaagaauguaacagucaugucucuacgcuccaacaaauuagaauuucuuccugaagagauuggacagaugcagaaacuaagaguccuaaauuugagugacaacag\n", + "auugaagaauuuaccauucucauuuaccaaacuuaaagagcuugcagcuuuguggcuuucugacaaucag\n", + "uccaaagcccuuaucccuuuacaaacagaagcccauccagaaacaaagcaaagaguauugacuaacuacauguuuccccagcagccucguggugaugaag\n", + "auuuccagucagacagugacagcuuuaacccuacacugupaagagcagagacaacaacgcaugacuguugccuuugaauuugaagacaaaaaagaag\n", + "gccpccacugaggcggugcggaaaguuucugucupagugcggaacupccpuugguguacugcucggagca\n", + "gcauupucccpupccgaggcagcpagucgcgguugcucagcgugcaccugagacccgacgcccpuccucgaagacgcguccgccgccgugcccgucgcc\n", + "gucgcgguugcucagcgugcaccugagacccgacgcccpuccucgaagacgcguccgccgccgugcccgucgcc\n", + "auupucccpupccgaggcagcpagucgcgguugcucagcgugcaccugagacccgacgcccpuccucgaagacgcguccgccgccgugcccgucgcc\n", + "cpagucgcgguugcucagcgugcaccugagacccgacgcccpuccucgaagacgcguccgccgccgugcccgucgcc\n", + "agucgcgguugcucagcgugcaccugagacccgacgcccpuccucgaagacgcguccgccgccgugcccgucgcc\n", + "guguacupcauugugccucugcaaggccaaggagaggacaagcgacgcguggcccaccupcugccauucag\n", + "accuagucaccgacuuggacuucucgcccuuugaugacuuccuccuggccacaggcucggcugacaggacg\n", + "gaugapcguccucaaggagaucuccaucacgcaccacgucaaggcuggcucugagaaggcugauccaucccauuucgagcuccucaagguucupccapauccuuuggcaaa\n", + "cuguacugccaccccgcuacuaggaccpcgcaagguccupuggugcucagagguggauuccuuugcccaggcacgccccupaccaggccuccaaaggagaag\n", + "gugcugccagucauguccccuccccccaggcgguccucggaguacagcugguggugacccugcucacugccacccuc\n", + "aauuggucgaguuuccgcagagugcccggagcccuaggccggupugagugcaccgcguucucgcacgcgucaug\n", + "uuuguuccgauacaagcacccgucugaggaggagcuucpcccuggcpaagccgaggcccagaggcaggaaagagcg\n", + "gupccaauggccuuagugaggagaagccacugucugugccccgagaugccccguuccagcuggagaccugcccccucacgaccguggaugcccugg\n", + "uccugcgcuucuuccuggaguaccagugguuuguggacuuugcuguguacucpcggcguguaccucuucacagaggccuacuacuac\n", + "ucgccpccaupccucgagcccgccccgaacccccgcgagcccgccuugucugcggcgugacuggaggcccag\n", + "gucuuauuaguagguaagaaacagcugcuccuccaccuccaccccagccccauggagcuugcuuuuuccaggccaccguaguccucaccacugccacuuugcuucgag\n", + "aagaccaccuggagcuccgcccpcagcgcpucacggcpaauuuucpucgccgagugacucagccccgcaggcucgaaacugcpcgcaugag\n", + "caacccgcacapcgcacccggacgcucuaccgcucccgccgcagucgccpccaupccucgagcccgccccgaacccccgcgagcccgccuugucugcggcgugacuggaggcccag\n", + "agcaacccgcacapcgcacccggacgcucuaccgcucccgccgcagucgccpccaupccucgagcccgccccgaacccccgcgagcccgccuugucugcggcgugacuggaggcccag\n", + "cgcacapcgcacccggacgcucuaccgcucccgccgcagucgccpccaupccucgagcccgccccgaacccccgcgagcccgccuugucugcggcgugacuggaggcccag\n", + "cugccgccccucccuguguccuuccaagaagugccacaugcacugaucucuuguguccccagauggucauc\n", + "cuucggcgaaguuggcggcgcggaggcuggcccpacgcgcccggagcccapaaggapaggapapucgcggccggccgcc\n", + "guaguccuggcpcgupcccuugaggugugcupagcugugguccpucggcpcgcgcaaguuggcuagucucugcggccaccuccggaapuccgccggcugugcuggugag\n", + "pccggapupacggcgaggagguggaggccggcgcuccgcuccgcuccagcucgguuuc\n", + "gcaggccuggcgaggcggcggcpcggaggcupccggapupacggcgaggagguggaggccggcgcuccgcuccgcuccagcucgguuuc\n", + "aggcgaaggaugacuuccugcggcacuacacagugucggaccccaggacucaccccaapcuacaccgaguacaaaguaaccgcgcag\n", + "agacagagucuugcuauguugcccpcuggucugaacuccuagccucaagugauccucccaccucagccucccaaagugcupauuacaggugugagccacacacccag\n", + "guugcaaacugaccagaaaccuggcccccucucccapcagcuggccccuugauggcuaugcugagccccuccaugagacugaggagagcuucuccugc\n", + "gcauuggauguaugaggcauucaagucuuacaagacagccuaagcugcccuacaggagcuuagcgucugcuagaggaggccuacag\n", + "gaauuuguaagugucupuucgagauccuaggauucagaaggaggacuucuggcauucuuacauugacuaugagauauguauucau\n", + "gcauuuauuuauucauuaaaugauacuaauggaaggcauuggauguaugaggcauucaagucuuacaagacagccuaagcugcccuacaggagcuuagcgucugcuagaggaggccuacag\n", + "agaagcapacugcuuggauaguugaccagcuucugcapcuccucagugagagaauggaggugaggucapacuccugccuugccucugccaucacuuccagugaugccuauuccuaag\n", + "gcgcucgugugcgcuccupcgcucgccgccgccgcugccgccgcgcgccuuugagucagcaaacuccgcggcccgcaagcccggcucggcccggcccugcucuguucugcccggaggagccgccc\n", + "gugcgcuccupcgcucgccgccgccgcugccgccgcgcgccuuugagucagcaaacuccgcggcccgcaagcccggcucggcccggcccugcucuguucugcccggaggagccgccc\n", + "gccgcgcgccuuugagucagcaaacuccgcggcccgcaagcccggcucggcccggcccugcucuguucugcccggaggagccgccc\n", + "cgcgccuuugagucagcaaacuccgcggcccgcaagcccggcucggcccggcccugcucuguucugcccggaggagccgccc\n", + "auuuugcugauugcauccuuguggaugccaauuauuucuuacugcagaagaggagguuuuuuuuuucugcacuuuuccugauguguuacaagauaugaaaag\n", + "uuaacaccuacucaucuuuacugugcuacaaagauucaaacuaagcuaugauggaaaauuuuaaaaaacacaccuaucacaauggcuaaaauaaaaaauagugauaaucccccuggaaacuguaauag\n", + "gagucagcaaacuccgcggcccgcaagcccggcucggcccggcccugcucuguucugcccggaggagccgccc\n", + "uauuaacapcccuccugccuagagccucccagcugaacugccuapapuggucucugcuagaguggaagaccugguccucugaauuuccag\n", + "auaguugaccagcuucugcapcuccucagugagagaauggaggugaggucapacuccugccuugccucugccaucacuuccagugaugccuauuccuaag\n", + "gccgccgcugccgccgcgcgccuuugagucagcaaacuccgcggcccgcaagcccggcucggcccggcccugcucuguucugcccggaggagccgccc\n", + "ugaaagauuucaaaccccaaacagugcaacugaaacuuuugcauuacuauacuacugagaauaucuaac\n", + "aaauucagaaucacacuugguaacuaauaaugaaagauuucaaaccccaaacagugcaacugaaacuuuugcauuacuauacuacugagaauaucuaac\n", + "acucgccgucagaagcacucugcuugcugugcucaccccucagcuguggccacccuggugccacuccuucccuggccacc\n", + "cucccgcuccuccucggccuccccuucpcgcucucgcgcuaacugugcuccuccpcccuccgccugcucccagcc\n", + "ggcuucupcpccggucccucggacgauuggaccuagcuuggcgcggaauccgugaauugcccgcggcccgapugcag\n", + "ggucccucggacgauuggaccuagcuuggcgcggaauccgugaauugcccgcggcccgapugcag\n", + "augccgcgaacggcuucupcpccggucccucggacgauuggaccuagcuuggcgcggaauccgugaauugcccgcggcccgapugcag\n", + "guaagaaaacugagucacacaaggauauauuuguguaacacaauuucaaaaaggcaaacucuugcucuuguuaacg\n", + "uuggugauagauugguggucauccaacaugcagaaaugaaugagcagugaaaagcagcagagccgaupucaugaggauguaagugcguuugaaggcuuccacacccucuacuccagg\n", + "acagaaucaugaauaaacuggaggauaagcaggaccagaugauaccaugaagagaaguuuacaggcccucuauugccaacuguuaa\n", + "guuuccugcugaucuuggcacugaccgaagcgcuggcauuugccauccaggaaccaucucccapaaucucuucagguccucccuucaggcacucccccpaacc\n", + "gaagcuagucuacacacauggaupacuauggaaauauacaugugacuuuuaaaccugaacaguagcug\n", + "uccaacuagacucugaaaugaauuagauggagauuuaaaauapcaauuuagupaagagauacuuaauuugaag\n", + "agcugccuccguaggccauggagccgagcagauccpucuucpuggccgcaaugucccaaguggacgacacccaccuagucccgaggacaaccgacaaaguccuuaaupcccagaag\n", + "agucuggcccuugaguaccpuacgcapugccucaaccacacuccguccacggacucuccguuauuuuaggag\n", + "gucccuggccaaagauuuauuucucuugacaaccaapccuccgucuggauuuccaaggaagaauuuccucugaagcaccg\n", + "cuugaauccacucgccagcccgccgcccucugccgccgcacccugcacacccgccccucuccugugccag\n", + "guagucgcggagacpugcugguuugcgucguagucuccugcagcgucupuuuccguugcaguccucggaaccaggaccucggcguggccuagcgaguu\n", + "gcgucguagucuccugcagcgucupuuuccguugcaguccucggaaccaggaccucggcguggccuagcgaguu\n", + "gacacaggaauuacgaaauggagaapagaagugagcuaguggcagcauaaaaagaccagcagaugccccacagcacugcucuuccagaggcaagaccaaccaag\n", + "guggaaaaaaucuaaaaucuccucaaaaaguagaggucgacaucauagaugacaacuuuauccugagguggaacaggagcgaugagucugucpaaugugacuuuuucauucgauuaucaaaa\n", + "gacuuaggacpcgauggcggcugagaggagcugcgcgugcgcgaacauguaacuggupaucugcggcggcucccag\n", + "uugaaaaugaacuaccuccaccagaaaauauagaagucaguguccaaaaucagaacuauguucuuaaaupauuauacauaugcaaac\n", + "aggacpcgauggcggcugagaggagcugcgcgugcgcgaacauguaacuggupaucugcggcggcucccag\n", + "ggugugacuuaggacpcgauggcggcugagaggagcugcgcgugcgcgaacauguaacuggupaucugcggcggcucccag\n", + "aagapcagcgcgugugcagapcggugugacuuaggacpcgauggcggcugagaggagcugcgcgugcgcgaacauguaacuggupaucugcggcggcucccag\n", + "agapcggugugacuuaggacpcgauggcggcugagaggagcugcgcgugcgcgaacauguaacuggupaucugcggcggcucccag\n", + "gagagcuaagapcagcgcgugugcagapcggugugacuuaggacpcgauggcggcugagaggagcugcgcgugcgcgaacauguaacuggupaucugcggcggcucccag\n", + "gaguauugugaggauugagaugacuggaguguguguggccuggagaguugcucaauaaauauauguugccuuccacugugaagag\n", + "ucggugagucaugcuucagguuugccapccugugucccgcaaaaaggcgagcccuuauucccagcggaagcccaccccggcucgcggcagcuuuccggugcgcccupcggcguagauccgaag\n", + "agucucgcucugucgccagguuggagugcaguggcaugaucucggcucaccgcaaacucugccucccpuucaagcaauucuccugccucggccuuccgaguagcupacuacag\n", + "agaupuuucaccauguuagccaggauggucucgaucuccugaccucgugaucugccugccucggccucccaaagugcupauuacagg\n", + "gugagucaugcuucagguuugccapccugugucccgcaaaaaggcgagcccuuauucccagcggaagcccaccccggcucgcggcagcuuuccggugcgcccupcggcguagauccgaag\n", + "gugucccgcaaaaaggcgagcccuuauucccagcggaagcccaccccggcucgcggcagcuuuccggugcgcccupcggcguagauccgaag\n", + "uagagaupuuucaccauguuagccaggauggucucgaucuccugaccucgugaucugccugccucggccucccaaagugcupauuacagg\n", + "gucccagucccggugaucggaaguucuccgupcacupcggcugaaggcuccggaacugcgccugcgcuuuucg\n", + "acuccgcucucggcgccucpcuccgcgcccggccagccugaggupucggugcccccggcggcacggcgcupaggcg\n", + "gugcaaucaccaguacugccucaauuuacuucaggauuuuggapcacccaccuucccccuugucuccucacaca\n", + "acuuggccugccuccgucccgccgcgccacuuggccugccuccgucccgccgcgccacuucgccugccuccgucccccgcccgccgcgcc\n", + "gauugcauuugcggccucgcugccguaucccaggcuaagcgccgcgcgcaaagccgugcggagauuggaggccgcgcpucccuggucupcc\n", + "accgcacaccccccagcccagacuccagcccuggaccgcgcaucccgagcccagcgcccagacagag\n", + "gguuaaguuuaagaggcuggapauggcuagcuggaggucugcguuguagagagguaaccccag\n", + "agacacgccuacgauuagacucaggcaggcaccuaccggcgagcggccgcpugacucccaggcgcggcgguaccucacgguggugaaggucacag\n", + "gapuupaagcucgaagccgcaggccugacucuggccuuuggcauccupuuggccupcaaaugugucgugagagacggauuuguuguucucpaaggc\n", + "uccccgaccacucpuucggcuaugcpagccgugaggaggaggcuugcagucguggaccugagaccucpaggucaugcugucuugcuuuuaaguggcuupaaagugaagaaaccccaaa\n", + "acuguggucpaguaggcagcggcgccgcguccgcucucgcccgcucucgcccgcucgccagccggcucuccucccgccgcaggacccgcgcgccgcgcucpcc\n", + "ucpaguaggcagcggcgccgcguccgcucucgcccgcucucgcccgcucgccagccggcucuccucccgccgcaggacccgcgcgccgcgcucpcc\n", + "agucaagucguuaaaauaccaaguggaggcauucuacagacagguguccacaccacggccacgcggacacggagucpaaucuggauccccac\n", + "ggaggaggagccgccgccgcagcaucaaagagaccgaauucccgcggccuppagucaugcuuugcggucugua\n", + "agacaggcgcpcgcacuggccgcauagagacgcagcgcacgcgcagucgcguauccgugugaupcpcuguugacggcgcugcg\n", + "gcagcggagacaggcgcpcgcacuggccgcauagagacgcagcgcacgcgcagucgcguauccgugugaupcpcuguugacggcgcugcg\n", + "acgcuggagcgcagcggagacaggcgcpcgcacuggccgcauagagacgcagcgcacgcgcagucgcguauccgugugaupcpcuguugacggcgcugcg\n", + "puggaaaaugguaccagucaaacccgaggcggaggaggagcagcccgcagucgcugccgcgag\n", + "aucccccccacccccgccaacgcucgccpucgcccgaggccugagccaapacgcugupcgcggcucaggccaggcccucag\n", + "ugcucuggcuauugcugaaaacaccuucuaguuccaccuuguaacuggacucccaaaagaugaaugcugacaucuucugaugcuuaacaagaaauaaaaauagucaccuuaaucaucaaaaag\n", + "uuccgguggugaggagaccuuuccaaauauaagaggaauaaagaagucaccuccccagcugucaucaucuuccagcagauugagcaagaauauuuugagcacuacaggaaag\n", + "acaguccaucaaacccgagaugaugaucagccacgugauuuuuucaagaagaggaauapugaaugaaucucaucagaaaagcag\n", + "auugupaagcupaggagagagagagagaggaagucggacgupcgapcpugucuggacuggaaccucupcccac\n", + "gccuccugacaggaaagguuuaapacagagcccupaggccpccpcucpccaccccpcccpcc\n", + "ggaaacugcuuucuggagccgaagagagucggaagaacaagagguuuuccguuupuupapucucgaaaaupauccuagg\n", + "uuucccccuucgccuccugacaggaaagguuuaapacagagcccupaggccpccpcucpccaccccpcccpcc\n", + "gcaggaagugacgcgccuggcccpagcugcggucgcagaggccgacggagccggagucgcggacgccgcpucuccpacag\n", + "gaacccucagugcugcgucuagauucugcapagguuugcupaccuuggcuccacgcagccagcgaa\n", + "gauugaggcuggagcuuugcacagaaaaucupcpccupuaguuuuguccuuguupcpuggaguauucagupcaaaacgccaguuccaggaagccucgcca\n", + "aggaagugacgcgccuggcccpagcugcggucgcagaggccgacggagccggagucgcggacgccgcpucuccpacag\n", + "ucupccccagcgaggcggupcpcpcpcpcgcgcagcaggagcgagupccgcccgccpccgcggacacugucgcccggcgcccag\n", + "gcucggcgaucupccccagcgaggcggupcpcpcpcpcgcgcagcaggagcgagupccgcccgccpccgcggacacugucgcccggcgcccag\n", + "cagcggcggccgcggccpccugcpagcugcggaggccggaggcpcgcugugcggugccaggagaggcpucggcpagccagcgagccacpagcgagccag\n", + "ggugcaacguccucapcguguccgcgcuguggccupuagagccuugcuccuuucauggcupucguguucuggcguguggapccgcgcugguucgucccucaccuguugaugc\n", + "guacacaccaggccupcpagapuuuccuaccuucugcugcaagacapauupaaaucggaguggacucggacuugaaucggauugccccggaauccacccucucucugugauaag\n", + "cauupuggaggagaaggcggcggcucucugguccgcagcggcaacaguaacgaaaaacapcu\n", + "auccccgcaccaagcgcuuaaccucauupuggaggagaaggcggcggcucucugguccgcagcggcaacaguaacgaaaaacapcu\n", + "aagcgcuuaaccucauupuggaggagaaggcggcggcucucugguccgcagcggcaacaguaacgaaaaacapcu\n", + "uuuuuuuuuuuuuaauccccgcaccaagcgcuuaaccucauupuggaggagaaggcggcggcucucugguccgcagcggcaacaguaacgaaaaacapcu\n", + "agagaapucagccgcggcggcapcggcggcggcagcggcgcagcuccgcuccccgcgcgucucccuuccccgcgcccagguapcgcucagccuccgccgccagg\n", + "gccccguaagccaguccuuccaggcuccugccuccucuggucauucccugcgupccucucgcaggaagcaguuuuccugugucccccgccgacccccugcaggag\n", + "gucagcagccgccagacuuccugccgaaguccgagcccccucccpcuggappcaagcpuuccgaggugcaaagccuggugccccgagcccugcgga\n", + "gcccccucccpcuggappcaagcpuuccgaggugcaaagccuggugccccgagcccugcgga\n", + "agcugcgcguuugccagaguuccagcggaccuccuggagcgcuugaacccaaagccccguuucacagaugagaauaccgagucccccuggaagaagugacug\n", + "auuucugacagucagacuuguccacaagaacucaacuggcaaggcugcuuuucugugcuaaaacupagcuagupcacc\n", + "acgcuccucgacgcugcgaggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcgg\n", + "gacgcugcgaggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcpugaggcgcugg\n", + "agaupuuucaccauguuggccagguuggucuccaacuccugaccucaagugauccacccgccucagccucccaaagugcupauuacagaugugagucacugcacccggccug\n", + "aauguaaaauacuaccaagguauccpcugccgugagcapugaaggacagaggacagaaggccuugguucucgacauuggcacuggcacpacucuuguca\n", + "gcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcpugaggcgcugg\n", + "aggacccgccccccagcacgcuccucgacgcugcgaggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcgg\n", + "aggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcgg\n", + "gacgcugcgaggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcgg\n", + "aguucugcuuuaggacccgccccccagcacgcuccucgacgcugcgaggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcgg\n", + "cucgacgcugcgaggucccgccccgcgugcuggccgcgguaaaagugguagcagcggaggcgagcggapuuucccgcggcgg\n", + "ccuugapcugcaccuagaugaacuugugaggcucauuugaaccuuuuggaagcaccgaagccugcugaaguuuccagacaucu\n", + "agagacuuucuuuuucaguaucuaaggccagugugguacaggugguuguguguguguauguguguuucuaauaauaaug\n", + "gaauuggugugcuuauguacauaccagguuaucucccacagugauauuggacaaccaggucacuuaugucccaggupaaaggaccuuguggcuggaccgguggauccuguccucagag\n", + "acaucucaaacuggcaaaacucagucuuagcagauucaguguggaagcagcuaucaaaaaggccauaaggauuuuguccccaaauuucacaugagcuaccuugcuucaaacuacugag\n", + "agagaggccaagagguuucugcuucuauugauguuagcauuugguuauaaccacpcaaagaauauuaag\n", + "agccugaacugupuagugaugugguguguuuccuaacaccuccggcagugagccaggcuuugaguggcugcgucuaaacacuucuuucccugaggacuggaagacauuagaauaag\n", + "gguguguuuccuaacaccuccggcagugagccaggcuuugaguggcugcgucuaaacacuucuuucccugaggacuggaagacauuagaauaag\n", + "uucuuuagccugaacugupuagugaugugguguguuuccuaacaccuccggcagugagccaggcuuugaguggcugcgucuaaacacuucuuucccugaggacuggaagacauuagaauaag\n", + "gcugcggccuggccuucaggccacuggcuaccgaaccccpcucuucaccaguccagcucguuuccagcacc\n", + "auupacgcugcggccuggccuucaggccacuggcuaccgaaccccpcucuucaccaguccagcucguuuccagcacc\n", + "cuuccauauagaagaaapaapccaaugaagacucuuggaagcuapaccaagugcagucuuuag\n", + "ggugacuuuuuaugauugcuuucugcucgucugaauaaaggaugagcccapccugcugcccacugucugcucug\n", + "gguaccaugupaagcgcugugaagaguuguugccuuccaagauauacccaaauucccaguuccag\n", + "agguuuccpugapuupcuccuugguaccaugupaagcgcugugaagaguuguugccuuccaagauauacccaaauucccaguuccag\n", + "gapuupcuccuugguaccaugupaagcgcugugaagaguuguugccuuccaagauauacccaaauucccaguuccag\n", + "gaucaaucuucaucaggcuacauuuccaaucaccuaaacaaccgagcaagacaagccacuccgacaag\n", + "guuggcugcccggcpucucugugagagauccagguagauggugaacggccccggcagcugapcag\n", + "gccaggcccccagacgcaucagacccugaaggacugcguggupagcccugcaccgcuccuggccccpcccccuggauccgucpcgccuccacccagcuguuagc\n", + "aucaaucuucaucaggcuacauuuccaaucaccuaaacaaccgagcaagacaagccacuccgacaag\n", + "ggacgcupcuccaacguuucaguagaagcgcuuaagacuugcaaacacccuuggupaccuggaaccccpagaugccgacgagcaagcag\n", + "gcacauagcuggcaaccuggaauaaaaaaucccuaucgugguguuguuguguggccuguuccugaaaacauugaaaucacuguaacacuuuuuaag\n", + "acgcgcpccuggccaauggcggcpcgguggagguugagcugccgupuapuuagugugagaggugcggcpag\n", + "uuuuguguucagaacuauccaggcaaagacccuggauaacagcugaaaugcugguuuuuguuuuuguuuuuuuauuuuacgaguggacacaauucucaccugaguccu\n", + "uggccacguggcgcuauggcggucacuaccpaauuaaccacggccacccucucagagcgccpcgcggacucapacacgccggcuaccaccugagccgg\n", + "cucuccucgcggcgcgaguuucaggcagcgcugcguccugcugcgcacgupaagcccuggccccggccacccccgcg\n", + "gguuuccaaacgucggcagaggcuggagacggcucucuagugcupuguggagugaggcaccacccuugcccugaagccupcacucagucacc\n", + "uuuccggcgupuccpcaagaaccgcuuguaguuugguuuaaauucugcacpaggaccuucugaguuuaccuguupcuccuggcugcgcag\n", + "uuguuuccggcgupuccpcaagaaccgcuuguaguuugguuuaaauucugcacpaggaccuucugaguuuaccuguupcuccuggcugcgcag\n", + "gaacugcguuuguuuccggcgupuccpcaagaaccgcuuguaguuugguuuaaauucugcacpaggaccuucugaguuuaccuguupcuccuggcugcgcag\n", + "guuuccggcgupuccpcaagaaccgcuuguaguuugguuuaaauucugcacpaggaccuucugaguuuaccuguupcuccuggcugcgcag\n", + "aacugcguuuguuuccggcgupuccpcaagaaccgcuuguaguuugguuuaaauucugcacpaggaccuucugaguuuaccuguupcuccuggcugcgcag\n", + "aacauaaaaguguaccuauuugcagucacuaccucuaucaccaccaccagcagagccugagcugaggaaaccacgguucucaauacccagcacacccacuuccaacuaucuguuaaaac\n", + "ucugguauccuuugccgucucaucagaaggcacagagcapagaagauccacgcucggaaaaagaucacagcagaccucacaagcaccgagcgcggcaugcac\n", + "ggcucaggaggagugaaagccugucagaaaaacaagugaaggaagcaaaaucuaaaugcaaaagcauugcccuucuucuaacggaugcucccaaccccaacuccaapuguug\n", + "cuuucgaacuuppcuucuccucuugucucccacuggugcucuggcugugaauccauccapccagg\n", + "ggcupcgagccaggcugccuuucgaacuuppcuucuccucuugucucccacuggugcucuggcugugaauccauccapccagg\n", + "ggcgagccaggcugccuuucgaacuuppcuucuccucuugucucccacuggugcucuggcugugaauccauccapccagg\n", + "guucugapacaggcugaccuggaggaccagaggcccccggaggagcacugaaggagaagaucu\n", + "gccagupucuccauugcccagcuccugcccacacucccgccuguugcccugaccagagucauc\n", + "pagacugcauugcugaguccuggcccucugapacgacugugccugagugcugcugugccacupacccgccucugcc\n", + "uapagacugcauugcugaguccuggcccucugapacgacugugccugagugcugcugugccacupacccgccucugcc\n", + "caagugccacuguuagaaauggaaaucaggccagcugcupcggcaagcagcaggaaugcaaauguccaugaccccucagauccacacaaagccuucugaccuuggaauuuaag\n", + "auuuccaaucucaaguggacuuuguuccaacuauupcgucgcucccccucuucauggucgcpcaaacuuccuccucggcgccucuucua\n", + "gccgcagcugcugcacccacccccacccugcccggcccuuucugcaccgucaucuccugccccgccgaggcuugaccc\n", + "gugcugucccccucucccuuccuuugcccaccgauuggapacacucuggaaaacucaguugaagaaagcggagagucugcguguacacagugcaaugau\n", + "gucggcgcpaggcucagauggcuggaggcggcpcacgcacacugcpcuccgapcacag\n", + "gucuacccgcgcgcccgagcgcggaaaccgapcaggcucgcgcucugccugcuucguggcgcuugguucgucccucgcccgaggagcgcgguggcggcgupapagccucugacggcgucug\n", + "uacccgcgcgcccgagcgcggaaaccgapcaggcucgcgcucugccugcuucguggcgcuugguucgucccucgcccgaggagcgcgguggcggcgupapagccucugacggcgucug\n", + "gacggugcuguccapaggcpcggapaaggcgcugccgcugcugccgccgccucgcccgaagcgacacagacgcupagcggccgaggcg\n", + "uugcaaggcaucugaucuccugguguuaaaaucugucgugauaccgaggaaggccccgagaucccaggcacugagugacugcauacu\n", + "aaaggcuugugagaaucugguggaugcuggaccuugcugcugcugcuacugcuguuuccapcugcagagcauggacuguuaaaucuugcacuucuucugagugag\n", + "acacagucaaaggcuugugagaaucugguggaugcuggaccuugcugcugcugcuacugcuguuuccapcugcagagcauggacuguuaaaucuugcacuucuucugagugag\n", + "ggagaaaapaauuuuuaaaaggagaaugaaaguguccuugucucuagaacugaagcaacuuggaggaaugaguggagucuuuguuuag\n", + "aaaugccugguccugcuaauuccugagccauuupauuaugcaacguaaaucugguugcuucuuggcuuuccggcuaccgccuuaggauucauauuuucag\n", + "cugcucuaugaauggacgcugccccaguacagcgaggaccugcugcaaaaugcauuucuuagucuucaauacuuauuccuccuuguaacuggauuucug\n", + "gaugcuggaccuugcugcugcugcuacugcuguuuccapcugcagagcauggacuguuaaaucuugcacuucuucugagugag\n", + "ugagugaguucucaugagaucugaugguuuuguaapcuuuuaccccuuuugcucagcacuucuccuuccugccaucaugugaagaapcauguuugcuuccccuucuaccaugauu\n", + "agucuggcucucucacccacgcuggagugcaguggugccauauuggcucacugcagccuccaucuccupuucaagcaauucuggugccucagccuccugaguagcupauuacag\n", + "paggcpcggapaaggcgcugccgcugcugccgccgccucgcccgaagcgacacagacgcupagcggccgaggcg\n", + "agauccuaucauuauuuuaaaauuccuccuccuccacgaaguccuuccugauuccuucaaagaaauaucacuccuccgaauucccag\n", + "ggugcuguccapaggcpcggapaaggcgcugccgcugcugccgccgccucgcccgaagcgacacagacgcupagcggccgaggcg\n", + "acacacugaaguuugagaagcacugccuuugcagcuauggcaaacuucuggaacacgaagaaauaaagcu\n", + "agaaucugguggaugcuggaccuugcugcugcugcuacugcuguuuccapcugcagagcauggacuguuaaaucuugcacuucuucugagugag\n", + "cugcgguuaaggagaguccgguuuaaccgucaccpaagcgcgcucguucpaucgccgapcugag\n", + "auagugaauuccuaagaagaaaauaauggauugcauauuaguuguucucuaaguggacucaacagugugcaagcuuguuggaaaagccaaaagaag\n", + "gcugcugapaggaggcgaaaagcugcgguuaaggagaguccgguuuaaccgucaccpaagcgcgcucguucpaucgccgapcugag\n", + "caaccuugaugucuggcpcggcaapcuccgcpagaguggagaggcgccgcaggaagcccagccaccuucaggccaccgccgaccccacugugcgucupaggcgcupcgcgcaccg\n", + "aggaggcgaaaagcugcgguuaaggagaguccgguuuaaccgucaccpaagcgcgcucguucpaucgccgapcugag\n", + "gaugacuacaagucccaugaugcaaaguaugagcacggaccaauguuggucgcaguuccuucupaauuguagucuucuccuguuuggcaaacuag\n", + "gagugapagapugcugcgagcugcupcugcacacgcacacgcacacgcacacgcacacug\n", + "gaupagagaaggcguucaccuuggcucugcuggcguuuuccuupcccuccagcugcagccag\n", + "cccpuuuccgcuucccuccpcgcgagaagapagccaggccgagccccggcccuaccgccgccgccgcc\n", + "ggucucucauucaucacuuuuaucugcuauguggcguccucagcaucugccuuccucacagcgccucugcuggaguuccugcuggccuuguacuuccucuuugcugaugcc\n", + "ccpuuuccgcuucccuccpcgcgagaagapagccaggccgagccccggcccuaccgccgccgccgcc\n", + "cgcuucccuccpcgcgagaagapagccaggccgagccccggcccuaccgccgccgccgcc\n", + "agugucgccugcccuccuuccgcacagcccpuuuccgcuucccuccpcgcgagaagapagccaggccgagccccggcccuaccgccgccgccgcc\n", + "cuucagauugcaaaccuucuugccuucaagccucggcuccaacaccaguccggcagaggaacccagucuaaugag\n", + "gacuggagacugaugcaugapcuacggaggcgcaggagcgguggugauggucupaagcggagcugaagugcccupcuuuggugaggcgugacaguuuauc\n", + "agagcgcgccagcgagcccggagcgcggagcupaggagcagcgagcgccgcgcagaacccgcagcgccggccuggcapcagcucggag\n", + "gcaggagcgguggugauggucupaagcggagcugaagugcccupcuuuggugaggcgugacaguuuauc\n", + "caggagcgguggugauggucupaagcggagcugaagugcccupcuuuggugaggcgugacaguuuauc\n", + "ggcgcpugccaccguugccgcaggcuggagagagauugcucccagugaggcgcguaccgucupcgapcuucauucuuccgcggcgucccuggag\n", + "aagagcaaaauaauaugaaaaguauuuaacaaggaauauaaagaaucaucaaagaaaauguuauaaaacuucuuugagaccacaagagauga\n", + "aaacagaagagugcaggauauauuagaaucugaaaucuuucucaaggauaugaggugccugguagaacuuuauuuacauguuaggaaauuuuaacaugagcuuuucaagaa\n", + "agagugcaggauauauuagaaucugaaaucuuucucaaggauaugaggugccugguagaacuuuauuuacauguuaggaaauuuuaacaugagcuuuucaagaa\n", + "uuagugaagagaguagaauaucuccaguuuuggcugacaucucuacaaccugaacaauuggcuuaaacuucacuupauucccgguugcuuguuuuagc\n", + "cccgacaggccpuuacuguggcgaccacgagagcagcuuuggcgcuauggaggagcccpuuaccccucaaccguauuupcugcuccuggaggagcuacgcagg\n", + "gagugcaggauauauuagaaucugaaaucuuucucaaggauaugaggugccugguagaacuuuauuuacauguuaggaaauuuuaacaugagcuuuucaagaa\n", + "gaaucugaaaucuuucucaaggauaugaggugccugguagaacuuuauuuacauguuaggaaauuuuaacaugagcuuuucaagaaauggaauugaaaaguccagaggaagag\n", + "agagcugacacucggcgaugagcuaagacgcuguuucagagcguuupuccucugaggccccuugaccag\n", + "augagagugaugaagcuguggaucugguaaacagaguacaaccuucugcugcauauuuuucauccauucagcgcaauuuuaaguagauauuaaag\n", + "gacacucggcgaugagcuaagacgcuguuucagagcguuupuccucugaggccccuugaccag\n", + "gugaggagacaaggauugagaaupaagcuuauuguaguaacagacucuuguggaagaguagagucaucupaaaauaucugaaccc\n", + "guuugaagacugcuucauucugccucuaguaccagcgguuucucuguucugugaucaaugugauucacaggaacuccuuaaguaacaaacgaa\n", + "gcucucccggcugugauagaccuucaguuacagagagapagcagagupaccaggucugagaauagugaagcaacucauuccuuucaggacauucccucugauguccuauuuucaaacu\n", + "guaucuggaaucccggcgccuagaacguguuuuucpagagcaaaggcugugucuacggcagccupauaua\n", + "gaagapagcaccaggaacagcgccugcgcggupcgugauccpcacuuapcaggaugaacgcugcuuuccaag\n", + "agcaccaggaacagcgccugcgcggupcgugauccpcacuuapcaggaugaacgcugcuuuccaag\n", + "agacuaauagacaagucacgaguuaccugugucaaaupuucccgguucggaaagccuuuuccuaguagcccacucgagupaac\n", + "cugugaagagcggaapccaapacgucuucuccacgccgcuccgacuccapagccguggccuccucuccgcccuagcgcugag\n", + "guugaagagucuauaaaccaaccccccucgccccgugccacaacuccaaaaacugaaaagauaagcacugccuugaugauccguaupaacu\n", + "aaguacccuuagaaagaggcccucagaagagucuucucuuaagaagauaaagaagguaguggaaacgaacuuccugagcuuuucaggcucua\n", + "guggccggapccugguccgaguacagcuuucaucgccuuuacuccccgaccuuccuucgagucuguuuauccguugcagccucccuuccccacgacpcgccucugcaacucaca\n", + "gcuuucaucgccuuuacuccccgaccuuccuucgagucuguuuauccguugcagccucccuuccccacgacpcgccucugcaacucaca\n", + "acapcguucccgcccpacuaagccpagcgcaucccggcuacugcpuccupucuucaccugcggagccuuacggcagcugagcg\n", + "cuaagccpagcgcaucccggcuacugcpuccupucuucaccugcggagccuuacggcagcugagcggupaggcgaguccpcucccugaucuucc\n", + "acapcguucccgcccpacuaagccpagcgcaucccggcuacugcpuccupucuucaccugcggagccuuacggcagcugagcggupag\n", + "paaccuaaucacggucuuuaagaaccuggacucaugcuccaauucugcuccaagugapcupagaagaaauauuacagag\n", + "gaacuugacaagagaggaccuuaaagaaagugagauccuucauacuuaggaauucagugacacuugcupaga\n", + "gaacagagcgagcugcggccguggcagcugcacggcuccuggccccggagcaugcgcgagagccgccccggagcgccccggagccccccgccgucccgcccgcggcgucccgcgccccgccgccag\n", + "agauggcaggaaaggcguuauuuugagaucugcauggaggaaguucaccaggcagccucaauucaccagcuggaaguuugcguuguuuggaaauuugaugu\n", + "ggauuaaucagugacaggaagcugcgucucucggagcggugaccagcuguggucaggagagccucagcapccagccccaggagucuuucccgauucuugcucacugcucacccaccugcugcugcc\n", + "agaagcgcugccgccaccgcaucgcgcagcucuuugccgucggagcgcuuguuugcugccucguacuccuccauuuauccgcc\n", + "ugguuggagguuuccagaagcgcugccgccaccgcaucgcgcagcucuuugccgucggagcgcuuguuugcugccucguacuccuccauuuauccgcc\n", + "gccccucaccccacgugguuggagguuuccagaagcgcugccgccaccgcaucgcgcagcucuuugccgucggagcgcuuguuugcugccucguacuccuccauuuauccgcc\n", + "aucagaagcaaucaapagcaguuguugguauugauuupuacuaccaacuccugcguggcaguuauggaag\n", + "gugcuggagaaugccgaaggugccagaaccaccccuucaguuguggccuuuacagcagauggugagcgacuuguugga\n", + "ccacgugguuggagguuuccagaagcgcugccgccaccgcaucgcgcagcucuuugccgucggagcgcuuguuugcugccucguacuccuccauuuauccgcc\n", + "aucagaagcaaucaapagcaguuguugguauugauuupuacuaccaacuccugcguggcaguu\n", + "ccagaagcgcugccgccaccgcaucgcgcagcucuuugccgucggagcgcuuguuugcugccucguacuccuccauuuauccgcc\n", + "gugguuggagguuuccagaagcgcugccgccaccgcaucgcgcagcucuuugccgucggagcgcuuguuugcugccucguacuccuccauuuauccgcc\n", + "gcupucccugaaucaccgacuggaggagaguuaccuacaagagccuucauccaggagcauccacacugcaaugauauaggaaugag\n", + "gcggccccuccacapccccucuccugccuggacggcucugcuggucuccccguccccuggagaagaacaaggcc\n", + "agccagcucucggcucgcagccgcagcgccccgcccccgcgcuccggaccuggcaggcggcggcugcapcagguccapccac\n", + "guggcapuugugguuccpucpccgcgccgcagccagcucucggcucgcagccgcagcgccccgcccccgcgcuccggaccuggcaggcggcggcugcapcagguccapccac\n", + "ccugcggcpuagaggcggaggcggagucgagucacucccgcacuucpcuccggugccccgcgccaggcugcagcuuacugcccgccgcggccaugcpcuccgugcacgg\n", + "cgagucacucccgcacuucpcuccggugccccgcgccaggcugcagcuuacugcccgccgcggccaugcpcuccgugcacgg\n", + "gcaagapcacauupagauucagcuugcaagaguccugaaucugaucuagaagacuucuccgaugaaacaaauacagagaaucuuuaugguaccucuccccccagcacaccucgacag\n", + "cggccguggacgagcguccgugcggccugguccpccauguccgcgugaggaccccgccgcugucgccgcucccguuccggcccuggccccucugcccggcagcgccgcgcacc\n", + "cggccugguccpccauguccgcgugaggaccccgccgcugucgccgcucccguuccggcccuggccccucugcccggcagcgccgcgcacc\n", + "guuuacagaccggcacauggcgcuuccgguugacguugcugacagcuagugaggcuuuagcccgcuucgagcgcccpcg\n", + "uccgcggccguggacgagcguccgugcggccugguccpccauguccgcgugaggaccccgccgcugucgccgcucccguuccggcccuggccccucugcccggcagcgccgcgcacc\n", + "gucccaggagacuacagcaaacgaguguaucaaggagugagagugaagcauacagucaaagaucuccuggcagaaaaacgauccpcagacaaguaacucaagacuuaau\n", + "gcagcugacgcccgcuuauuagcucucgcugcgucgccccggcucagaagcuccguggcggcggcgaccgugacgagaagcccacggccag\n", + "cucaguucucuucuacuuupagagagagaaagucagaugccccuuuuaaacucccucuucaaaacucaucuccupugacug\n", + "gcuuuugauaaucuuuauuguggaggccaugccuaaacuaagaaaaugcaauacucuccauggaccuaaugaaaugagauaaugcacaagagagagccucccacaaugccugguacaua\n", + "guuuaccuuccagaggcuggcaaugcuguuucacuggaggacacggcuaagaaggaaguccaccagccugccaag\n", + "guuuaccuuccagaggcuggcaaugcuguuucacuggaggacacggcuaagaaggaaguccaccagccugccaagaugaauugccuugaag\n", + "gagapagapauccuggcccagcugacuuugaaucugapapccaagcugccacugcccuggauguuggaacaccuggucuugcugcuuccucccaccaccucaaaaacacag\n", + "ucaucugacccagcuccacccucggcaccaacgaaucuugcagcagcagcagcauagucaaacaccaag\n", + "gucuugcpcccagcggcucugauuccguaccccccaccccaapcuggaggcuggcaguaggcguagucagaggacgccacccgagccacgcgapagaagaguggagauagacaa\n", + "gacauggcaaccacagagagagcagcccuuuucuuucccccuuggaggcuuccagaggaauugacuacuaugacaggaaccuggcacuguuugag\n", + "acggcpugcggcpccgagcccgcacgaugccucacuucaccguggugccaguggacpccgaggcgcggcgacu\n", + "gaguccugcuagauccccgcaagcuaggccagcuccucccacugccucccuuccucuuucuccuccucuuacuccuuuccagccagaccuuggcugucuacagg\n", + "gugucggcccpcggcpacagcggcpacagcggcpcggcupacggcpugcggcpccgagcccgcacg\n", + "guuccpccgcggaggccggagcagcucccccpcagcgcaaccgcupccggccucagupcugaguggucpcaucpcccagagagcggcug\n", + "ucuucccggagguccuccagauaccgccggaguaugaguggccuucccaaucuacaggaaacauuaaaagagagacag\n", + "auccgcucuaaacaaccucaucaaaacuacuuucuggucagagagaagcaauaauuauuauuaacauuuauuaacgaucaauaaacuugaucgcauu\n", + "uccgcucuaaacaaccucaucaaaacuacuuucuggucagagagaagcaauaauuauuauuaacauuuauuaacgaucaauaaacuugaucgcauuauggccagcacuauuaag\n", + "ccgucagguucugaacagcugguagaupcuggcuuacugaaggacaugauucagacugucccggacccagcagcucauaucaag\n", + "guuauuccaggaucuuuggagacccgaggaaagccguguugaccaaaagcaagacaaaugacucacagagaaaaaagauggcagaaccaapcaacuaaag\n", + "guuuucacuuggucggaaupagagugugcaagagaucgcugcpacagguuccuagagaucgcuccpacggucgugacggcccccgapacaugagagaagaggagcggcgcucag\n", + "aaauccuguugccaauccuuguaugucaguuucccaupucuugaaugcaaauacaaauaucguaaacuaaauauuuguguuuucuuuccuagacucuccagaaagagcaacagua\n", + "cgcpaagcpacccgcugucacugcgccucccgcugccgacgccgccuggacggccgcacucucccugcccgagacccg\n", + "cuagaagaagucuucacuucccaggagagccaaagcgugucuggcccuaggupaaaagaacuggcugugaccuuugcccugaccuggaapcccagccuupcuga\n", + "aagaagucuucacuucccaggagagccaaagcgugucuggcccuaggupaaaagaacuggcugugaccuuugcccugaccuggaapcccagccuupcuga\n", + "augccpcpcccggaaccgccacpugagucpucguggcugcugccpuccugcgcgcuccggacugag\n", + "ccuucggccuccuccccupccgcagcgacucpccggcuuccugcuucccugccugccggcggucccgcugg\n", + "cuuucccucagguuuuccucuuccccacugcggcuccccagucggcgcuugcgcggagaacucagcgcugag\n", + "auugucuaaagccccaggaaaaaugguggaaaauucaccgucgccauugccagaaagagcgauuuauggcuuuguucuuuucuuaagcucccaauuuggcuuca\n", + "gcpugcguguggagaggcccaggugaggagcaagcgcccgcguuccggaagcccgcucccpcc\n", + "ggauccaguauuuaagaauauuuupcugcucucccucccucauuuucuaccuuuuuaaggacuggauggucuuuccuugauuaucagauucaauuuuucaag\n", + "gucupaguguggcaaauaacuggauugaaauuuauaauuucguacagcaacuugcggagagauuugugag\n", + "agucuupuuugugaaccacgcaupcuguuuuagcacagcugcuaaaauaggccaggccugcaggacauacgg\n", + "ugcagaucuuccuucaagaaaagacuuucugagaauuuuugccucuaugguuaucagugacagugaccu\n", + "accgaguuucacucuuguugcccaggcuggagugcaauggcacaaucuuggcucaccgcaaccuccgccucccag\n", + "gugaccucaaagcagaagcucugaauucaccucucaucugacgacugacagcugcugccaccgccagccucugucccuugcccaggccugucacacggcugccucucagcag\n", + "cucaucugacgacugacagcugcugccaccgccagccucugucccuugcccaggccugucacacggcugccucucagcag\n", + "ggcccugccggcapcagcaagucpagcagcugupugguguccuacaggcucugcuguggaggaagagcugcugcccugaguggag\n", + "gcacgaggcgcgcguuugcacccgagcccggcccgcgccccgaugcggagcgaugccgcucggccuggccgccccccgcgagcaccgcgcugcagacgaagcccgcgcgugaucccgcuccgg\n", + "guugccugcaugagugugugcucugugucacuguggauuggaguugaaaaagcuugacuggcgucauucaggagcugg\n", + "aguaapcugguugccugcaugagugugugcucugugucacuguggauuggaguugaaaaagcuugacuggcgucauucaggagcugg\n", + "gccugcaugagugugugcucugugucacuguggauuggaguugaaaaagcuugacuggcgucauucaggagcugg\n", + "agacgcggagcgcacgcggccuuugccucggccaggacapcagcpagapcugcuagacaacaauucuugaccccuccucgacccacgaccgccag\n", + "gcccuaaagccuggcagacgcggagcgcacgcggccuuugccucggccaggacapcagcpagapcugcuagacaacaauucuugaccccuccucgacccacgaccgccag\n", + "ccaggacuaaaagaagugguagaauccugucgaggaaaaaaucuuuuuuuuucuaccaauauugaugaugccaucaaagaagcugaucuuguauuuauuucu\n", + "gaaucaaacuugacguauggagccaagaaagcccuuggaaaaacuggccucauauuuuguguacacagucccuguacapuuucugaccugug\n", + "aggaaaaaguccuggauuucgagucagaacaucuggauuagaauccuacuucuuucacuugauaaucuuguuaccuguggaaaucagaagagagaauauaguaaaaauacgcaguacagucccag\n", + "cuuccuccaggagucucuggugcagcupuggaaucuggccaggcccugcuuaggcccccauccupucaggaaauuuggaggauaaggcccuucagccccaag\n", + "ccuuccuccaggagucucuggugcagcupuggaaucuggccaggcccugcuuaggcccccauccupucaggaaauuuggaggauaaggcccuucagccccaag\n", + "agaugupagcgccucugcccugucgccccguccpaugugaggagcgucucucccuggccgccccgucugagaagugaggagccccuccgcccagcagccgcccugucugagaa\n", + "gcuagucuugaauuccugaccucaggugauccucccgcguuggccucccaaagugcupauuacaggcaugagccaccacuccuggccccagaaagugacauucuuuacuuaccacag\n", + "gucugcgcgucuguuguucccagcgcucuuggaggccugcaaaggaagagcaaccuguccagacuccccgcag\n", + "cuggaacaacuuacuucccgucuuuccacuucagagapaaccuaggaucaaugaaguugaupuuuucgucugcuggaguaggaauaa\n", + "augguccugucugucagcgcuguuuupagcccgccggugaggccpccacgcucagacacuucgaucgucgagucugucacug\n", + "uucccgucuuuccacuucagagapaaccuaggaucaaugaaguugaupuuuucgucugcuggaguaggaauaa\n", + "agucccuccucccpcpcgacguugccauggagacaggccgcuggcugaggcccggcucgugucccugcapc\n", + "uccaacucccaccccpccccggaccgcagcuggucguaguggccgcggaggacggcagcuuuupccpcpagaagcguccguucauccgcggaaccaagcugag\n", + "aguccuguggccacggccauggccpupagcupcuccagugagcacagagcuccuugccaguaggcgaugcaaguuaucucupcccggaggacacga\n", + "ugcuggaaugaauccauucaucuuuaaauacuuaacugcuucuacuacaaugaguacuacugccaguuuccacuaauaauagcaguacucauggcugccauuuccagaguacucacuag\n", + "gauaaaagaaucagagugucucaacccuugacaagaggaccaagugccuuuauuccagagaaggaa\n", + "guuguccaagcaaacacaguggaugaacguacuaacuuucuuguggaagaauacucuacauccggucgucuggacaacaucacacagguc\n", + "aggcucuauuuagagccpuapagcgcagcggccagauaccucagcgcuaccuggcggaacuggauuucucucccgccugccggccugccugccacagccggacuccgccacuccg\n", + "auugcucagcggugcuaggcuggcgcggcuugagccgccgccggacugacagcucggucugcggacc\n", + "accgugcgcguggccgcgcucaacggcgucucpcccggcggccgccgcpaaccaccuacgcgcaggucaccgucuccaccpcccp\n", + "guccucgauuauccccaagcgcccugcagaccggcaggucuaguuggcuugupaaaagauaccucuuuguacgucagaagaaacugaggcag\n", + "aaggaguucaaguugcuugccagacuaacuuacuuuuaaaaguaagcagccuuccaaguuaagagaugauuuuaaauuucag\n", + "agccucccugccugaggcguccgcggccpauccggccccuccccucgccuccucuccuaggugccggccpapcggccgcagcag\n", + "agaggccgcgcgcacagagcgagcucuugcagccuccccgccccucccgcaacgcucgaccccaggauucccccggcucgccugcccgcc\n", + "pugccupcugagccgcggccucgacauggccuaacagugapcaggcccgaguuugccgagugcaguccccg\n", + "cagccuucgacgacgcaguggaagaacgagugaucaacgaggaauacaaaauauggaaaaagaacaccccuuuucuuuaugauuuggug\n", + "agcgagcucuugcagccuccccgccccucccgcaacgcucgaccccaggauucccccggcucgccugcccgcc\n", + "ggaaacaauagaggccgcgcgcacagagcgagcucuugcagccuccccgccccucccgcaacgcucgaccccaggauucccccggcucgccugcccgcc\n", + "gcagcccgagccggagccggagccpagucguggcccggagupccuuggagucggcgcgcaggcggcucgcg\n", + "guagacagauccaggcucaccaguccugugccacupcuuuuggcguucugcacaaggccuacccgcagaugccaugccugcucccccagccuaaupcuuug\n", + "uguugucuguuuuaguaugcaggugauagacuagagaacaagaccucugucuccguagcauccugg\n", + "auggapcpcucugcapaagugcgucagaggaggcgcpagaguapugcuguggucugagcuagapugaagcuggcggagcaggaggaupcg\n", + "agcagucugaaugccagaauggauaaccguuuugcuacagcauuuguaauugcuugugugcuuagccucauuuccaccaucuacauggcagccuccauuggcacagacuucug\n", + "agaggaggcgcpagaguapugcuguggucugagcuagapugaagcuggcggagcaggaggaupcg\n", + "ggagguggcugcugcaggcguccggcuuggacgaaccgccguucccagugcupacccuuuaag\n", + "gcpaguuauggapcpcucugcapaagugcgucagaggaggcgcpagaguapugcuguggucugagcuagapugaagcuggcggagcaggaggaupcg\n", + "aagugcgucagaggaggcgcpagaguapugcuguggucugagcuagapugaagcuggcggagcaggaggaupcg\n", + "aguuauggapcpcucugcapaagugcgucagaggaggcgcpagaguapugcuguggucugagcuagapugaagcuggcggagcaggaggaupcg\n", + "cuguaapuaacgauuaggcagacggcuaaagugapagacuuuuggcugguauuccaauuggaaggaguuacacuauauaaucccacugcaaacaauagg\n", + "ucugcagccccucuuuccuggaguaaaugaacuggaccaaaucucaaaaauccacgaugucaucggcacacccgcucagaagauccucaccaaguucaaaca\n", + "gucgagagcuaugaauuuugauuuuccuuuuaaaaapaucaggaauaccucuacuaacaaccaauuuguccccacaaugccucucccuccugcacgcaaugguggccu\n", + "ggaucaggaauaccucuacuaacaaccaauuuguccccacaaugccucucccuccugcacgcaaugguggccu\n", + "cugcaagccacacucuuuccuuuucuuccggaaggapuagaagacaaaauaauauagagaucaugccaa\n", + "augcuguuccgguggaggauuaggauguugucgaggapagaaaucggupaucaaagaaggagaagucguccgcupcuauupaugapagcaggag\n", + "cccuuccuggaucuggagagagcagcugcugcugccccaccaccugccaggcccggccacugagcagccccccggagccccag\n", + "gcupacccacgcggcaccgcpapcucugcgcgcucaaccccgucccuggcauuauccgccgccuccacccgccggccucccgcagccuggccapcc\n", + "gcgcgcucaaccccgucccuggcauuauccgccgccuccacccgccggccucccgcagccuggccapcc\n", + "ucaaguccaucaucuccagaaccagcuagucuuccugcagaagauauuagugcaaacuccaauggcccaaaacccacagaaguuguauuagaugaugacagagaagaucuuuuugcag\n", + "aagccacagaagaaguuucuuuggacagcccugaaapaaccuauccuauccucggaaccuucuccugcagucacaccugucacuccuacuacacucauugcuccuagaauugaaucaaagagu\n", + "ccagcagcccucagcccuccaggacaggcugcaucagaagaggccaucaagcaggucuguuccaapccuuugcgucag\n", + "gacagcggcgacccpccucagaccugcccccgcaucucgccggcgccaggcagupaagucagguucuuccgccaccucccagccag\n", + "gcacaccuucgccuccgauuccgaaccgcccpacagaggcaaguggcaaagcapapcggag\n", + "acgucpuuuccucguuuuugcggacuggcgcuuucugauuucagagacucuccgcaacagaaccaucucaa\n", + "guacuggcgguuccuuccgccggacacgucpuuuccucguuuuugcggacuggcgcuuucugauuucagagacucuccgcaacagaaccaucucaa\n", + "gugcauuucuaaccagcuaucaggaaguugcugaauuuaaaauguugucucuguggagccagaagauaggcuuuagauagucauagug\n", + "cuaguccugagaggcupccggcggcggcugcggcpagaccggugacccgcggcupcgccucggcc\n", + "cugagaggcupccggcggcggcugcggcpagaccggugacccgcggcupcgccucggcc\n", + "aguccugagaggcupccggcggcggcugcggcpagaccggugacccgcggcupcgccucggccaugacugcggagcugcagcaggacgacgcggccggcgcggcagacggccacggcucg\n", + "aaguuauagaccuuacucaugauaacaaagaugaucuucaggcugccauugcuuugagucuacuggagucucccaaaauucaagcugauggaagagaucuuaacag\n", + "agaccggugacccgcggcupcgccucggccaugacugcggagcugcagcaggacgacgcggccggcgcggcagacggccacggcucg\n", + "pagaccggugacccgcggcupcgccucggccaugacugcggagcugcagcaggacgacgcggccggcgcggcagacggccacggcucg\n", + "aguccugagaggcupccggcggcggcugcggcpagaccggugacccgcggcupcgccucggcc\n", + "ggcuccggcuggcaccugaggagcggcgugaccccgapcccapagcugcccggcuggccuaggcaggcagccgcacc\n", + "uguaaagaggauguguuugcuucaccuucugccaggauuguaaguuuccugaggccuccccaguccugcggaacu\n", + "aguggaccgcugugcgcgaacccugaacccuacggucccgacccgcpcgaggccpuaccupcupauccggagcaagcpcgapcagcgcccuaagcag\n", + "guggaccgcugugcgcgaacccugaacccuacggucccgacccgcpcgaggccpuaccupcupauccggagcaagcpcgapcagcgcccuaagcag\n", + "gccggcaguggaccgcugugcgcgaacccugaacccuacggucccgacccgcpcgaggccpuaccupcupauccggagcaagcpcgapcagcgcccuaagcag\n", + "cugaacccuacggucccgacccgcpcgaggccpuaccupcupauccggagcaagcpcgapcagcgcccuaagcag\n", + "guccuccggaaccgcccccggcccucccupacccgugccucagcgcguccaggcuuugugguguccugagucgccauggaaacccgapaacgcggagccpugcuappucg\n", + "aucpcuaagccpcgcucuupuccucuuuguacgcccgcgaagcgccgugccpccuugcucaua\n", + "cucccpcuaggacauccuccucucccccuucuguuucugcgugaggcgcacaaaapcpagccgg\n", + "gaggcggcccccgagcgagcgcgcgugcagccgccgccgccccgagcacccgcagcuccggcgccgcggcgagacggagacggaccgagccacpcccccgcggccgcagcaucucggagga\n", + "guuccuagcaaccagccugaggucuggagguggugcggapagccgccuapaccapacuccugcc\n", + "ggaaaucuaguucpaaaagugugapcucuucacgupaaggaacagcaggcgcggaggapcaagcgugugugagauucagugguccaugcgugcguuugucgu\n", + "gugcuggugauupuguggcaacucagaacugagugagcaacuguaugaugupcuaucpauauagugaacaucgacaucagugagguugucaucaagcaa\n", + "gcagaguugcgacgcucggcggcauapcggcuccaccgacacuacgcggacgccuccugccgcag\n", + "auacacaaucaucaucuuacuaguucucuguguugcucgcuaaccagucccccaguucaguagacuggagcccagagccugcuuacuugucag\n", + "ugcggcggucccugaggcgcagaguugcgacgcucggcggcauapcggcuccaccgacacuacgcggacgccuccugccgcag\n", + "uucugucuuccaaugguggaaccugagagacuucaguguaaaaugccuuauucuguucucacugaaacaag\n", + "caaaaguugaaaaaucaguaacccaagaugacuaaccaaaucaauaugcupcaggaugagacaucagugucugccucagacagaagagcacacacaaaacaugaccucucacuccaagcccag\n", + "caacaaggauggccaaggcagucacuaaucucacacucaccugauagccacaggaacaacauuuucccagcuauaag\n", + "uuucuugcaaacuuuguggcacguuuucupaagaaaaaacuaggaucguguaauauuaaaaaauaaaucgagaggcuuuuuuuuuuugcucuccauauuauuaagcugcauggacugag\n", + "guacacuugcugaaggaccaguuggcugcugaggcugcggcgcggcuggaggcccaggcucgcgugcaucagcuuuugcugcagaacaaggac\n", + "gcccagcuccagucuccccuccccpucucgccagccccuuccugcagccgccgccuccgaaggagcpuccgccgcpuaacc\n", + "gucgcuccgguuccucugccuccucuggcugcugccuccgcagcucccuccuccuaccccaccuccuccaucupagcgucugcpccugapcggcggcggcggcggcggcugcgau\n", + "agacacccggccuagcgccgcpucgcgccgagccgagccgagccgagcggagccggcggagccucuggaaucacccpucgcuguuccugag\n", + "agugaguggcagacacccggccuagcgccgcpucgcgccgagccgagccgagccgagcggagccggcggagccucuggaaucacccpucgcuguuccugag\n", + "gaguggcagacacccggccuagcgccgcpucgcgccgagccgagccgagccgagcggagccggcggagccucuggaaucacccpucgcuguuccugag\n", + "cuagcgccgcpucgcgccgagccgagccgagccgagcggagccggcggagccucuggaaucacccpucgcuguuccugag\n", + "cacccggccuagcgccgcpucgcgccgagccgagccgagccgagcggagccggcggagccucuggaaucacccpucgcuguuccugag\n", + "gcaguuccucuuugugguugccuucacuaccuuccuggucagcugcguggacuaugacauccuauuugccaacaag\n", + "aacauccgccagguagcuucuuaguugcugccccuagcucuaggagcuccugagugcacacgccguacccgucccuugucpaauccugucgcag\n", + "acuggugcgcgauuuagguccggaggaggcguugugaggugagcuuuuucagaagcgcgaucccaggacacgucpaagcaagcauccccag\n", + "gucccucaaggccggaaagaaagucpcuucucuagccccuggaggacucgacucacuggugcgcgauuuagguccggaggaggcguugugag\n", + "gccccucuggcgccguucgguuucucuuauugccuucacugaggaugagucccuuuguggcucuauguggacccugcggaauccaccggcgcaguuucaucuagcgacug\n", + "gcaccuuuguguccuggcuuuuucauuuuuuaaaauuaguuuucacgauucugaaguaagugguauaaaaacaguuagg\n", + "cagcuccuugccgucacaagaacgaaguaggucapapaagaggcaucuucguguccugaccugauuccuugccgucuauuaaauauccuacauugcgg\n", + "ccaggaugcccccucaccccgucucccacucuccagcgccccagcuccuugccgucacaagaacgaa\n", + "cuuuuugcuuucgcaggcgagugaggauggaguccuggccccugccaguggcucagccuguguguguacccapuagaaugcaaugcgagugapcgaggagcuccpcugacccuuggaacacg\n", + "gcugcagcuggagguagcugccuaucugauucuguuugagaguccgccaaguupauuuaaauuagacaucaagaagaauuuacagaccggccuugccuuguuccacg\n", + "gcggccgcagccugagccapcccccucccucgucaggaccpcagcaagcaggccpcagguccpcacccacc\n", + "aggaaaucggccacagugcgcaugugugcggcugugcuuuggcucuucpuaaagauggcggagcgcpuacagcuuuucgcugacuacauucag\n", + "cugcaaauggugugguauuagcaacugagaaaaaacagaaauccauucuguaugaugagcgaaguguacacaaaguagaaccaauuaccaagcauauagguuugguguacaguggc\n", + "pucaggccauggauucgagccccagcgcugugacauacugccgaaagguuguapcaagapugucucccccaaacpccgacccuccugcggccuugacgc\n", + "uuaacugcucgcuguggupaapcagagguaggugagcacucucccagccuggagcagccggaccagcccagaaggcagcggcggcccaggccagcauucccgca\n", + "gapagauuugucgccugccgcucgcucupcucgaugugaauauauauuaugucugccuguucuccccucgucgguggcuaag\n", + "agagacupccuggagacuggapagauuupaggaauagagapuguaguggapaagaagccpcuggagacucagaaggapagccagagu\n", + "gccgccacgcaccuggapcgacuaccagcgcucagcuugcucgcugcagucccupcaacgcugccccacaugccaagagcaaggagcucaacggcagcugc\n", + "acuuuaacugcucgcuguggupaapcagagguaggugagcacucucccagccuggagcagccggaccagcccagaaggcagcggcggcccaggccagcauucccgca\n", + "gacacuuuaacugcucgcuguggupaapcagagguaggugagcacucucccagccuggagcagccggaccagcccagaaggcagcggcggcccaggccagcauucccgca\n", + "cuuccaccacuauguuuuccugagauaagucpagucugagapagagaappagacugagagucagagagaggagagacuaaggacgcuaggupcapcucuucacuugcag\n", + "cgagccgcuccauacccuaggauccacuauccgcucuagcggccagaagcgcggccaccuuccccugcugaagcguucacuuuaauuuuggccg\n", + "acuccggcagguccgcggugcugccagaacccgccgacggcgcpcugcugguccccgcucggaggaggcgcppccccpacc\n", + "cucuuacaguggucccugcuggcccuuggugacpucgcgucaguuccgacccggacccguacgcugcugcgcugacguggcuccuggaagcapcuggcguapccgcc\n", + "cuuacaguggucccugcuggcccuuggugacpucgcgucaguuccgacccggacccguacgcugcugcgcugacguggcuccuggaagcapcuggcguapccgcc\n", + "guggauccugcaauggacacaucauaaggacagaagccagcauugugaugucacagccuggcuguggcuuugugcuccuggagcuguag\n", + "ggauuguccpuggcaccguucccggccccaccpcgccgcgapaucaugucuacagccucugccgccuccuccuccuccucgucuucggccg\n", + "guuguuggaagaggagccuuuggaguuguuugcaaagcuaaguggagagcaaaagauguugcuauuaaacaaauagaaagugaaucugagaggaaagcguuuauuguagag\n", + "cuucggcaguuaucccgugugaaccauccuaauauuguaaagcuuuauggagccugcuugaaucca\n", + "gapucgguccggaggcpupcgcpucucacccggauuguccpuggcaccguucccggccccaccpcgccgcgapauc\n", + "aguuacugagaacucauaagacgaagcuaaaaucccucuucggauccacagucaaccgcccugaacacauccugcaaaaagcccagagaaag\n", + "gcaguuacugagaacucauaagacgaagcuaaaaucccucuucggauccacagucaaccgcccugaacacauccugcaaaaagcccagagaaag\n", + "ggcugaggcaacaggcugugauggccaucagccaggagcugaaccggapcccuppccccaccccuagcacguggauuaaccagguucggcggcggagcucucuacucg\n", + "gaagcucugucucuccucggcuguguauccagguucucggcuggaagagacucucuacagugaccaggagcuggccuaucuccagcapaggaggcc\n", + "ggcaccccccuuucucugccccccgcccccaagccgcggccauggaccuggcggauccggccugcccuggcccagcucaacaccugauuucg\n", + "gaggcagaagccaacuccuuucucccgagccugcuggcagauccucccccaccucuccgcaggaguuccccuccuaggcupagcaucccgugcapuaaaucuuuucaag\n", + "aauucugucuuugaggcagaagccaacuccuuucucccgagccugcuggcagauccucccccaccucuccgcaggaguuccccuccuaggcupagcaucccgugcapuaaaucuuuucaag\n", + "gaguucauugaaaaugaugaggaugcagacaupaagacagaauaagaacucaaagguucgaagacagccaagaaagaaacag\n", + "gugcgucguggcaggugagcggugaugaagaaapcggaagcucccgcuugapuagacgccacggccuccgcucccgcgcguuguuguccugccuuaccgcgcuuggaaacucu\n", + "gacuugcgagcccuggucagagaggagccuggapccaccuaagcucugcacaaggaauucauccaacucuguag\n", + "cuauauauaaaugcugcuuugcacagugaauuagccgaugccacpaagcagcggaugupaugguggcagaaaaugaccagcgugucagauuugcauaaggacacaccacaaggcugag\n", + "aggaagccggcggagucuuggugcugagucugapcuucaggcaggacccaagacucuccucugagguagcagcccccagagaagguuagcuguucucugaug\n", + "gccaagucucugaaucucugaccuuuagaagaaaaugaagacucugccpuccagccugucuccugcauaacuacugg\n", + "gauuuucuucccuggagugagaagcaggcagaggaucacucgguggcuguguauacccugccuuuggugguggcaccccagucagaaacpacccugaagcupauuuag\n", + "aaugucacgcuacuguapugaauucaucagccuuugccuuccugguuuaaaaacucuugcaaaaaugccaaaupugugaccuuuucuuucuucuccaacagaagccugga\n", + "cccaucgcccgguccgcggcgaggupccugguguuugacccggaaguggcuguguucagcugacagcugcugauaagguggcggcggcgaaggcagcggcag\n", + "agaagacccggauaguuccucccggccacgccgcgccggcucupcacucagcaucguuuccuuuuccuccgcuggagcagcu\n", + "cauacacgucgugacuuggaacguggcuucggcagcgcccccucuagaucucagugaccugcuucagcugaacaaccggaaccucaaucuugacauauauguuauugg\n", + "uuugcaggaauugaacucupaucauaagccuccuuuccgaugcugccuuuaaugacucguggagcaguuuccuc\n", + "aaaaacaguccgcgacagcuaggcgcgugagaccggccgcccgcapcugcucuggccpacccgcuggccpagacgcgaaccugccggaccaccgcgcpacgacggcggcc\n", + "guccggaagaaaaacaguccgcgacagcuaggcgcgugagaccggccgcccgcapcugcucuggccpacccgcuggccpagacgcgaaccugccggaccaccgcgcpacgacggcggcc\n", + "ccgcccgcapcugcucuggccpacccgcuggccpagacgcgaaccugccggaccaccgcgcpacgacggcggcc\n", + "aguccgcgacagcuaggcgcgugagaccggccgcccgcapcugcucuggccpacccgcuggccpagacgcgaaccugccggaccaccgcgcpacgacggcggcc\n", + "auucucagcgcupagccgccgcccccgcagcugcugccgccgccgccapcccggacucggacgcgugguag\n", + "agcgcupagccgccgcccccgcagcugcugccgccgccgccapcccggacucggacgcgug\n", + "gcccauaggcuccugccagccugugacgugcggccccpaaugccgupagcpcaggcuggcaugagcucaccggagguacccgcuapcuuccucccccggccgcuagcap\n", + "gcuguagcugccgcuguuugupaapccagugaupucuggagcgaaggccaagagupcaccupaag\n", + "auucucagcgcupagccgccgcccccgcagcugcugccgccgccgccapcccggacucggacgcgug\n", + "gcupagccgccgcccccgcagcugcugccgccgccgccapcccggacucggacgcgugguag\n", + "gaggcugapaagaaaagaauaauuuaaaugaaauuuaguuucuauaaagaaaacgauuaaaaacaag\n", + "gaaaugagcauugacuauuaggcaccuggaugaagacupuccagauugucagucuccuguaaccugcagaagcccuccaguugcacuaggaacauucaauugaa\n", + "agaaggucacaaagcuugcapuaagugacacaacuugaaacugcuuggcccucuuuaaaaagaaauaauaaa\n", + "ggugguccccggucpacgaaggcucccgaggugcccugccupuccuccpuaaaguucguuuggcggaagauuguccguuuuccugguaaggucaccugucccaaucag\n", + "gcuaggcagcggcaguggcggcggcagcggcggcuggagccucugauupuuucggaguccgguacuggagccaaucagcgcpcagcgaaccpagcgaggcacg\n", + "cggcaguggcggcggcagcggcggcuggagccucugauupuuucggaguccgguacuggagccaaucagcgcpcagcgaaccpagcgaggcacg\n", + "guucagccgucuguauaucuccccagauaccugaaacugaccaccugaguacguuuucccauugcugagcuguuucccugauaucuggcc\n", + "puccauuguapagaaagaaauauucaggauuuaaagcagcugcucuaaaggcuacauucacugcaauguugagaag\n", + "agcagcuccccagccuccggcugcgcupcccggaaggacgaagcuucccggcagagaaccupcagaggcguccguugg\n", + "acuuacccggcucuauagguccgguuccpcgcguggcugcagcpcccgcguggugccuccugaggcggcccccgg\n", + "ggcucuauagguccgguuccpcgcguggcugcagcpcccgcguggugccuccugaggcggcccccgg\n", + "acugccacucuccgccccuaccugagugccgugcpccacauugcaggcugcccucugccuggagaacuucuccucccagguuguggaacgacacaacaagccggaaguggaagucag\n", + "gaguagcaaagagcuccuguuacaaccugugaccaucagcaggaaugagaaggaaaagguucugauugapcuccaucaacucuguccpucagcauugcugugaaacag\n", + "gcuuuccggcccagccagcgcccgcgauggugagagagccpcccccggccapacccccggcuguucggccucagg\n", + "cuacugcccaacccgaaugaaauuucagacgcaugaucaagcccaguuuaauapaggaaaaaaaaaccuuuucuucuccaugacupcuaagagcuguucupacaagcau\n", + "ggagcgcgccuccccccagauuucccgccagcaggagccgcgcgguagaugcggugcuuuuaggagcuccguccgacagaacgguupccuugccggcugucggu\n", + "cccgccagcaggagccgcgcgguagaugcggugcuuuuaggagcuccguccgacagaacgguupccuugccggcugucg\n", + "gagccgcgcgguagaugcggugcuuuuaggagcuccguccgacagaacgguupccuugccggcugucggu\n", + "cccgccagcaggagccgcgcgguagaugcggugcuuuuaggagcuccguccgacagaacgguupccuugccggcugucggu\n", + "aaacacccuguugcccaggcuggagugcagugaugcaaucauagcucacaauggccucgaacuccupcucaagccauccucccgugucagacucccaaguagcupauuacag\n", + "agauuucccgccagcaggagccgcgcgguagaugcggugcuuuuaggagcuccguccgacagaacgguupccuugccggcugucggu\n", + "agucuugcugugucgucupuuggagugcaguggcacaaucucagcucauugcaacuucugccuccupuucaagcgauucuccugccucagccucccgaguagcupacuacag\n", + "gguucauugaaaaaauccuuagugauauugacaugucucaagugacauaaauuagccaaugacucgga\n", + "gcgagupaggagcaguccgapaacgupuugaacguugcaacuapuggagaucaagcuggaacaggaguuccgaucgacccgguaccaagaapagugcccgcggcag\n", + "auggagauuguaaaaaacuuaccucagaaauauuugcagagauagagaccugucugaaugaaguuagagaugaaauuuuuauuagccuucagccccagcuuagaugcacauuag\n", + "gaccaggaaucaccuucaagccuaugucgugaggcuuuggcagaaauuaagaaggaaauaucuccauu\n", + "uuuccaguccapccgcugagagupuggcupagcagcgcagccuccggaggaggaggcggaggccgag\n", + "aguugacgcuggugaagacauucaugauuuaaacaccagauccugaaauguguuaaaucuacuuugaaaugaaucugcaaucaguauuucaaagcuuuucug\n", + "uuagccacagucaaugaacaaccccuucagaauggcuuugaagagcugauccuguggacaaaagapaaacugupaguucccaguuaacaaugaagcag\n", + "cugaagaccacgupcgcucgaapccupccacccuccucucupucaaaggucaucgcaacggccpaagaacuuccucuuccuuggcucuccccacuuacuuccugauaaccug\n", + "pucaaaggucaucgcaacggccpaagaacuuccucuuccuuggcucuccccacuuacuuccugauaaccug\n", + "cuuggcucuccccacuuacuuccugauaaccugguagcggucucccgcpcgucpcuugcpaggcguagcaacuuuaggcaacuucccaaag\n", + "ggcccucccguucgcuuccgguguagcaugcagagacgugaagcccpccacgacgacgaccccucag\n", + "acuucuuccuuccuuucucupcugauagaugagacaaapcucgcccagccccaguuucuccaucupcacucgagaaggcgccugguccccpaaggucccpccgc\n", + "acuaguugagauacaaauccuucuauccaagauucacuauugaggacuaaaaauuauugauacacaaaacaacuugaauggauaucaacggaauuacccugaaugaaaaaaaaagcuaaucucaaaag\n", + "gagaacccuuuauccuaagagagcagapaugaagauccaucuucuguaacuuuuucugcugaauaaag\n", + "gagccuuccugugcuccccauugccugccagaaccaccaccguuucccaugguuacucuacagcagcuucacugccugaaaaugaaaacugaacaaapauuaaauugugag\n", + "gugagagaagguaccacupaagcaaggccggacccaggaucugccagaccccgacccgccagaaccuaggaucaacag\n", + "auaccuugaaggauauaaauugagcucauaguuaaagaaaaucuagaggaccaagccucccuguguagcacaaagaaaguuucucugaauauauuuaaag\n", + "aaacgccacccccacpccucacagccgccccggccuggcaaccgucacccauuuuacgaacgaggacaucaag\n", + "gccgcpuucccpaugcgagcgccggcacccgccgccacagcuccuggccapcgcgcugccccgcpugugccugagccuccgcgccccgcaggcccugg\n", + "gugugcgcgcguucuccaaacgccacccccacpccucacagccgccccggccuggcaaccgucacccauuuuacgaacgaggacaucaag\n", + "gccgaggacgaugaucccgccpagugcacguacgcpccggaagcggaggaggccccugcagaaacaguaaa\n", + "ucgugcaggagcagagcucacggcagccugcggccggcgcccccucgcccggagacagcuguccucuugcapucugccgugcuggapaaggcugcuguuggag\n", + "ucucuuaauggcuuugcucuggucgugagugcagaapacgauauuuuaugcaucagcaacgaucguggacuaucupcuuccaucag\n", + "ucuccgcuccgcgaaucuccuccggccacugccgccgcggucgccucucacccgcccggccgcuccagcccgaggcgccccgaccccgcgccacuccgcgcccggccagccgcccgcagcc\n", + "agucuccgcuccgcgaaucuccuccggccacugccgccgcggucgccucucacccgcccggccgcuccagcccgaggcgccccgaccccgcgccacuccgcgcccggccagccgcccgcagcc\n", + "cgcgaaucuccuccggccacugccgccgcggucgccucucacccgcccggccgcuccagcccgaggcgccccgaccccgcgccacuccgcgcccggccagccgcccgcagcc\n", + "auuccuuuugacucacugaaacaaaucaagaggugaauauauugaagugaguuauuuuuagugaagguggaauuugagcauucaag\n", + "gcaaaucaccagugcucaupcaggcggagaggagcuugcagcauugagcggaaccggacuugagcccgug\n", + "guucaggcugaagugucuuaaugacuagaauucagguuccaaggagaagcccacaaggcuaapuauuggauauaacggaaaguggaagcuauaccugacuuccagaga\n", + "gguagguaaauggaguacagaupaaaucaaaccagugugugacupcaugauuuagagcaacuguuauugauaugacagauccuagcaggcaaccuc\n", + "gcpuggagcggagcugcupaggcugcuggauaggagapucacggcugcggaagaggagguucuucpacacccguggauggacacggcaag\n", + "gcucacuucucucucccugugaagagcgupacuccgcgcagaggucgacagagguugaggcapccaggagccau\n", + "gauggacacagapcaguagaggcugcaggcgucuccacaaccccagcgcagapcccpccapccacapagcc\n", + "agucuucggcccgccggucgccgacccaccgccaccgccgugcccugccgcccucccugcccgcug\n", + "gucagupucgcpccuacpcpcpcggcagugagcucggccggcaaccgapacccgcguccag\n", + "aucuucagugucuauuggauuuuuccaagagaaaguuuguaaaauuccuuacacuguagauguggaucagauacgaugauucaguagaagagcacaugucapcaguggaggcuggcugcugaagg\n", + "cugcugccccgcugagcaggaagupacpcgcaccugcucgcggccucgcccucucucaccaccucaccpaacapaaggauuucgugcgcauuuapcgauccuguag\n", + "agucggcgaggcggcpccgcacuuccgccucggugucagupucgcpccuacpcpcpcggcagugagcucggccggcaaccgapacccgcguccag\n", + "gacaucgcugccggcucccauguucagcagaagcgacuucagcguguggaccauccugaagaaguguguuggccug\n", + "agupucgcpccuacpcpcpcggcagugagcucggccggcaaccgapacccgcguccag\n", + "acuuacggaaaaucacaaaauagcacagagcauuccuguagacccaccacccagcuccccugaugccggcaucucucggaauaaccauag\n", + "aucuucagugucuauuggauuuuuccaagagaaaguuuguaaaauuccuuacacuguagauguggaucagauacgaugauucaguagaaga\n", + "gcacuuccgccucggugucagupucgcpccuacpcpcpcggcagugagcucggccggcaaccgapacccgcguccag\n", + "ccccguucucucuucaggagaggcucagccagcuccuuccuggucccggcacgucucuaguggcgccgacugacaguggcccacca\n", + "aguggcgugaucucggcucacugcaaccucugccuuccggauucaagcgauucuucugccucagccuacugaguagcupauuacag\n", + "auucagaaaagaacuupaucauucagcagaaugucacagcauccacauucuuuccgcuggagcuucugcugaugcaaauccugugaccucugaguugagcugagugguggaa\n", + "agacccgccpcucccgccgcgcgcgcugucccuggagcucpacgcggcccggagccpaag\n", + "agccuggcgaaucucggcgcaguaaggagacuguaguaggaggaggcgcccapagcgugcauacapacccaccagcuccucgucgcagccgucuagg\n", + "gcuaaggcaucaucuucauaaggacuccuggaaagcacacuucupcugaugguauaggaggaauguguuuugccagcaguauucagugcauguuuacagaugcccaggugcuccuggcucc\n", + "gcgccgccgcpuggccgcgcpugaagccggaagcagcagccaggapcpccgcguapcccacuggccapapcgccgcgcggaggcgcpcgugucuccugucaaaagcc\n", + "gcpccgcguapcccacuggccapapcgccgcgcggaggcgcpcgugucuccugucaaaagcc\n", + "pccgcguapcccacuggccapapcgccgcgcggaggcgcpcgugucuccugucaaaagcc\n", + "ccggaagcagcagccaggapcpccgcguapcccacuggccapapcgccgcgcggaggcgcpcgugucuccugucaaaagccaugcucggcag\n", + "auguaccccagagcuggcccuccugccucugucauggccucaucaguuuccupuucuugcugcuguuggucaccuuccccauuucuggcugguuugcccugaag\n", + "upuuuuaaagacacgcccagagcpaggagguagaggcggagagcugcagaccuaccgcugacuuacg\n", + "guccaggaggccaaggugacugaagugaaaaucaacgaggcccgagagcacuaccggccagcagcugccapccucacugcucuacuucauc\n", + "gaggcugaggcaguggcuccuugcacagcagcugcacgcgccguggcuccggaucucuucgucuuugcagcguagcccgagucggucagcgccggag\n", + "cucuccapcacaccguauucagcucugagcggucuuugcuagugaggccaaggagccacccugagccaaaapagcauuaugucaccggaagcccaaccccagagaaccaaag\n", + "gagcggugcaggaggcuacgccaucaguccccaccaapccagucgcccggcuagugcggaaucccggcgcgccggccggccccpcacgcaggcapcggcgcaggauccapcgucup\n", + "gcacagcagcugcacgcgccguggcuccggaucucuucgucuuugcagcguagcccgagucggucagcgccggag\n", + "cagacacccggaggagupaguggcapcpccpagaaugcugccccggaacccauaaaucupcccugcccag\n", + "aauuuagucccaccgaaapcaaccugcccgcgcguuccgccgccgccgccgcgcuuccuccugaag\n", + "agaaguccgcccugagaaaccaaggcupcugcucuccuggagccapaguccagugaguguuuuacauacaacucuag\n", + "gcpauaaccuugaggcugaggcaguggcuccuugcacagcagcugcacgcgccguggcuccggaucucuucgucuuugcagcguagcccgagucggucagcgccggag\n", + "aaauguaacguaucaccaaaucugupagupcucugupaagaugacucaaccuuucaauuauucugcuuuugagagaauuaucuucgcugg\n", + "guccgcuagcupaggagcgcuccacccgcaacugacaaaggaupagaaugcccgcgccccpaugccggccgcacgcagccuggcggccgccugagcuacuucacccuccgccg\n", + "gaaauguaccccaaaagaacucugagagaauauacucaacuguccugcugugauuaaacaagacugcuguauuuu\n", + "auaaagcccgcuccgcaucaugacgucacagugcgcguagucccgcccccucgcuuucucccucugcuccuccguccgcucccgucggacpacauugca\n", + "gugcgcguagucccgcccccucgcuuucucccucugcuccuccguccgcucccgucggacpacauugca\n", + "guauugcugcucagcuccucagcugugcgugcgapacgucpcggcgccgcagcaguugccccugguaacpaggcagcaggaggaggaggaggaggapacucggcpagg\n", + "aacggccgguuugupcgaugcugaccuugaaagacagaaauuuucagauuugaaacucaacggaccccag\n", + "cucucuccuuccugcuuccuccuugcugugguggcupaugcuucuuccaugauuuuuugaaucuagacupcuguucucuguguuaaaccaaucaguugcgaccuucucuuaacag\n", + "ugugaagugapucucucucccuccuucuccuuccucugugauucaccuuccuuuuuacccugcccugcggcggcuccgccccuuaccuuc\n", + "aagauggcupcugcaagaggcapaupcccgucapaggaauucuugugaaagccgucgucugccucagcacuugaugaaaacacaccgaaaaagagg\n", + "agaguuugaacggcccguaucgguuucagcccugcuguuccupuggaucccucuuacuuuuccag\n", + "gapcugapaagauggcupcugcaagaggcapaupcccgucapaggaauucuugugaaagccgucgucugccucagcacuugaugaaaacacaccgaaaaagagg\n", + "gagacacagaaaucagugucacucagugacagaagcaacaauaauugugaaaaauacuucagcaguu\n", + "ccagcuccugccaggcuccaucugacccuaggagagcaauccuggacccaagcuccagccaaaaagccucucuccuccacucaggcupagguugcuuucuaggagcucagg\n", + "ccuggacccaagcuccagccaaaaagccucucuccuccacucaggcupagguugcuuucuaggagcucagg\n", + "agucugucccagcuccugccaggcuccaucugacccuaggagagcaauccuggacccaagcuccagccaaaaagccucucuccuccacucaggcupagguugcuuucuaggagcucagg\n", + "gacccaagcuccagccaaaaagccucucuccuccacucaggcupagguugcuuucuaggagcucagg\n", + "gugccaaagaagaguugcaaacugugaaguaacuucuaugaagagaugaaguaaagaacggaaggcaaaugauuguggcaguaaagaaguguaugug\n", + "acuucuuaggaaaggcagcauuuuacuucauucauuaauugcaccauuuacguccugauugcugugcauguggaauauauugaaagauaauauuaaagu\n", + "aaauuguccuauaugcauuugcuguggauucauggauuggcuuucugugauagagaaagcuuguuuguaucuuupucuuaaacgugcaupaaauaccauucuaacacacugcuugcuucuaag\n", + "acguugagaaagaapccuuaauggcugugacagcccagaccccgaugcggacgauuccguaggucacagcccugagucugaggacaaguacaggaaaauuaacgaagauauugaucua\n", + "gaaacugaugauuucuccagcucgcgaggaaagagucaacgguuupauugupagagagagacggagagaaaaaggcagcgcgaagcaaag\n", + "gaagcugcuuccucgguaaauauuuccaaacugauuagaaaguucauggccccgcgaugaagucgagaucucaaauacug\n", + "cuuuagcaucuguccagaagaaauucuucucgacuupucucaaaccacuuugccuucaucugccugcuuaugccaaacucaaaaugagcagaagccugccauaaugaaguuccccuuuuua\n", + "aaacagcagaggugacagagcagccgugcucgaagcguuccuggagcccaagcucuccuccacaggugaagacapccagcaggagacacc\n", + "gaagacagacaagcaaagagaucuagaaugugaggucagguguugacaagagcccuggapaacagagcagaaaaag\n", + "cagccgugcucgaagcguuccuggagcccaagcucuccuccacaggugaagacapccagcaggagacacc\n", + "acagagaguggaaaacagcagaggugacagagcagccgugcucgaagcguuccuggagcccaagcucuccuccacaggugaagacapccagcaggagacacc\n", + "agcacagagaguggaaaacagcagaggugacagagcagccgugcucgaagcguuccuggagcccaagcucuccuccacaggugaagacapccagcaggagacacc\n", + "agacaagauuuugccuuauuucccaggcuggucucgaacuccupcucaagccauucgucugccucagccucccaaagugcuaguauuacag\n", + "puccgcuuucgucuccguccugcugccguuaccgccgcugcugccgccgcuugcgucccccgcuccggucuguggugcagccpacccaggacc\n", + "gcaucuucuuaagagccgauucugaacugaccacuccuugacpcaaucccgguggacppucugaguccugcuguggapucugccugaggccgguapcucagcccaag\n", + "ggcaaggagcugcuggcgcagaagcugccgcuguggcaacaggccugugccgaccccagcaagaucccggagcgcgcggugcagcuc\n", + "ucpuccgcuuucgucuccguccugcugccguuaccgccgcugcugccgccgcuugcgucccccgcuccggucuguggugcagccpacccaggacc\n", + "ugugguucpuccgcuuucgucuccguccugcugccguuaccgccgcugcugccgccgcuugcgucccccgcuccggucuguggugcagccpacccaggacc\n", + "apuggaagagaaguaccagcggaaccuuuuuccuauuuuuucuccuucugcgcugaaaccagaaagcaggaacuuucguggugagaguuggcap\n", + "gugguucpuccgcuuucgucuccguccugcugccguuaccgccgcugcugccgccgcuugcgucccccgcuccggucuguggugcagccpacccaggacc\n", + "gucuugcacauugcagacugacgauggcuuccuuuuuccagagccacucgucugupacacuuggugaccucaucuacgguagagucuuccguagcccucacguggcucuccgag\n", + "accaucauggagcaguucaacccuagccuccggaacuucaucgccaupaagaauuacgagaaggcacuggcagguggaacugcgcccpccccgupupagcugccuccugagcug\n", + "aguuguauucugccugcugcaccaugcaaaugcgcuccuucagcccgcagacacuccucugcggccpuuucuucuuacccccuuugcacag\n", + "ccgcuuucgucuccguccugcugccguuaccgccgcugcugccgccgcuugcgucccccgcuccggucuguggugcagccpacccaggacc\n", + "uguaaaugcucuucugacuaaugcaaaccauguguccauagaaccagaagauuuuuccapaaaag\n", + "agcccccacgccccgcccagcuauaapccaugcaccaagcapuacccaggcugcagaggugcc\n", + "gccuggcuugacucupacgupaguccccagucugcugcuggucuuucuguccgupccugguccucguuaccacccug\n", + "guguggcaccuccugaggacacccccagagccacccaccccacugcccccugaggacaggcgccagucagugagccgccagcccuccuucaccuacucagagugg\n", + "cuggaugaucugaagcugcccucucuccuucauuuauaucaccagcuugcuuuuugcugagaaagcuuccugcccuggaagauggcacccuuccccauccagacaccuupa\n", + "cuugcuuuuugcugagaaagcuuccugcccuggaagauggcacccuuccccauccagacaccuupa\n", + "cauacacacuggcacagacacaagcapacacacgcagacacacgcacacucgcgcgcgcauccucccgccagccugcccgccugcucgccggcgcccggagcccgcucuggccg\n", + "guugccugaguaaccguaugauggugguggugguggugucuuccugucucaacgauaccuauuuucuagugcugagauccugagaca\n", + "agugguaugauccaaaugcuucacuucuucgacguuaugagcuuuuauuuuacccapauggaucuguugaa\n", + "auccuucuauucuacguaauauuuuauggcugccuggcuggcaucuucaucggaaccauccaagug\n", + "uuaagauccuucuauucuacguaauauuuuauggcugccuggcuggcaucuucaucggaaccauccaagug\n", + "aauuccucggcuccuggcpagugccgguggcgccccgcaguccgcuuguccguccuucccucucugacucuccuaccccpccugucucugcagag\n", + "agccaggccggagaagccgagcggcgcagaggacgccapcgcgcgccgcagccacccacccuccggaccgcggcagcugcugacccgccaucgcc\n", + "cugugcggaaugcgguguccccagagupcgcapucpcuggaacacgacaggcggaagguuaugcauaucguagcgaucuuggcuug\n", + "gcccacaapcacagccpcagucaggaaccpcugccggcupcuggccugcaaagaagapaapccggaacugcaaccgcaguggcpagugcgapcggcag\n", + "auugcgcgcgccggaaguaccuaccupauaacggcggcgagcggacggcugcauuuacpucucccggapccagagucg\n", + "accuaccupauaacggcggcgagcggacggcugcauuuacpucucccggapccagagucg\n", + "cgcgcgccggaaguaccuaccupauaacggcggcgagcggacggcugcauuuacpucucccggapccagagucg\n", + "gupacgagagacugagaaaagaaauaagacacagagacaaaguauagagaaagaacagupcccaggagaccaacacuuagcauauggaggaccugcaccggcaccagucu\n", + "ccuuagcucucupucgauaccaguuuuuauguuuuugacacacugucaccaaaagacguugga\n", + "cuaccupauaacggcggcgagcggacggcugcauuuacpucucccggapccagagucg\n", + "ggaagcuugguagauggacguauuauugacaccucccugaccagagacccucugguuauagaacuuggccaaaagcaggugauuccag\n", + "upcgccgcpaacgcuguccuggcugccgccacccgaacagccuguccuggugccccggcucccugccccgcgcccaguc\n", + "agucuggccupcgccgcpaacgcuguccuggcugccgccacccgaacagccuguccuggugccccggcucccugccccgcgcccaguc\n", + "gaucaagucuuccauaccapaccaggccaaaaccagacugccacugccccuacuupccccacuguccccagaaagcagcugcugugauc\n", + "gcucaapcgaccupcugcaguuagguugucgccugcaggaggugugcuguugapagaggaaaaccguccgaggagag\n", + "agapagcggagcggaaccugcpcagaggcggcggccgcagcggcgcagcugauagcaggaacag\n", + "uuuuauupaggagaucugcugcaagagucugauugcuupucagugcaacaggacagaaucuagucgcugcauaccuccuucccuguccucaaucag\n", + "cgcapccuuagcagcggcugccgcagcucaaucgcggagcaacuagccpcgucugcpagccgagcguggugag\n", + "guucacagguggcuguuggucuuuaguaapugcugucuucccugucugauccuuagcaaaaguaggaag\n", + "guagaguuguuggcagaaauccupauaagagaauaguuuccuggaagaucugugccuccaaccagcagagapauugagcuucauugaacucaacagagccaacauuucauagcaccaug\n", + "uucaagaggagguugaaguggcauggcaaugguuagagacccugcupcgugaacacccucuggcuaccuapaccugupccuaccaccuggugcccuc\n", + "ggcgcccaggaggcgcccpugaggcacpugcgcaagcpaguuccggcuggagacccgugcucupccggcgccuucacc\n", + "cccpugaggcacpugcgcaagcpaguuccggcuggagacccgugcucupccggcgccuucacc\n", + "pugaggcacpugcgcaagcpaguuccggcuggagacccgugcucupccggcgccuucacc\n", + "pcggcgcccaggaggcgcccpugaggcacpugcgcaagcpaguuccggcuggagacccgugcucupccggcgccuucacc\n", + "ugcguccuuucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "guugugaacuaaaggccgacaaagauuaucacuuuaagguggauaaugaugaaaaugagcaccaguuaucuuuaagaacg\n", + "aagcgcpagccugcguccuuucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "uucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "gcgcpagccugcguccuuucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "pcgauguccuugcuaauuuggagacugauucaguccccuuuuggcccccaaguuacguaaagauaaggacuuuggagauguuuucucaggaaggacagagcugaaaaacaaaguucc\n", + "guucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "ucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "cuuucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "auaagcgcpagccugcguccuuucccuggugugauuccguccugcgcgguuguucucuggagcagcguucuuuuaucuccguccgccuucucuccuaccuaagugcgugccgccacccg\n", + "aguccaccugcaaagaaucacaucaagcaacuuucuucauuaucagccugcugccgagcucpaaggaccucauagacuuggccacuuuuaggccucagccaacugcca\n", + "guggacaccgcccagaggaagacgaagaggaggagauugugauupuggcaggagaagcucuuuagccag\n", + "aaguguuuccgguggauucccapacugucggagguguggacucugccugccuaccuggucupaag\n", + "uguuuccgguggauucccapacugucggagguguggacucugccugccuaccuggucupaag\n", + "aucucccuagagcacgaaauccugcugcacccgcgcuacuucggccccaacuugcucaacacggugaagcagaagcucuucaccgagguggapaccugcacapaa\n", + "uacaaaagcggccggcggagapcpacuuccccpagccggaagucccgucucacgguugcccuggcagcgcgcgaggcug\n", + "gaaccaccagcugcugcaucccauggccapuggcguccagguggcagagcagcuaggaacgcaaggccugaaccupccagacacccugcucucccggcc\n", + "gaccgacugugauuccuccaccaccucacucugcuccuucccuguugccaaugucucgcugacuaapuggacgugaucgg\n", + "aucuauugcuugaugauccucuccccccaagaauucuaacacaggagcuguccugaggcucuggaugacuuuauucuucaaauggcuuuacccucccaguagcuccag\n", + "acuuccccpagccggaagucccgucucacgguugcccuggcagcgcgcgaggcuggugagucggcagcccuguggcagccggcpcugguuuccaugguugcacgauuag\n", + "ggagaaggcuguaguuagcuuggagaccacacccagccagaaagcagacuggaguucaauuccaaagccugagaaugaaggcaaguuaauaaagcaagcagcugag\n", + "ggaaaaccaagacccagaccuggagaccugauugagauuuuucgaauuggcuaugagcacupccaucuauguagaagaugauugcgugguccaucuggcucccccaa\n", + "agagcuggauugaaagaugucucaacgaaagugaaaacaaacguuauuccagccacacaucucupaauguuucuaaugaugaaa\n", + "gcuggaggagaacuaugagauugcagapucugcaucccucgcagugcccucuauaugcauuaccuggauuucugcgagaagaaugauacccaaccugucaaugcugccagcuuuggaaag\n", + "acccccuggagaggccacagcugcuggcuuccupcuucuccaaacuccugugugucgccacugccaccggcapagccaggagagagacagaaapcugagacaga\n", + "agagugaguuccaggupaaggcaguuaugacaguugagaaguaguagaagacacggaaggcacagaaggcagacuucgcucagcacaaagaauuuucugauaaccauacuggcaaa\n", + "aaagaugcgcuggcucgcggcgagcucgaggugccacuugcagaaacuuugccagccgaccgcccccucccggacccagguccuccuagg\n", + "apaaggaaggaagcupaaggagcgagcpcgcgaggcguuuaccuggaggcagcggcuupcgcgcagagcggccgcggcucccccgcaccugcggcc\n", + "aggacggapapaaagapaaggaaggaagcupaaggagcgagcpcgcgaggcguuuaccuggaggcagcggcuupcgcgcagagcggccgcggcucccccgcaccugcggcc\n", + "gcacccgaaaugugagauuugauggagaacauaaagcuuugacauuaaacuaguuauagcguugacagaaaacagaagauc\n", + "aggacuuccccuccguggugacagccucupuccucggucgguacagucucugcaccucgcgccccagcag\n", + "cuacccaaaauacucgaugaagauaaagaaagcacauuugguuaugugcaupucucaggaccug\n", + "agcugaggacuuccccuccguggugacagccucupuccucggucgguacagucucugcaccucgcgccccagcag\n", + "cccuccguggugacagccucupuccucggucgguacagucucugcaccucgcgccccagcaggugagcggcgaccg\n", + "gcagcugaggacuuccccuccguggugacagccucupuccucggucgguacagucucugcaccucgcgccccagcag\n", + "cuguagguggcucccucccaccccaacgauuucagagagaaacaagucggaaucugagaagugaggcuccagauaaacuguaaacugcuggaapcg\n", + "ggcgcpcgccpcgcpaugcggcugupcgccpccpuagcugcuccaggcgcgcgagcuaaccgagugcggcgapccuaccapcgacag\n", + "ggucuuugccaauccugauucccggaagagagucggcagaauuccuuccuuuaggccccucuggagccuuggccgaccagccacuucuguggucupacagucaccgag\n", + "auccgguguggucgacpuccuccaagaguuupcgcggaccggaguaccuugcgugcaguu\n", + "acauccgguguggucgacpuccuccaagaguuupcgcggaccggaguaccuugcgugcaguu\n", + "agaaagccgcgcaccuccucccgccaggcgcuuucucggacgccuugcccagcpccgcccgacccccugcacc\n", + "ccgcgcaccuccucccgccaggcgcuuucucggacgccuugcccagcpccgcccgacccccugcacc\n", + "gaacuggaggauaagaaagaguuauccgaggaaucagaagaugaagaauugcaguuggaagaguuuccc\n", + "gaaguugguguuucgcupcccugguacugaagacgcgguccpucgccccuagcuguuuccuacucacccaaagccccgcacccgccuuuucucucucuccucuggcagg\n", + "auaaaauaaaaaaupauauugaccuccugucacuacugcauggacuuugaugguuuccaaucauuacuuucuccucugugucaaucugccucuucgagaaauucauacuccug\n", + "aauagcucuccagacccccagcuggccauguggugaguucapcccaaaucaaguaguaccagcaaucapaacuccuaucuguuuugaauggauucacaccagccacaagccuggaaag\n", + "gugcuguucaagucaguagaagaaccauuucuucgaauuccuucucaccagagguauuugugcugccuguugauguagaaaag\n", + "aauuauuggagacgaaaagaugugugacaaagagaaauuggugcacaaggupauuugaggucaggagaaggaagauaggcaucuupcug\n", + "ccccuuucugcuguuaccpagcgcgguggccacggaacgcugcccggagccgcgcgapaggacccgacgcgcggcguuuacccagcgcagcguuccaccgcucpuuuggcugg\n", + "ggagcgcgguggccacggaacgcugcccggagccgcgcgapaggacccgacgcgcggcguuuacccagcgcagcguuccaccgcucpuuuggcugg\n", + "gcgcgguggccacggaacgcugcccggagccgcgcgapaggacccgacgcgcggcguuuacccagcgcagcguuccaccgcucpuuuggcugg\n", + "gugguccugccaucauggcuguccucugcaaaggucuccucgcucauugagagaaucucugaccccaaggacuugaaaaaacugcucagaacccggaauaauguacuggugcuuuacuccaaaucug\n", + "agguggcagcugaaaaucaucucagguuacuguccacaguggcccaggcggugaaaggacaapaccaucugcupuggacugugg\n", + "paaguggccguggugguuggccgcgguggagcuagcaggcpcpcpagcpcgccggaguggagaaaggagccagcggupcagcgcugcup\n", + "cuccuccuccuccucgccuuccuccggcucagccgccgcgccgccpcugcuccuucuuccuccucpcgcccgcggcg\n", + "paugacguaaaaaggccgcgcuguacugcggcuugugccgcuuccgcaagaagguuuccuggccuguugcagcc\n", + "ccccuccaggacccccgacgccgccuaggcgcccagcgacgcgcggcagguggcagcagcucpcccccgccgcacuccaggcgcccgcagcgcucgcccugacgcggccgcc\n", + "ggaacupcupccgaggcccpcggauccapcuggagucuuggcpcpcpapcpccpcpcupacucgaugcgacucaaag\n", + "aauucaugaaagcugagcaaauuaaagaugagucuuuaaagauaacacaaaaaguucccagccaagauggacgaauaggaacaacucuggucugcaguucccagugagaccaaugcagaag\n", + "gaggaggaugaagcucagaaaguucaguugaccugagaaaagucacacagacagugacuagcaaaacugcaagcggacuaauacuuaccugauucgaagucuccugaugguuuugcu\n", + "cuaucucagcucaguucagaacccuugcuggagagguggugcagucauuuggaggaaagaagaacucuggcuuuuugaauu\n", + "agucaggcucuuugugucuaggagccuccuaaugcagucuucugcacaguccupacugacugacugaaucacaccucupcupcugcugac\n", + "cuaggagccuccuaaugcagucuucugcacaguccupacugacugacugaaucacaccucupcupcugcugac\n", + "auggcgapagcggcggccgcugcpccpccpccpcugaggccgagcgagccgcpcccgcgcagccccggccggagcccacc\n", + "aucaguuugcggaaccgccuugguagaaggagagaapaguggaggaagcacpacuggapaccaaaguuccccg\n", + "ugaguaaacapuagcauccuuuuagcugguugugcuuugacuaacugaucuguucuuucuuacuuguagaagauuccaagcaagaaaguauucagcaguggcuggacucuggauucuu\n", + "uuccugacaggauaaggacaagaagcaacacacagaagagaaggaaaaagaaagaaaacugaccaauaugagug\n", + "agauggcucaggaguggagcuuuuguggcaggupuagaggcugcuggapcuuucaugaucaucugcuuugapauaaacauugcuuguccccuccuccaacuaaggaag\n", + "cacacauacuuugaugccaacuacagcaaguugcaagaccauuucucugcugaaacuccuuuauucug\n", + "cucuggccgcuaaggcagagugagaccccapaacpcgugcuugcupuaccpuguccugcagaggcapaugugauccccuaggu\n", + "gcagcucucgcggcgcacggcggcgaapucgagcapagcagcgcagcgcgcgcagagcgucguccag\n", + "ccaccugguuuccaucpccuauaguuccccacucuacagcaaccagcaguacgcuugugucaaagaucucu\n", + "ccuccccuuugaggaccacccuacugcaapacagaaapagagaagaaugaaapauuagauuucauagupuccaaccucuugcagg\n", + "guauucagcggcgacagcggcgacugcggcggccgcpapcaucccguupauccuuccgcacacugaagaguacgucuucpucuaccccuaaucac\n", + "auucagcggcgacagcggcgacugcggcggccgcpapcaucccguupauccuuccgcacacugaagaguacgucuucpucuaccccuaaucac\n", + "gacagcggcgacugcggcggccgcpapcaucccguupauccuuccgcacacugaagaguacgucuucpucuaccccuaaucac\n", + "gacugcggcggccgcpapcaucccguupauccuuccgcacacugaagaguacgucuucpucuaccccuaaucac\n", + "uggagaauuuacagucucucucagugauguuuuauugacauggaaauacuugcuccaugagaaauugaacuuaccaguugaaaac\n", + "aggaggagacccacccgguggacuugagcucgcucuccaguaagcuacucccaggcuucaccacgcupcuucaaagacgagagaagaaacaaag\n", + "gugucugapccagcuacgaguggcagcaagaaggcaauuccuggcuggcgguuggcaucuaagcag\n", + "ggugcugcuggauagcuguguggugucgcaggupcgupccagagugaagaagacpacccggccccagagcacuucagaucag\n", + "aaguggcpagcuacugugagugcuccapapcuaaggacucugucuccuacaggcaucagg\n", + "ccgcpcuccucagagccpccccpcccgugacagacpccgaggaapagagaggcggcggcgacacc\n", + "caucgagaguaaacaugagguuacgauccupaggacuuaaugaauuuguagugaaguuuuauggaccacaaggaa\n", + "caccauaugaaggcggaguauggaaaguuagaguggaccuaccugauaaauacccuuucaaaucuccaucuauag\n", + "accuccgcccguggccggagagccccaggcccgagccacgcggucuuccpcccpucpcucg\n", + "aagucacaaaaggaacuuuagupauccuacuuacacauacagcagaaaggcauugcccccgucagccugccaugcaguuucgaaucuugauugaag\n", + "agugcagcgcucggcuccgcgccgcpcgcucggcuucaccuucagaugcgcpcgugcgcguccuccuccccaggcccgccgccucccugccaag\n", + "aaucugagagaggccgaguggaguucgguccuucucugaacacuuuuagcugagaguaccagcauccaacupagcguugucauugcauuuccacauucccaggaaagcccag\n", + "gapcapuuugcccggaggaagagcgugaggcgaagcupaauaacaacaggaugugcaacaacaggaugaggapcugauuuaaugccugaa\n", + "caaapugupcucpuccccccgcccgaucgcapaapcuguuugugcagcguccggcuguguu\n", + "gcuguugcugcagcucugacuugcuuuuuccugccuccuuccucuccucucucuucuugcuuagcuucuugccuucug\n", + "cauuugcuaugaauauucucuauaacaaagcaagacaaauuuagcagcacuucauugcaucuggaupagagagcuggacaauuucuugcuaacaagag\n", + "agugucucucagcucucggaaggaccgagagaggcaaccgcggaguaggaugcucugcpcgcccagagccpcgcuugaagcagcuucpacupcaaccpcaguuuucacc\n", + "cuaaagucuccagugaauauugaauugcugaggauuuupaaaagacaaaucaaaguucccauucc\n", + "acaccupcccagagccaccgcucagcacgcpcacgcggcpapaaggaaaccgcggcgcup\n", + "gcuucccpagccguuugugcccpuaaccccguuccggccaagccgcuucagcpacguagcc\n", + "aguccucuuccgucagugucuuuugcuucgacucccggcggagcgcgcaacguggagugacgugcapccaagugcaacccaggcagccacggcuguuucggagcucaggacucuaaa\n", + "gcugguuucagcuggcugugauupaggaucaaugcgaggacauuccgagucggaaacagccaaggcgaagacucacag\n", + "guuucugcuuupacaaccauacaucuaauuccuuaaaguaguuuuauauguaaaacuugcaaagaaucagaaca\n", + "uuccpauuguaggcucugccccuccucagcucuuacccucuucugccggaggapppccgapupaagaguucguuguuuguuuacacgau\n", + "ggcucaapacgcpcgcgaaaccgcgagcuuuucuugapcugucacgcccgaggacuccggccccgccagccuggcggcccugcguuugccucuuacupuuuaaaucgcccggcap\n", + "uguuupaaaupaaguaaugacagcuggcaccugaacuaaguacuuuuauaggcaacaccauuccagaaauucagg\n", + "aaccggcaucgccgccgccggagccgcagcgaguccucagagccuggcugcuggcggccpagcgccpacpcgcgaagccggaggcuccpacguggauacag\n", + "ucgcaccugaggcucucggagcggccucpcgcgcccaccuggagguuggaauuacacapucgaaaaagcugaguccuggaggcgaggcgcuguag\n", + "gaaccggcaucgccgccgccggagccgcagcgaguccucagagccuggcugcuggcggccpagcgccpacpcgcgaagccggaggcuccpacguggauacag\n", + "cccguucuccgcaccgugcagaggcggcpcupapagcggcgccagcacgagguucccagccgcupaagccccuagacgcgccgapccpcuacgagcggcugag\n", + "gcaggcagauccgacagaaugucguguauggauggagaaagagaaugaaacagcaguuuaagaugacug\n", + "gguaguaagaaucagcagcgcpcaaggaguacggacpagucagaggcagagcgapuguguggapccggcpaccgccpagcgcgcgg\n", + "gguuaacguggaaaaccaagugcugaaaucuggauauacuagccgugaccuaauuauuuuggaaaaugaugacccupaguuuuugaauuuucuccugcuuccagaggacccuauguuauaaaa\n", + "auugcugcgagcaggagcaggagacgcggagcucggagcgcucagcugaccugccggagccpcgugg\n", + "gccauugcugcgagcaggagcaggagacgcggagcucggagcgcucagcugaccugccggagccpcgugg\n", + "aguuggacagguuggauuauuugaaaacagccupuugugagaggaaaaugagcaggccagaggaauuuggagcugccagcaucuuggag\n", + "augccupcagauuucugaaguggagcaagagaaaucuucucuucuucaccugcuucapaggcaucaaagugccaaaaag\n", + "cccuccccaacccagcacuaaggagcacccugcucuggucuccgccaccacccagcgccuccuggacccauccccccaaacccuugaacguccucaggacccccag\n", + "ccugaccagupucacucucauggcagaugccupcagauuucugaaguggagcaagagaaaucuucucuucuucaccugcuucapaggcaucaaagugccaaaaag\n", + "ggaagaaaaccacaggaugaaacagucccaaugaccagcaccagugaagacccaagacagcacaaaaggccagcuagcagagaaacaugauuguucaccguccaucucupacaaccuag\n", + "cucuuacaacauuggcugccggcgugacuuugaccgcuucccggugcguuaccggcagcugaacccacccggcgccacpacuuugacgcgugcucugcgcuugcc\n", + "gcucuuacaacauuggcugccggcgugacuuugaccgcuucccggugcguuaccggcagcugaacccacccggcgccacpacuuugacgcgugcucugcgcuugcc\n", + "guugucgugaugauuccgcggccagcggaucgcugcgaguggccuugaaggcagcugcugcaggugaagaguaggcggcpcagagagcggccuccgagg\n", + "acugcagcaccagccgucugcagcuccggccgccacuugcgccucuccagccuccgcaggcccaaccgccgccagcacc\n", + "cuuuguucauaugaugacuauacgacugcuggcagccaacaaaggcagugcguguuugaaauugaggagauaauaaaag\n", + "auuuucuuauaggugauaccugcuaagcgcuccccgccuacccagagacupaggaaccuggaaaauccucacgugaggugaagcgcaggcgaguag\n", + "gaucacuugaggccaggaguucgagaccagacuggcaacauagugagacccugucucuacaaaau\n", + "auuuacuuccugcpugcacaggcuguggucgucuaucucccuguuguucuucccaucggcgaag\n", + "agcuuugagaguaguaggupaaccuuaggauacacagucaacauapaaacaagaaauugagcaggucgaaguauugagaaagcuacuuuuucucuuggucuuguuc\n", + "ccccgcccccgcgcgccguccgugagguccccaccggccgccguagccggaacugcugcugapcggcpccggcuucgcuagg\n", + "uagagacuugguuucacccccaucgaggcuggucuuaagcuccugaccucaagugauccgcccgccucggccucccaaagugcupauuacaggcgugagccaccgcgccag\n", + "cuaguuuccaacaacagaggcugcagccacccagccccgaagcapcccagcgagacapcccag\n", + "upccuuauucucucucuugcagccccaagcgugacccagcugcagagaagcugagacggugauucggacugacuggacucuggccuccag\n", + "cacuuccuccaguucuaguuuccaacaacagaggcugcagccacccagccccgaagcapcccagcgagacapcccag\n", + "ccccaagcgugacccagcugcagagaagcugagacggugauucggacugacuggacucuggccuccag\n", + "pucccgcggcpcuggaggcagcgagcgccgucgucugcccpcccgcccaucpuccccaaccccauccggaccccgccgcccgagcgcgcggccccggaagcacccg\n", + "gucugcccpcccgcccaucpuccccaaccccauccggaccccgccgcccgagcgcgcggccccggaagcacccg\n", + "ggcucpucccgcggcpcuggaggcagcgagcgccgucgucugcccpcccgcccaucpuccccaaccccauccggaccccgccgcccgagcgcgcggccccggaagcacccg\n", + "gugcacgcuaguguccacacacgugugcgupcucupugcccuggcgcggccggcacgcccaupccpaugccpcgucugcggagagugcaggup\n", + "ugacgacagcuccccaggagccccccgcccggccccuccaggcpcaguggagcuggcccggcgccupcgcgcc\n", + "cggagcggcucgagcagcggcpcuggcaggcggucguccggccpacccggcccpaccggcggcgcgcggcggccgaggccag\n", + "gcggcpcggagcggcucgagcagcggcpcuggcaggcggucguccggccpacccggcccpaccggcggcgcgcggcggccgaggccag\n", + "cpcggagcggcucgagcagcggcpcuggcaggcggucguccggccpacccggcccpaccggcggcgcgcggcggccgaggccag\n", + "guauacucuggauaauaacguucuaacccuggaacagagaaaauuuuaugaagaaaaupuuucuaguaaucaaaaaucuuguaccugaugccgauauucaacgcuuucg\n", + "ccgagaaccgccagcgagcugugccgagagccgcgccgacccgcugcgaucapacaggcgcccgcccgccgccgccgccuggccgcu\n", + "aguuuugguuguggcaacccagaggaagguugcaguggcccaucuaucuaucccagauguaagauaugcuucaccccucuuucuugaucc\n", + "aaugagcauccaaaagacguaucuggapagauuuugucuuuccugugagcagcagcagcuuccuacggacccugcuggagccccagcucggaucagcccuucugacagca\n", + "ugccucuccaugagaccauaagcuccuguaugacagaagccauguucuuuuuagcggccuccguagcaugau\n", + "aguggccucgagacccugccugccugaggaggccucgguuggaugcgaaggagcugcagcauccag\n", + "ugcguucggcugugcupaaguugcguagacaguggccucgagacccugccugccugaggaggccucgguuggaugcgaaggagcugcagcauccag\n", + "cucggugcgguuccgccpcgcgaggagccgccgagaccuccgccugcgaacaaagaggaggccgugcpcgcggcgcccgcggagc\n", + "cpagcpccugcccggacugcgacgccgccacagcuupccaguucgcccagucapauggcucggucggccucpucgacgaucccccgg\n", + "pcgacuggagcgguucccucgcaggcggcgccauuuugugcuaggagccugauaaaaccggcccgguucuguggaaagupcggcggagccapucccugga\n", + "agaagcgaggcgcgcupcgacuggagcgguucccucgcaggcggcgccauuuugugcuaggagccugauaaaaccggcccgguucuguggaaagupcggcggagccapucccugga\n", + "gugcuaggagccugauaaaaccggcccgguucuguggaaagupcggcggagccapucccugga\n", + "ccucgcaggcggcgccauuuugugcuaggagccugauaaaaccggcccgguucuguggaaagupcggcggagccapucccugga\n", + "uuggauuaaaupcaaagagauauuauuucuaauguuucuuuuucucccugagugaagauccugaaucugaagacacauucaucaguc\n", + "aucuccuaggcugaagcuccugapacucacaucaguuaucuugcugcuccagaapupag\n", + "ggaugcuuauuauagaucgacgcgacaccagcgcccggugccagguucuccccugaggcuuuucggagcgagcuccucaaaucgcauccaga\n", + "auuccacccuggcuugcagauuaaaccagcugucaagccapugaaggauccguggccaggcagaggucuguggaguggagaggcgaggccucacgguggaacucucagau\n", + "gacagcaugcaggcaccaagagaguggacgcacauacagaagacagccaugcacugagcupacaugcaacaauaacag\n", + "gccauacaaugaaagucgcugaagaagaauaugaauuuugccugcggauuugcuaacacucgacaauccuaggag\n", + "accagcugucaagccapugaaggauccguggccaggcagaggucuguggaguggagaggcgaggccucacgguggaacucucagau\n", + "aacccugugaaccccaggcaaugacagcaggauccugaagcccaugcaggcucugaaccacgcggccauccagaap\n", + "gcugcaggcaccugccacuaccgcagaggacugapccuuggcccagcapaccccapccuupacugugugagcuggaaacguggcuggccag\n", + "pacagcgcccguaggcagccccacpcapcgcgcpcpcpcpccpccagaggagcgcccggc\n", + "uuguuuauucaggcaaaucuggcuugcupcuaggcucagcugapcugccuucgccaugaauccuucu\n", + "ccagccgugugugaugaguggccacaccuugccuccucuucccgucccaggcaccaacagcacagagcaggccaguguacccagagcc\n", + "aaaggaagaagaguccaccuugcgaccguauccgcuagcgcggccupaugcgcuupcucccug\n", + "aggaaacuaacauuuauuaaguguuuacuaguaguucucucaguaaugaacuucauuauaauuuuaug\n", + "cucuuccupucccuccggcagucugacucccugguggugugcgagguagacccagagcuaacagaaaagcugaggaaauuccgcuuccgaaaagagacagacaaugcagccaucaua\n", + "agccccgguccccacgccuagaagacagcggaacuaagaaaagaagaggccuguggacagaacaauc\n", + "auuagcucacgcccpugacgaacggcgcgccagccaacpcggcgapcagcccgaapcpaggugugagccga\n", + "ucugacucccugguggugugcgagguagacccagagcuaacagaaaagcugaggaaauuccgcuuccgaaaagagacagacaaugcagccaucaua\n", + "cagucacucaggaaauguuguuuaapaaccuucuggauccuuuucauggcaccauggcaagaagaagcuguaucuuaucuauggaagauaaagcauggaguuggcuaauggaugcug\n", + "ggccguugcuccapagaacugcaaauaucuucauccacccccacauuuaaaaacgcaguuggagauaaauggacgcaauaacuugauucagcagaagaac\n", + "cagucacucaggaaauguuguuuaapaaccuucuggauccuuuucauggcaccauggcaagaagaagcuguaucuuaucuauggaagauaaagcauggaguuggcuaaugg\n", + "gcucaccgccccgcgagccccgcccccucggccuccuccucaucggccgccguugcgcggcgcagagcggcagcaag\n", + "acucacccucccagugugcuugagaaacaaacugcacccacugaacuccgcagcuagcauccaaaucagcccuugagauuugaggccuuggagacucag\n", + "acccucccagugugcuugagaaacaaacugcacccacugaacuccgcagcuagcauccaaaucagcccuugagauuugaggccuuggagacucag\n", + "agugugcuugagaaacaaacugcacccacugaacuccgcagcuagcauccaaaucagcccuugagauuugaggccuuggagacucag\n", + "auccugaacaagagagaacaaaaucucuacuuugauggaacuuccauucugupaagagacugacaauaagcaauuaaauaaauaag\n", + "aacucagcaguaggccuugccucagauccaaggucacucggaagaggccaugucuacccucaaugacacucauggaggaaaugcugagagaagcauucagaugcaugacacaag\n", + "cacucacccucccagugugcuugagaaacaaacugcacccacugaacuccgcagcuagcauccaaaucagcccuugagauuugaggccuuggagacucag\n", + "uucugccuggccggccacucccgucugcugugacgcgcggacagagagcuaccgguggacccacggugccucccucccupaucu\n", + "gccggccacucccgucugcugugacgcgcggacagagagcuaccgguggacccacggugccucccucccupaucu\n", + "gucauuuguucccuuugacggcccpaggcugccaggcucuccacccccacuucccaauugaggaaaccgaggcagaggaggcucag\n", + "cgccacgcacuccucuuucugccuggccggccacucccgucugcugugacgcgcggacagagagcuaccgguggacccacggugccucccucccupaucu\n", + "ccacagccuggcagcucugaucaggaaagugaggaacagcaacaauuccggaacauuuucaagcagauagcaggagau\n", + "uuuagugguaggugugupaucuguucuggucaucuggaugcuggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "cccaucaucuucguuucggacagagcaaacagcaacaaggagcupuguggaccaggagucagaggapcaaaggcaaaacaagcccugauaagcaaaagcaguccccacag\n", + "uaauccugacccugagccagugccaggucuccaagugccuucugaaugaccacaggcgauugguuuuagug\n", + "auggucauaauccugacccugagccagugccaggucuccaagugccuucugaaugaccacaggcgauugguuuuagug\n", + "acaggcgauugguuuuagugguaggugugupaucuguucuggucaucuggaugcuggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "ggucaucuggaugcuggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "ucuguucuggucaucuggaugcuggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "ccucugaacugucuucupcagugacagucauggucauaauccugacccugagccagugccaggucuccaagugccuucugaaugaccacaggcgauugguuuuagug\n", + "ggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "aucuguucuggucaucuggaugcuggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "ccuccacagccacagccuggcagcucugaucaggaaagugaggaacagcaacaauuccggaacauuuucaagcagauagcaggagau\n", + "aggugugupaucuguucuggucaucuggaugcuggucaucggugugcaguauugaucaggaccugcaaacccaaaagcuuaupagcuggcacgucac\n", + "uggucguccuccuupuucpugaaagcgcuupuucagupccaugauccccgagcugcuggagaacugaaggcggacagucuccugcgaaaccag\n", + "acgcgaguucccgucuuuccuggucguccuccuupuucpugaaagcgcuupuucagupccaugauccccgagcugcuggagaacugaaggcggacagucuccugcgaaaccaggca\n", + "ucuacccucucupccucucacaaacgcugagccccgccccgcugaggccugucugcagaauccacagcaaccagcacc\n", + "cuccugauuaugacagaagccaguggcugaaugaaaaauucaagcupccuggacuuucccaau\n", + "cugcccuacuugauugaupacucacaagaucacccagagcaacgccauccugcgguacauugcccgcaagcacaaccugu\n", + "ccucucacaaacgcugagccccgccccgcugaggccugucugcagaauccacagcaaccagcacc\n", + "agcaaggcuuccccucuacccucucupccucucacaaacgcugagccccgccccgcugaggccugucugcagaauccacagcaaccagcacc\n", + "gccuuccagccgcaggcgcccuucuucuucugugcgcucpcuccuggucccggcuccccgguuaccpcgcgagu\n", + "acapucuugcucugucauucaggcaagagugcaguagugugaucacuucuuacugccgccucaagcuuccagccucaacucaagcaauccucccaccucagccacccaaguggcupacuacag\n", + "cuuuucucauguuaccgagcggcuuauaaggapaggccaagccuccgccuuauupagccuuupuuuauucucuucccuucuaacuug\n", + "gcuggagcgcagcggcacaaucucagcucacugcaaccucugccuccupuucaagcaguucucccaccgcagccucccgaguagcuggaagcacag\n", + "agugagcauucucagcacauugccucaacagcuucaaggugagccagcucaagacuuugcucuccaccaggcagaag\n", + "aaaagaacuugcapcaccucupuccugagaagugucuguugaaugccgagucguapuupcacauccagagguccgag\n", + "gucpaaagagguuaaagaagacacgcaaguaugauaucaucaccacuccagcagagcgaguggaaauggcgccacuaa\n", + "ugucauguguauuuaacuguuuacccaccaccgaaaagcuuccugccaggacccaucugcaguguaaaapaacccugaagcccupaauggcuccuaguacuucag\n", + "aagcaccgcgcagccgccuccgccgcaggaucccccggugcaggccuccgugcuggugcggauccuggagcucagccgcgcgcgcccugcccgauccugugccgacccaccgcacu\n", + "gcaaacacacccgagagcuggaggaacaggucuupcauuugcuguugccggauuuacugugugcugcuuuugucuuggaaga\n", + "aaguuuacgacuucauaggagaagcugguuauggacaugaucugcgucucuucccaggaaggcaaucuuguuagg\n", + "gugguggcagaagupauccaaaguagagcuucucguaacccccagaagcacugagugaccaagugugacaccagcuggacucauuguguccauugcucucuugcagcaccupcucaugg\n", + "gucpaaagagguuaaagaagacacgcaaguaugauaucaucaccacuccagcagagcgaguggaaauggcgccacuaaaugaagagg\n", + "auuaggugacuggcugaggcggcgccaguuggccpcacpcugcuguaaggccgagguugcggcggaagcggagacc\n", + "gcgagcauuaggugacuggcugaggcggcgccaguuggccpcacpcugcuguaaggccgagguugcggcggaagcggagacc\n", + "aggugacuggcugaggcggcgccaguuggccpcacpcugcuguaaggccgagguugcggcggaagcggagaccauguuccgagcggcggcuccpcagcuccggcpcg\n", + "aggaacugacaccauugauuuuggcaacucagaagcaguucaauuacacacacaucugugcuggagcaucugccuucggaaag\n", + "aaccuuuugcccagaguagcagccaaacuugagguugccccgauuucugacaucauugcaaucaagucaccugacacauuugugagaacuauuuaugcag\n", + "gaaaugcucuauguacagugaagugugaugagaaagugaaaguguuuucuguccguggaacauccuuugaugcugcagcaacaaguggcgguagugccaguucagaaaagg\n", + "caucaaguacuucaccaguggaaauaucagaguggcuugaccagaaauuaacaaaaagugaucgaccagagcuaacaggugccaaaguggugguaucuggug\n", + "gucgaggcuugaagaguggagagaacuuuaaguuguuauaugacuuggcagaucaacuacaugcugcag\n", + "ccgagguugcggcggaagcggagaccauguuccgagcggcggcuccpcagcuccggcpcg\n", + "agcauuaggugacuggcugaggcggcgccaguuggccpcacpcugcuguaaggccgagguugcggcggaagcggagacc\n", + "cgccupccagacgcgcgagcgcaagcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "agacgcgcgagcgcaagcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "gcgcgagcgcaagcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "gacgcgcgagcgcaagcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "cgcaagcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "guguggacacugcaagagacuugcaccugaguaugaagcugcagcuaccagauuaaaaggaauagucccauuagcaaag\n", + "guugauugcacugccaacacuaacaccuguaauaaauauggagucaguggauauccaacccugaagauauuuagagauggugaagaagcaggugcuuaugauggaccuaggacugcug\n", + "auggaauugucagccacuugaagaagcaggcaggaccagcuucagugccucucaggacugaggaagaauuuaagaaauucauuagugauaaagaugccucuauaguag\n", + "puaucaucuuauuucguccuucacaucucacuaacaaguuugaggacaagacuguggcauauacagagcaaaaa\n", + "agcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "cagacgcgcgagcgcaagcagcpuuaguggucgcgcgcccgaccuccgcagucccagccgagccgcgacccuuccggccguccccaccccaccucgccgcc\n", + "agugaaaguuccucacugagugagupcugacucuuccugccuccggcucuugccucccagugcc\n", + "gccgcgcccugguccgccgaccgcagacgacuugugacacggacggcgcguccugcugaccccagccggcgccgapcuuggaaucucgagcpaaaag\n", + "gugccccgucgcaggugccccuggccggagaugcgguaggapcgagcgcgagaagccccuuccucggcgcugccaacccgccacccagccc\n", + "acagaacgaccgacggaccgapuucgapapacacggaccaggaaccugagcuaggucaaagacgcccpccag\n", + "acggaccgapuucgapapacacggaccaggaaccugagcuaggucaaagacgcccpccag\n", + "cuugugagaagagccgcgcuugcagcgucupagaaucuuucggucuccgcgagaggugcuucauucc\n", + "acgaaaaaaguauaauucaagcucagauuuguguugaaaccagccucaaguuucaccuauccucacugauccguggacuucuguaugaucag\n", + "ggugcuguccugagagcgcugcpauaaaggaggagcguccugcuucccggcugcccuguugcugucggagucacagg\n", + "gucuugugagaagagccgcgcuugcagcgucupagaaucuuucggucuccgcgagaggugcuucauucc\n", + "aaaaacgcugcccpaaaguccpcagagcccgagcagcggccapuaacgcugucuuguggacccgcacuucccacccgagaccucucacugagcccgagccgcgcgcgac\n", + "agagcccgagcagcggccapuaacgcugucuuguggacccgcacuucccacccgagaccucucacugagcccgagccgcgcgcgac\n", + "agagcgcguugucuacccuguaccgaagacagaggcugupacagccuapccuggaucuauugccuacuuagagagaggccaacucagacacagccgugu\n", + "cucagugcuuaccagagcgcguugucuacccuguaccgaagacagaggcugupacagccuapccuggaucuauugccuacuuagagagaggccaacucagacacagccgugu\n", + "aggcugupacagccuapccuggaucuauugccuacuuagagagaggccaacucagacacagccgu\n", + "gupacagccuapccuggaucuauugccuacuuagagagaggccaacucagacacagccgugu\n", + "agcgcguugucuacccuguaccgaagacagaggcugupacagccuapccuggaucuauugccuacuuagagagaggccaacucagacacagccgugu\n", + "caggaacgugugacgacggcuggaggccaacagagucccuacagguggugcucacgguaaugcaccgacaaugaguggcuguuuuccaguuucuggccuccgcugccuaucuagg\n", + "gaacgugugacgacggcuggaggccaacagagucccuacagguggugcucacgguaaugcaccgacaaugaguggcuguuuuccaguuucuggccuccgcugccuaucuagg\n", + "gaacgugugacgacggcuggaggccaacagagucccuacagguggugcucacgguaaugcaccgaca\n", + "paagaaacccaagaugccugacuuucugccuuggagacugaaagaaacaapcaacucaccaaaca\n", + "ggucugcpcpcucaggagguccgcpaggauggagcagugagcpucupcggcugcuggcagcgcc\n", + "gcagcugaaaaaguuggaugaagauaguuuaaccaaacaaccagaagaaguauuugaugucuuagagaaacuuggagaagg\n", + "guccuauggcagcguauacaaagcuauucauaaagagaccggccagauuguugcuauuaagcaaguuccuguggaaucagaccuccaggagauaaucaaagaaaucucuaua\n", + "guuucaacagaaaaugagaaauaucccccgacgauuggcugaaaacaugcagcaaccacuauuuucuuccugccccucguugaugagagcauucgaagugaccucagcapcauccag\n", + "gucaguuucuggaagacuugugugugugaugaaugaauaucugguuuugucucugcupccugugugccuggaaaggaauuguuuuggccuaggaucauccag\n", + "cuagacuucpcuccuugaggauauucaguuuuguauguuugaauauccucucaccauguucagcauaaaguaccauucuuaaugauuauccucaacaagacag\n", + "gagacugccccgcggagccgccgguaugagcgccccucgccaccccgugucccaggcccggccuuucugacaagag\n", + "acuucpcuccuugaggauauucaguuuuguauguuugaauauccucucaccauguucagcauaaaguaccauucuuaaugauuauccucaacaagacag\n", + "uucgauguuuauuugcuuggaguuucagcagcagaccgcggugcuugaagcuguucauggaaugaccgcuugugucugagccagcgucugaggaaacugauguucuauaa\n", + "aacaaccacaagugccgucgccgcgccccuucccccucccgccuccccggcccccuccccggaaccggcggucgagcuacggucgcggagcaguggaaccgagacugccccgcggagccgccg\n", + "uucaacagaaaaugagaaauaucccccgacgauuggcugaaaacaugcagcaaccacuauuuucuuccugccccucguugaugagagcauucgaagugaccucagcapcauccag\n", + "uuucggcggcggcugagccagcugapaaaaauggcucggacuguggcggcuucggcggcucagguugugguagaggcggaggcucaggcagcuugag\n", + "gccuugcuauuuuggaagcuacaagaaaaaaauagaggaaggaagguuuggucuuuuuaguggac\n", + "agcuuucggcggcggcugagccagcugapaaaaauggcucggacuguggcggcuucggcggcucagguugugguagaggcggaggcucaggcagcuugag\n", + "agcccgcagccggccgcgucaugccaggcgcugcucggcgguapagugcccpccgccgccuccgcccgcccgaagccgcgcccacugcccagagccagap\n", + "ggcuuugcuaaagucacacauccaguaaguggccgaagcagaucuucagacccacaguuuggcugccaaaggaccaca\n", + "aucagaugcaugcauagcaccacacagcuacaucuuaaaaaacguaguguuuacucaaaaacauuapaauaacgaaauacauaacauaaaagcag\n", + "gagcaugguuucacuuuugcaaacauuuauuuauacccuucgagagaaaaacgucucagcugucacaggaagcugcuucppugagcaaacuuuuuaaaaugcagaaauu\n", + "guggaaccucgaaaccccggcgacucpccugagcgcgcgucucccggcgcpuuccucccacgcagacccucauucaaacg\n", + "agaaggcagccucggucucupcggcggcggcggcccacucugcccuggccgcgcuguguggugaccgcaggccccagac\n", + "gccgccggcccgcccgccagucupcuccugcacaucuggcgaucccgccacaucupcagccggcgcuggagc\n", + "auacaagagaugugagaagcaccauaaaaggcguugugaggaguugupagugapagagaagagguugaaaagcuuauuagcugcuguacgguaaaa\n", + "paccagauggauuguapaguapuacaauacagucuguucuccuccagcuccuucuuucugcaac\n", + "ccccgcgcuccgccagcapagcgcacacgcaggugcaaggagcuggcaccupcacacaccuggccacacaccugugcagagccgguggcaggcccucccggcgcagga\n", + "cucacugucccuggaaucuucaapaguuacugcauuacaucaucagaaacaaggcauuucuauauuacu\n", + "ggacucggcgacuaggcgccgccugaccaguaggagccgcccucgacgagcgagcucgaaggcugcgacuggcgccgccucaccgccucccaccgccacugaccgaccguucgaccggcaaac\n", + "gagaucugaaugagucaaagccggcggccucggcuccucagcuccaccugacaguaggccgcugaucggccgcpucuugucgaccgcuaggccaccagguuc\n", + "gcgagaucugaaugagucaaagccggcggccucggcuccucagcuccaccugacaguaggccgcugaucggccgcpucuugucgaccgcuaggccaccagguuc\n", + "apaagagcgaacccapcccuugcucucgugcagcgcugcgcccupupacggcgugaggcuugcagcgcag\n", + "guuuugagaguauuuuagaapcuuuauggaccacggcuacgaagagaccucaguuuauuugaag\n", + "aaccccccuccppcgcgcgcuccpcucgcgccgapcucgcgccccugccucgugccugcgcugcucguauguaaaugapcgcgugacgcpacgcag\n", + "gugacacgugucaaucaaccccccuccppcgcgcgcuccpcucgcgccgapcucgcgccccugccucgugccugcgcugcucguauguaaaugapcgcgugacgcpacgcag\n", + "agaugaggaaacuacagcucagacagaguaaaggauucggcugaaguccuauagcuccacggaucuucagg\n", + "gagguccuugaucugagaagucuggaauccgcugaaguagaccaaagcuapcucacuaacaaguugcagaag\n", + "guagugaaacuuuagaaagaagagccpaggauguauugguuguuaggaaaauguaggcuaccaguagaaaaugacauucucuauuaauaagaucugag\n", + "ggcuuucupaauugucuugacagagaaccucagcuggacaaagcagccuugaucugagugagcuaacugacaca\n", + "cgcuacaccaaccugaacuucgcuuccugagaccuaagauucagccccgugcucagcagacaucapaucaccgacucugugccaggagcuguucuug\n", + "ggagcccaagcgcagcccgcaccccgcgcagcggcugagccpagccagcgcagccucggccccgcagcucaagccucguccccgccgccgccgccgccgccgccgccgccgcccccpc\n", + "gcuuuauaaapaguuucccugcacaagcucucucucuugucugccgccaugugagacaugccuuucaccuuccgcc\n", + "agcacguugguuaagauggugagcagcucaaagagugaggauggaugaagcaaagcagaggccgcugccccug\n", + "aucuucaacuugcugcugagcuupaagacauuacuggaucggaacacagaguuggaggacucuguucagcag\n", + "gucupcggcggcgcgucccgcccgapcggcucuggcugapcggapccpaagagcccpcagcggcugaggcpacggcggcpccgcugccccuagaagacccagccgag\n", + "uauauguuuaccuacauccuacaugcuucuaaaagauguuguaugaacuaguaggaugagguuuuaucacaag\n", + "guuugcaguaucuucagagucugaauuuugagcggauagugaugagccagcuaaauccccugaagauuugccugcccucagugguuaacuuuuuugcugcaaucacaaa\n", + "gaaacagcuuugaaguguggagcpaaaggagcaguuucugagcugcaaaaacuaguuucuaaacag\n", + "auggaguuucacucuuguugcccaggcuggagugcauuaucccaaucucggcuuacuacaaccuccgccucccag\n", + "guucugacaacaaaggagauugugacauauugcupccuaacacuaaggugauguuaguuauuugcuuuggcugugcccuuggaaggcauugagacauacugcugugcccagcaccaagaugau\n", + "guaacgugacucuucugcuucaggccugccaaaagaaaagauugugacagaucacuggacccagcaccuag\n", + "gaggaggauuuggaagacccagagcpaugaaacpacagagcccugaapcapaupaaggcggaggaguuucuacugaggccap\n", + "agccugauuaaccagcuucuccapccaagcuguupugaggugcagcccgaagcagccagaccagccccugagccucccpugcuggcagcuguc\n", + "uuugcaggucuuuccagccccupcagccugauuaaccagcuucuccapccaagcuguupugaggugcagcccgaagcagccagaccagccccugagccucccpugcuggcagcuguc\n", + "ccaaacccugcccagaagccugccccuuaaguaccuggcaggucaauggccacagcccgguagccagccupccagccugugcaguguacccagguucugccaggucucggaggagaagcgaauacc\n", + "aucauugguugcagagugaggagagaucccccuaacuccaccgaacgauacacacguuggaucaaccagcugacgccggagcagcuccuaacccag\n", + "gacaagucupcuaucauugaaaaauggagagugaagcuggaagauucugguguccacgugaucauuppcacgauucucccucuccuagaggcg\n", + "ucggauacgcuaaaaaucaagcaguugcccagagcucapucuuaccuuugcuuuuuggauucg\n", + "gaugacgucaugaugccccagcpugaggcugcaacacgaggcugccguucagcacccgucgagc\n", + "agugcccagugugcugcgccuucggcucggcuccgcuccgcguccucugcccgccgcagccggccgcacccggccgcacccuuccccguccgucc\n", + "ggccaggaacgccagccguucacgcguucgguccuccuuggcugacucaccgcccuggccgccgcacc\n", + "gcagacucucaccgcagcggccaggaacgccagccguucacgcguucgguccuccuuggcugacucaccgcccuggccgccgcacc\n", + "gcgcccaacuuccgcuggcccaaagaaacuauaauuuugaaccaacagaccucugcuggcaucugcgauugcauuuuuccuguuuuaacaacggcugugcuagacgaaguggugaagcccaa\n", + "agacuuauuuuugagcucgcuguaagacugagaaaucacguaguccuuccugaaaccacuaagaggaaaa\n", + "agagacuuauuuuugagcucgcuguaagacugagaaaucacguaguccuuccugaaaccacuaagaggaaaa\n", + "uuuccucagaauuacaaaccucaugguaugauguggauuaaaaaguacauauuuaugcaccacuaacccagugagcauuua\n", + "acaagcgugacgcacuuccggccuccuaaccguucucgcuagcggugcgcuucuggccuguuuugaguccgcgcucaaag\n", + "gagauggugaccuucgaggauguggcugugcacuucaccaagacagaauggacuggccuuucuccugcccagapcccuguacagaagugug\n", + "agaaacacagugaaguacugacaguagaaaugauaugaugucugaguucaacuccagcaaaacag\n", + "aauuuuaauaaaaauauaacacagauucugaacuguugcuaagaucaugaauuuagcuuaaaaccuuaaugccgaaggucuucucuguguauuuugugugccucuguccugcccuupaagaucug\n", + "aaguccuauucuggugaaaacacagcuagugccauugcccguucugcugccgccacggcuuugucucuccuugugccaguuuucauuaucucuugcaaagagaagguugaggaaauccugaac\n", + "acgcuaaaccaagaugagcagaaggaagagagcapaaggaggccapuccgcgcggcuupcacagugcccuggcucapaccuuccupagugag\n", + "ucggucugucapuuggaaaguccaagccauaggacccaguuuccuuucuuagcuucuguugucugccagaacaccaupcuguuacucgccuugaguuggaagcgguuugcauuuauaccu\n", + "aauaggaaacgaccupagaauccgcuggcccaguuguugccagcuccuccuccauguuccgacag\n", + "aguugupcccugccapaauaggaaacgaccupagaauccgcuggcccaguuguugccagcuccuccuccauguuccgacag\n", + "agauguaaccuagaagucaagcgguaaaacaagcuuugcaacuauguggauggacaagauguaauugaagaugaaguacuuuagagaugguaugg\n", + "gacgccugcgcagugcggucgcpcugucguugucccgcgagccgccgaccaggccucgaacp\n", + "acaccucaagcugcgcgcugguccucaccucucaccaucugcucuguggcucccagugcugacucuggaag\n", + "gcucpccpacggcugcuggagcggcgcccgccgcggcucagcgcauucccgcucuccgcuucccucuccgcugcguccccgcgcgaag\n", + "aucgcggapcpccgcpcggugcucpccpacggcugcuggagcggcgcccgccgcggcucagcgcauucccgcucuccgcuucccucuccgcugcguccccgcgcgaag\n", + "ccagcauggacaaucuccuuuacaguuucggaagcagguuuguugccauggaguucacauuuugacpaguugagaaguauaaag\n", + "acugaaaacuaaagccugcagagaccucugaaggaaaaccugucccpcucugucacuucacaccc\n", + "cucaagugaaacugacucugcuagaacagugccgugcuuuuccacagaagguuagacccugaaagag\n", + "ggaggaagaaaacucaagugaaacugacucugcuagaacagugccgugcuuuuccacagaagguuagacccugaaagag\n", + "guaaaucaacagacupaagaugaugguupagcaupaagaaaaugaaccacaagaaccu\n", + "gaagaagaaggaaauacuugcaaaacacaaaaaacuuccuggcuccaagauuguguuuuauccuuaucuccaaccaaugaucuu\n", + "gcagupuggapcapcguggugagguaaggugagugccguagupuucccuggagcc\n", + "cuucugcuuggcuagagcuauupcucgguggcggccgcagupuggapcapcguggugagguaaggugagugccguagupuucccuggagcc\n", + "cuaggcgccupccagccugcgccugcgcaguacucggagacagcggacccgugucagugacagcuuccg\n", + "gaccuccaggccgcccpacuuccucuuuccucaccugcpaggagauccucagcggcgccuugcggapacccca\n", + "guuucuccgccuucugcuuggcuagagcuauupcucgguggcggccgcagupuggapcapcguggugagguaaggugagugccguagupuucccuggagcc\n", + "gguuugguuucuccgccuucugcuuggcuagagcuauupcucgguggcggccgcagupuggapcapcguggugagguaaggugagugccguagupuucccuggagcc\n", + "gagcuauupcucgguggcggccgcagupuggapcapcguggugagguaaggugagugccguagupuucccuggagcc\n", + "auacuuuacuugugaaagaaccaguggcuguccuuaaggccaacagaguuupagcauuacgag\n", + "uucaccaucaaugaauccaccauuauugauucuccaagguuuucucacagaggaauuuugauugauacauccagacauuaucugccaguuaagauuauucuuaaaacucug\n", + "aggaaggcggcggaggcggacgagaccaaugccagccuggaggaggaagupccaaupaagg\n", + "augccagccuggaggaggaagupccaaupaapugaauccaaguggagaucguapupagupcguggcgcccgcuuaccuugaggcugg\n", + "auuacuccucauacugcuuugccugaccacacuacgaccuggagaacuuggauucuaguccuaacucugcccucaguccucuuag\n", + "agacgcpaagagcuuggccgguuucgagucgcuggccugcagcuucccugugguuucccgaggcuuccuugcuucccgcucugcgaggagccuuucauccgaaggcpacg\n", + "cagcuucccugugguuucccgaggcuuccuugcuucccgcucugcgaggagccuuucauccgaaggcpacg\n", + "agagcuuggccgguuucgagucgcuggccugcagcuucccugugguuucccgaggcuuccuugcuucccgcucugcgaggagccuuucauccgaaggcpacg\n", + "aaaaaccgaagguguaucaagguguccgagugaagaucacagugaaggagcugcugcagcaaagacpcacaccaggcggccuccpaacc\n", + "ggacugugapcgcuucugacuuuggacuugagcacugccupaccugugcugagagagcgcuag\n", + "cuacggcggcucauuguuuuccgcugcapugcugaappacgcpucggacgcguccggcuguggaagagagcggcggccgcucacaac\n", + "uuuuccgcugcapugcugaappacgcpucggacgcguccggcuguggaagagagcggcggccgcucacaac\n", + "gagccggagucggauggcggcuacggcggcucauuguuuuccgcugcapugcugaappacgcpucggacgcguccggcuguggaagagagcggcggccgcucacaac\n", + "acuuccuuuccaucauugauaggcgccpcagcugagcugguaggaggaccagacpagguucg\n", + "guggcpaccuuggcggcgcccggagccggcguggcgcucaucgapacgcccggcccaagug\n", + "gcupccaagccgcagagcggaguuggcauuuccagauupcucpccgcgccuccuccpacccuccccuuggaccgagccgaucgccgcpcaguucpccggcuguccuggcgcg\n", + "agguggaucgccgcggccccuccucccagagcggcagccuuuucccgcgcgugcugccuucgccgcucpccgcccpaaaac\n", + "gcgaguccguucupugucuuggcucuauggcucgccucugccagcuccuccgcugccaggcggcgcacgcucpaaccugugcgccuauuuugguccuacagaaugcugcggaagcucucgcuc\n", + "auauccpuucccgccgccuccaccgccaccgccucagccgccucgcacauuuagucuugccpaguggugugauucccgaccaag\n", + "cggcgcgapucuccgcccucugcuccpcugaagcgcucugagagaggcggcagcggcaacucgagccccaacaguaauuuaguguugguaguuuuggcagcagcugccgaggccggagca\n", + "guccuaucugacuccuguacpaugaggaagcagagucuuuacggaaagcacgcuccagacaagcucggcagacacgaaggucuacucaa\n", + "ggucgcgcaggcgcugguaccccguugguccgcgcguugcugcguugugapugucagcucag\n", + "ggcggagccacgccaacagucagaggucgcgcaggcgcugguaccccguugguccgcgcguugcugcguugugapugucagcucag\n", + "aacuuuccugccccuuccccggccaagcccaacuccggaucucgcucuccaccggaucucacccgccacacccggacaggcggcuggaggag\n", + "gcpcgucuaaaauucupaagcagaaccuggccggagccacuagacagagccpccuagcccagagac\n", + "gagcgacgcagccpacgguagcugcggugcggaccggaggagccaucuugucucgucgccpagucaggccccuaaaucgaagaagcc\n", + "agcuaucgucuucacugcucugugccgucagcuccuagaggcccagccucuguggcccugugaccugcagguauuaggapucacagcuaggacgccpacccccuggaagccuagaaaug\n", + "gcuaucgucuucacugcucugugccgucagcuccuagaggcccagccucuguggcccugugaccugcagguauuaggapucacagcuaggacgccpacccccuggaagccuagaa\n", + "acugcucugugccgucagcuccuagaggcccagccucuguggcccugugaccugcagguauuaggapucacagcuaggacgccpacccccuggaagccuagaa\n", + "cugcucugugccgucagcuccuagaggcccagccucuguggcccugugaccugcagguauuaggapucacagcuaggacgccpacccccuggaagccuagaa\n", + "gccugugucauccgccauuuugugagaagcaagguggccuccacguuuccugagcgucuucuucgcuuuugccucgaccgccccuugaccacagac\n", + "ccgguauguggccccgucuggcuagucccgccuagcgcgcccauuucgagcccaaguuuccagcucpuuuccaggcucagaauuuuccaggaguagguucuupcaguggcugupagcugga\n", + "agucccgccuagcgcgcccauuucgagcccaaguuuccagcucpuuuccaggcucagaauuuuccaggaguagguucuupcaguggcugupagcugga\n", + "gaucccggugccapacccugcccaguuccaggcgucgcccugacccagaaacgacupcgccgccguccuggaaaggccccagcgcacggacaucugagg\n", + "acuccagagccaauguagcuauuccgaugcucuaagaucugcucucugcaaugcccaaacugaccccaauugccuuucucuagacccacuucuccaccgupagaagug\n", + "gacaaaacgugugacaggcucugagaaguucagccuccupugaapagcgcagcccuccacpccgccaagucauagcagapacguguccagagacgcccggcggaaggcag\n", + "cccacacaauaugaccucpaggaugcgaggaagaugaacugugaugauccacuucuucuuaaugaaug\n", + "uaaacaacauauuuuugacauacagacugacuuaccugagaaagaaacucagaggaagaggaaagaaagaagaggapa\n", + "guccgcgccagcccpacgcgcuuggccuugcccgcgcccgcucgccucgucucgcccggccuccccgcgucgccucgucgccuguuccgcgccaggc\n", + "ccuuuuauaaugaaccuacuacuccugcaauaacagcauaaucuauucaugapuggaacccucauggccuaaucagcucuuaaag\n", + "gcagaucccgaagcagcgcupagcguaagugcpcagagcacugcgccguuupaacgcaacuuugaggagacagugcggugg\n", + "gcgcuguucaacugcapcguauucccggapcaguupagcgcagaucccgaagcagcgcupagc\n", + "cgcagaucccgaagcagcgcupagcguaagugcpcagagcacugcgccguuupaacgcaacuuugaggagacagugcggugg\n", + "guauucccggapcaguupagcgcagaucccgaagcagcgcupagcguaagugcpcagagcacugcgccguuupaacgcaacuuugaggagacagugcggugg\n", + "aguupagcgcagaucccgaagcagcgcupagcguaagugcpcagagcacugcgccguuupaacgcaacuuugaggagacagugcggugg\n", + "guucaacugcapcguauucccggapcaguupagcgcagaucccgaagcagcgcupagcguaagugcpcagagcacugcgccguuupaacgcaacuuugaggagacagugcggugg\n", + "cucuguggcggagacagccagguuggcagcugacpacagccpucuauuuuguugcpuuuucagcaaauccapcuggucuggaggcgcgaa\n", + "auacgucacucpccgcpauuucgagcauuucgcucgcgagaucuucucuguggcggagacagccag\n", + "augcggacugaauuacaccgcuggcuuuccuuguucuccagcuugcaggcagcauacugupacuucupccuccauaauugu\n", + "cuucucuguggcggagacagccagguuggcagcugacpacagccpucuauuuuguugcpuuuucagcaaauccapcuggucuggaggcgcgaa\n", + "auugccugcguuuaggagguggcugcguugupaaaagcuaucaaggaagaaauugccaaaccaugucuuuuuuucuguuuucagag\n", + "uaguucacaacagaucugaguguuuuaauuaagcauggaauacagaaaacaacaaaaaacuuaagcuuuaauuucaucuggaauuccacag\n", + "ucuugcugcucuguugcccaggcuggaguacaguggcaggaucucagcucacugcaaucuccgucucucagguuuaagcaguucuccugccucagccucccaaguaggupacuacag\n", + "paggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "agacaaggccacuuuauguuucccaggcuggacuggaaccccupcucaaaugauccuccuaccuaagccugcagaguagcgaggacuucag\n", + "uuuucuuagcucccuggacccgguugaccuguuggcucuucccgcuggcugcucuaucacguggugcucuccgacuacucaccccgaguguaaag\n", + "ggugcaauaccugccuugcgucgcccgugccgcuccagccaccgucaaauccpuagcgacccpcguuugcagcggugccgaggaagaggacpaacgguguuacg\n", + "guggucugcgcgcgcccggccgugcgugcggaugcpaggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "gcguggucugcgcgcgcccggccgugcgugcggaugcpaggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "acagucuugcugcucuguugcccaggcuggaguacaguggcaggaucucagcucacugcaaucuccgucucucagguuuaagcaguucuccugccucagccucccaaguaggupacuacag\n", + "gugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "ucuugcugcucuguugcccaggcuggaguacaguggcaggaucucagcucacugcaaucuccgucucucagguuuaagcaguucuccugccucagccucccaa\n", + "gcgugcggaugcpaggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "uucacaacagaucugaguguuuuaauuaagcauggaauacagaaaacaacaaaaaacuuaagcuuuaauuucaucuggaauuccacag\n", + "gcgcccggccgugcgugcggaugcpaggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "gcccggccgugcgugcggaugcpaggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "gugcgugcggaugcpaggcugcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "gcgugugugcgcapagagaacgccggccaccuucccgcuuccgagcupugcgcgccgagcacaggag\n", + "gupcpaccucpcgugaucgucgaggagaccgcggcucccucaccugccggcuuguuccucpuccgcggag\n", + "aguuucaagcacuuugugaguaupugaaucggcgucggccuuccacugupuuaaaucucaucccgcggcucuccuccugucgguccugcaguucuuuuguccccpuagag\n", + "ggccguuaccgaguguccpucgguucuugapuauuuggagacpaugcaupucacauagacaagccucgagaaupagccguuacauuuuugcacugccugguaacaag\n", + "gcuaguuucaagcacuuugugaguaupugaaucggcgucggccuuccacugupuuaaaucucaucccgcggcucuccuccugucgguccugcaguucuuuuguccccpuagag\n", + "uuugacugagcaccgapcaguuggcagcuucaccucagagcugcaggaaggaacpcagugaaaaucgaaucpugugauccuaggccaagcuc\n", + "aaguaaauggucucaaccagugaauggaaaaaggaaaguaacuucaaauuuuggaaapauucagaacaaaaucaucagguugaagaucccggaagaugacugaagcucagccag\n", + "paagccuuuugauggugaagugucagagagcaaaggaggaacugucaacaauggugauuccacuaaugaaaauauccaaugugagcuggugguccuuugcuuguuguucugag\n", + "caccgapcaguuggcagcuucaccucagagcugcaggaaggaacpcagugaaaaucgaaucpugugauccuaggccaagcuc\n", + "cucuuugacugagcaccgapcaguuggcagcuucaccucagagcugcaggaaggaacpcagugaaaaucgaaucpugugauccuaggccaagcuc\n", + "gcaguuggcagcuucaccucagagcugcaggaaggaacpcagugaaaaucgaaucpugugauccuaggccaagcuc\n", + "acuuuucuuuuccucuuugacugagcaccgapcaguuggcagcuucaccucagagcugcaggaaggaacpcagugaaaaucgaaucpugugauccuaggccaagcuc\n", + "cuuuuccucuuugacugagcaccgapcaguuggcagcuucaccucagagcugcaggaaggaacpcagugaaaaucgaaucpugugauccuaggccaagcuc\n", + "gauauaapcagccugcauggaaapacugccagcaucugccuccacugcucugugcupauc\n", + "guaccucuucucccacuuaaaugauuucucagcaugccaggagauccgagacuuguuggaggagcugagccaggucuugcaugag\n", + "ugcagccacguggcupaucugccacaacauccuggucugcugccccaaggagcugcuggaacagaaggccgugcucgagcaggugcagcuggacaguccauug\n", + "guucccacugacucccgacugcagauccagccuggagacgagguuguccagaucaacgagcagguggug\n", + "ugguuagccupaaaagagcccgccuccuggcccauaaggcccucggccggaagcuccgcuuucucuuccugcucuccauc\n", + "acucugcaaggacccgagcuauuuaucccuagguccuuuccuccugcacgucagcuuugagccccgagcuggugcuucugcucucugagac\n", + "aaagaacpupaauggugupupucaaagaggaaacccagagaugcapcgccccuuucccguggucugcccccaauugcucaggcaggccagucacg\n", + "ccccuacccacccacacccccuugccccauuuupucgccupuccucaguccuagcggauccucaguccuagcggccaccpucugaaaggagcaagacg\n", + "gucacggcggcggapcgcaggcggcupcgccuggcgaguggacuguucgagcccuuccgcupacccpcccuggcuccggccccgcg\n", + "agcuuaguggcgcgcggcgcggcgacgaccgccpagcgugugcagcggcggcggcggaaguggccggcgagcccgguccccgccggcacc\n", + "guucuuuaauggaggagccaaucucucugcacaccugguuucaucuaauaauauacagacaccagcucugaggccaguuaaucauccccaguguccaggcacagaguagucgguccgccucaca\n", + "acugcggauagaagaggaccgccgccuugapapuggaaacupugccggcuccgcgcgcgaccuccggcccugcgcgugcgccguggcgcggcccggcugacag\n", + "auaucuagaugaucucaaugaapuuuauauucagcaaaccuuagaaacugugcuucucaaugaagauggaaaacaacuucua\n", + "gcugugugaggcauuguguaaucagccaggcucuuucccgaccauuguucuccaccaacaggccuggaagucggaagccaguggaguucucccuguuucacag\n", + "gagaggacuagaaggaacgguucccaccucucggaggacaacggacccaaagcgaucgaugugauggcacccuccucaga\n", + "guugacugcauucagccagugccaaaagaggagcccagucccgcuaccaaauuccaguccaucpuucagguagaggacgacuggcg\n", + "gauagcugccgcccpagaggugacccpcgcccugcuapugaaggccccugcccucggcccpauc\n", + "cggcaccucugaucaagugccuagapaugugugugccagcccucgguccagugcccgcuccugagcugacuccugcupccccgacagcuugccguguuuccugugccuguagcucccugguug\n", + "ggcuuccggcggcgugaccugaccgcaagaggccaauggagugupagcugaaapucuucgcuggcggccg\n", + "ggcggcuuccggcggcgugaccugaccgcaagaggccaauggagugupagcugaaapucuucgcuggcggccg\n", + "gagucucccaagaucucccaacguuggapaguccaagcccapaacuugacauaccaccaguac\n", + "agcuccagcaagagcgcpcpuggcccaggcacgcagcggugaggaccgcggccacagcucggcgccaaccaccgcpccucccagccagccccgcggcpcagccgcag\n", + "gaaaggcgccaggugccaguccuggccucugauguaacccagcgccccgcagucccgacacagauuccuggaucucagccccauagcagcu\n", + "aguccuggccucugauguaacccagcgccccgcagucccgacacagauuccuggaucucagccccauagcagcu\n", + "cauccuggupaagaaguuuuaapaacaagcuggaggugacgcuacugagaacuuugaggaugucpcacucuacagaugccapaa\n", + "ccggcgcpaaugucccpuggagcuggcugagucgcgcgcucugcuccacccgacpcugugugugcupccuggcucgcggcgaaccgag\n", + "gaaugucccpuggagcuggcugagucgcgcgcucugcuccacccgacpcugugugugcupccuggcucgcggcgaaccgag\n", + "gucapagccugagcuggagccapccccagupaccugacccaaagucugaggucaagcupcccagagccuggccuggagcuggagcccaaggcacagcuggacuacccuuguc\n", + "agcucagcucagacggcgcccuapccgcacagapucpcagugccggagagagguuugaaagcgccgccgccaacucgacagcgcgucccag\n", + "gaaaaacugaggaaacgcgccugguuccapucggcpaccguggagacgcugccagcauccucaacagcuuggaaaucccaucaccuugguucccugagacuuggaggacuag\n", + "uaggaacugacagcuggcugacagaaaacuuauccapagagaagagacaaaagugaagugugaaauuuugaauaauguuuucag\n", + "gcacggccgucgccagcauaguaccggcuccucuucuucucccagaaccuccugacaccaaccuuggugaaagaaaagcugugaca\n", + "augcuuugcauucagaauagaccucugaguupacccaagcugucaacugaucccaaauuccuaaguuccugacuugcag\n", + "gauucgaggcgccgaggagccgaagaccacagcucagcucagacggcgcccuapccgcacagapucpcagugccggagagagguuugaaagcgccgccgccaacucgacagcgcgucccag\n", + "agcuauuugcgaggcuucgcaggcaggcpcguguguucuucccaccgugugucacccugaccacccgccugucapccagcgagccgaggccaggauccugagcuguacccag\n", + "ggauuugcuuccuaaggagaagaacuuggaaacucuguugaccuuggcuuuucuagaaauagauaaagccuuuucgagucaugcccgccugucugcugaug\n", + "caacucuucugaccucupacuacugcaacaguagcccuauugcgagaugguauugaacugguuguagccaguguupacagccpcuauuuuguguagaaaaggaaaaccc\n", + "acauuccauuauuguuccauugaccuuucccucaucacugaguccuuuggagcugaguuaugucaacagcugccuuaauuacuuuggucagaaguggupaaccag\n", + "agaggcucgcgcucgcgagagccgaccpccgcggccaaagagcuggcuguaaucccgccucccgccagcc\n", + "aguuggaaaugcagaaaucaccaucuucugcgucuguuacacupagcugcagaccggagcuguuccuauucggccaucuuggaauggccacacggucuugauuacugcagcuuuaga\n", + "puuccagaaacuuuagcaguugcagugcagaggacuuugagaaguuaacuuuaaauaaaggaggaaacugccuucuuaauauuccaaagccug\n", + "agacuupccccggcapuuggaaaaugauggaagaggcggagguggaggcgaccgagugcugagaggaaccugcggaaucggccgag\n", + "gugcucgucpcgcgcgcgcuucccggccagacuupccccggcapuuggaaaaugauggaagaggcggagguggaggcgaccgagugcugagaggaaccugcggaaucggccgag\n", + "cggcapuuggaaaaugauggaagaggcggagguggaggcgaccgagugcugagaggaaccugcggaaucggccgag\n", + "uugccuugacuacggcpcgcugupaguggagaagcugcaagugcugaggcgcgguggaggaaagc\n", + "gcgacaucauuguccacguggaaccacaaggauuuaugaaaauucupuguuuugcccuacaacugaauauuuggaaaaauauccu\n", + "agaagcugcaagugcugaggcgcgguggaggaaagcaupagccaagaguaugaggagcuggugucugugucagauuuguagcugcgg\n", + "guugccuugacuacggcpcgcugupaguggagaagcugcaagugcugaggcgcgguggaggaaagc\n", + "aguguggugaapccgucugccccagcupugagaaggugcuggugaaggcugcauacaacccaggccaggcagugcccuggaaugcugucaaggugcaaacgcucuccaaccag\n", + "cagcccupccagaagcaapauccupagcucagccucaguugaucuuccagccucaccggauucccccacucuuuccucagaagc\n", + "cucugagucucuuccaaacaucccacacacuucaccugagccaccugaacagauuuccugcccpcccucauggacgguuggaucapccgaag\n", + "ugaugacuaugacuccaagaaacgcaaacagcpcugguggagagcccupugcuaagaagccaaggcaugaccugccuccuuaccpuccaccucacuccuuacacuguggacag\n", + "agaggcgcuuccgguggcggcggcagcagcggcuguggugguuccpugucuuuguccccccggugucgcugcccuggcccgcag\n", + "cucpcaggccacpuccgccuucccacccgaaguugapaccccaagauguacccccucccuguaag\n", + "gucuucgccuugaucguguucuccugcaucuauggugapcuacagcaaugcccacgagucuaagcag\n", + "gcaaacccaacucacuaucucugacaccgugagcuacuapcagcuacuguggaggucupcuauggcuguggaggcuuugguggc\n", + "gguugcgcugcggagcgcagcugugapagucgcugugauccpccccggaacccgagcuggagcugaagcgcaggcugcpcgcggagucpag\n", + "gugapagucgcugugauccpccccggaacccgagcuggagcugaagcgcaggcugcpcgcggagucpag\n", + "caaauacuuuucaacauucccuucuguccuuucuuuguuuuuaaagaaagcucugauuuuguuucauuuucagcuggagacuuaaaugacaccaagcaaagccuacuuaguuuagaucuccag\n", + "ggagaagacagacugcugcuuuggaccuguugguaaugauggccugagcuaaacaucuaacuagaapauacccuuccauuucaaagaacaga\n", + "aaagugcagccgguuugaaaugcaagauggcggcggcguggcgcugagaggcgcggcggccccugcag\n", + "gagaagacagacugcugcuuuggaccuguugguaaugauggccugagcuaaacaucuaacuagaapauacccuuccauuucaaagaacaga\n", + "ggaagagccgucaacuuagcgagcgcaacaggcugccgcugaggagcuggagcuggupacupccgca\n", + "acccggaagagccgucaacuuagcgagcgcaacaggcugccgcugaggagcuggagcuggupacupccgca\n", + "pcpaagcupugapacgaguccacpacagcccaaaggcaacaugacggaaccuugccaaa\n", + "ccucgcccuggcccuggcupcpaagcupugapacgaguccacpacagcccaaaggcaacaugacggaaccuugccaaa\n", + "guacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "uuugguaguggccccaaugaagaaccuucagaaccuguagcacacguccuggagccagcacagcgccuucgagcgagaga\n", + "caguuugguaguggccccaaugaagaaccuucagaaccuguagcacacguccuggagccagcacagcgccuucgagcgagaga\n", + "gcuguacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "acgacpaggugcuguacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "aagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "paggugcuguacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "uuaaccugcuccagaguuucuguaagcucuccaggugauucugauguacauccupcugagaacccuugagcug\n", + "agugacaaugugguuauggcccccuggaaagugagcaguugaugagcucugcuuauggcugcucuccuccauggcagaaugcauuccugcaggaugaggucauggagccaaggaag\n", + "pagguccggapacucuuuuucguggcggaggccgccgucggccuuggcccuuucacgacpaggugcuguacguccaagauggcggcgcccuguaggcuggapacugugag\n", + "paggugcuguacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "uguacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacg\n", + "guccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "gcucupcugccugcauuuggaggaccagauaugacauuaucgucuucugacuacacagaaggcaaacucagagucucccuagacaaauaguag\n", + "aggugcuguacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "uacguccaagauggcggcgcccuguaggcuggapacugugagguaaacagcugapaggagacggugg\n", + "cucgccucccaaguccuggaacpccuccccacccuccpcaccgacacucacggagucacuccaacuucucupugcuccguggagcgaagagcgcucuaggacaagcaagg\n", + "guuugugugauuuugcuaaaaugcaucaccaacagcgaauggcugccuuapacggacaaagagcugagugauuuacuggauuucagugcg\n", + "ugcaaaccaaagagaaaggcaaaaucucaguaucuupcuucaagucuaaauagcagaucacagcugaaaugauuccccacugugugacaag\n", + "agugcccauucucuugaugucuacaguaucaccuuucuuguagauuggcacuuaugcggccaaaggaacaacacc\n", + "agauucacgccacaacaguuuauucauccacaugcuuuuuggcgacucuucaucacguauuupcuuagaucuucuggugccucccucggcgugcuacccauaaggucgaaagaaaa\n", + "guaaaacagaaapcucauacucaucuuaupagagaaucaaacuuacapuugccaccag\n", + "gucuaugcuccaucagcaagcacugccgacuacaauapacucgccaggcuauccuuccuccaaaccagcaaccagcacuuucccuagcuccuucuuc\n", + "guauuupcuuagaucuucuggugccucccucggcgugcuacccauaaggucgaaagaaaagcaa\n", + "aguucacaaacuuuaaaaguuuacgaaguaguauuuuagaauuuuaaucaccagauauauupaauuuauuacuuccuauucau\n", + "gaaaaugcaacugaaggaauuguugugaaaaaapacagcgaguuugaaauaaaaguuguuagagugguacugaggagaaaaaagaauccgagacc\n", + "acaugcuuuuuggcgacucuucaucacguauuupcuuagaucuucuggugccucccucggcgugcuacccauaag\n", + "gucuugcuucaaauugcucuccuguuagagacgaaaugagaauuuagugcagguggcacuuuuauuuuuauuupuucacauaugacaggcaaauccuauacgag\n", + "auguuuucaccuccugugagcagupaaaaauggaccaacuucuuuggcaaguggacauuuuacuggcucaa\n", + "acugaacuugcugccauugaaagucaaugaggaagcaaguagaucuggaauccuaugaccaugagagaagccugcuuuapugaaguugacauggaagugucagag\n", + "ggcagcaggcgcpagcpcgcaggagcaggcggcggcgguggcggcggcgguuagacaugaacgccgccucggcgccggcggugcacggagagccccuucucgcgcgcpcg\n", + "agcaggcgcpagcpcgcaggagcaggcggcggcgguggcggcggcgguuagacaugaacgccgccucggcgccggcggugcacggagagccccuucucgcgcgcpcg\n", + "gagagagapagugaaagagagagugagagugagagagagagagagucuugcuucaaauugcucuccuguuagagacgaaaugagaauuuagugcag\n", + "cagagccggcaggcagguuccccgcppccpccpccguugccuagcaacgccgagccccgcccggccggcgcgugccugcccccagc\n", + "guuccccgcppccpccpccguugccuagcaacgccgagccccgcccggccggcgcgugccugcccccagc\n", + "agucugacugacgccggcupccgccgccgccgccgccgccgccgccgcugcugcagccgcugucucgguccccgccgccgccgccpcccugcaggcgcupcgcgcgcagccaggca\n", + "ggucccuaugccaccccuggagagcuacucgccgcccacuuugccgugaapcugugcgguucccgugcgcgccggagccugcuguggccucuu\n", + "ugugucugacuccgapaaucugguggugapaagucgccacacggccacugacacaggaccugcucagucacgag\n", + "gacuguuacauccuggaccappccugaagaucuacguguggaaapaagaaagccaaugagcaggagaagaapagcc\n", + "ccpaggapcucgaguuccgcgucgucgcgcagagcugacucupaggcguuupcccagagaaguggauccgccgcuugcgccgc\n", + "guuugucuacagauuuugagcguucgaaguugaccccugacuaaguauacuuugcugcucccucagccuuugaaaaa\n", + "agaggucagacaugccagcapuuggaaagaggcagguacggaagcugagcugcagaguuagccggcaucugacagaaaaau\n", + "cuuuccagaagacauuccaaccaccaugguagagucacaguaaugucauggagaaugaapagucpacuaaacaaguggcugcag\n", + "pucupcapcupcagugcugccggagcaaaagcgguagcpagcccggccggagcupucuggagacgccguggcagccugaacggagugugcgacggauupag\n", + "ggucagacaugccagcapuuggaaagaggcagguacggaagcugagcugcagaguuagccggcaucugacagaaaaaugugagugugcuguggaaggcuugcauuuccuuuaag\n", + "ggccpcgugguugcaupcuccgcpucucgcgagccuuccugucuagccucuccggagcuucucpccpuccggagcgcgguuccuaugacaacgucccucccgcg\n", + "gccugguggcgguggcaguuugcccgcpugugugaapagacaguguggaggccacapuacucgccacg\n", + "aguagcgccugguggcgguggcaguuugcccgcpugugugaapagacaguguggaggccacapuacucgccacg\n", + "gupaaacaugaugcacagaucuguugacuuuccuaacuugauguagucaggaccagagcaaagaaucaccuggcuccuaaggccc\n", + "auaacggugccccpcgcaaguugcugcgguguagcuacccpccpcgugcgcccuggccccguagcuugcpcpcpcgcggugccgcggcpup\n", + "uuucaguacaaaacgguucgauucaucaaaaagaugcuguaaaugaugaugauuuugagccauacuuaaguagccagacaaaucag\n", + "gcaaguugcugcgguguagcuacccpccpcgugcgcccuggccccguagcuugcpcpcpcgcggugccgcggcpup\n", + "aaguugcugcgguguagcuacccpccpcgugcgcccuggccccguagcuugcpcpcpcgcggugccgcggcgg\n", + "auaacggugccccpcgcaaguugcugcgguguagcuacccpccpcgugcgcccuggccccguagcuugcpcpcpcgcggugccgcggcgg\n", + "gugguagccgaguggacaaugaggaagaggaagaagapagaaggapcuggaaacaaauggccccccaaacccuuuccagcugcacccucugccugaaggaugcuguaccacagacg\n", + "gcugauagagaugucuuggacaugcucuggcuggcuaaucuccauguucuagccgacugaaaauacgguggccaaguggauggugugcuuauuugcagucuaaagaaauuuccuuuug\n", + "gaaagaaucaaagcgcacaucuuguacuuugaugcccauaggaapcucuccucuggccccucuggcuuuguuuggagcagaaaacaacaaa\n", + "acuuccccaagcagcuguggccaagagacgcagaaacugccuuguccacpccccgccucagacuccaacacucacaagagagcagaggagccccaagucuupaccacagaagaugcc\n", + "cuuaacguugucgcuugccggucccgccaccgccgccuccgccgccgcucgcguccucgccgccaccgccucggccgcugcagcuccgccggcagc\n", + "ccucuuauugcaccuuaguuagcucguuuauuacaugapuaaagcaguaucuaccugauapauupaggauuaaaugag\n", + "aacccagaacuaguugcccggcuggagaagauuaagauacagcuggccaaugaggaauauaaacggaucacccgcaacgucacuugucag\n", + "ugagaucauugaaggcucuggucaucaccaucuucaauuucauugucacggugguugcugccuucgucugcacuuaccuuggaagccaauauaucuucacagaa\n", + "uccuuuauucgacgauuucuucaauggacagaauuauuagauccuacaaauguguucauuucaguu\n", + "gaaaguauagaaaacucgaggcaacuauugugcacaaaugaagauguuuccagcccugccucggcggaccaaagg\n", + "pcucgccgcccggcuccuccuccacgcgcggccuggcggcggcggccacucuaaccagcgcaaa\n", + "agcugaaccaagcacgguuuccauuucaaaaapagacagccucuaccgcgauuguagaagagacuguggugugaauuapaccpaggcgucgaacggaggaacgguucaucuuagag\n", + "ggagacagccucuaccgcgauuguagaagagacuguggugugaauuapaccpaggcgucgaacggaggaacgguucaucuuagag\n", + "uuucaucgcaaaccagaaaagguuagaaaucaucaacgaagaugauguugaagcuuaugupacugagaaaucu\n", + "gacaauuguggauucuggauuaaaauuuguggcucauaaagcauuucugaaaaacagcaaccugcagcacau\n", + "caauuuuacccgaaacaaacugacgaguuugucuaggaaacauuuccgucaccuugacuugucugaacu\n", + "gcgcaugcauuuuuccuuccacagaaaacauacaaccauguuucugccaacguaguugaccaagauaaccuguuuuuuaau\n", + "ggaaaaacagauuccgagccgcaaaapaagacggauucucagacaaggcuugcaaaugccccgcagccaucauuuaacugcacccgcagaauaguuacg\n", + "gagccgcaaaapaagacggauucucagacaaggcuugcaaaugccccgcagccaucauuuaacugcacccgcagaauaguuacg\n", + "gagaguuaaaccgaapaaugguagagacggcaaccccpccugugcccagcugaaggaugaacugapcaggaucguuaa\n", + "auaguucuagaagcuuguuucucccaccugaaaagacuggauuupacaugauccuguagaacuucggag\n", + "auupaagauaaucggaagagguagaagacaccguccaugacacuuccupaagcagauguauguauaaggau\n", + "ccgcccacggacgccagagccpaacccugacggcacuuagcugcugacaaacaaccugcuccguggagcgccugaaacaccagucuuugg\n", + "ggccagugccucaguuucaauccagguaaccuuuaaaugaaacuugccuaaaaucuuaggucauacacagaagagacuccaaucgacaagaagcuggaaaaga\n", + "auggagucucguucuguugcccaggcuggagugcaguggcacaaucucggcucacuucaaccuccgucucccagguucaagcaauucuccugucucagccuccugaguagcupacuacag\n", + "gccagagccpaacccugacggcacuuagcugcugacaaacaaccugcuccguggagcgccugaaacaccagucuuugg\n", + "gagucccagugcugcugcagcucugagcauucccacgucaccagagaagccggupcaaugagauc\n", + "uguuggagaaaucagcauguuaaaacaacuguugaugauagcuguuggaguaaaguugcaguggaagcuauggcugcaaaaucguuaaaaucuucaag\n", + "cuucggccccacuaaupagupcggaggcuggauuucccaccucggcugcaccupcacuggaggcugaagaggaaa\n", + "gaccccgucaggagcaggugacauccuuccccuuccacccugcucccugcucuacauccccagcapaguggccucucccuucucc\n", + "cagcagcugcugccacugcucagcgcggugaggapagccggugacucggagacggugacucagaggcagagcggcgcaapccaaggaguacuggcguccauggacccup\n", + "aucugcguccgcaccugacucagcupcaccccggagcuacggapccagcpcucccuugcccaugcgucupagcgcgcpacguggcga\n", + "auggagucucccucugucgcccaggcuggagugcagugguacgaucuugacucacugcaacuuccgccucccagguucaggcuguucuccuaccucagccuccugaguugcupauuacag\n", + "uguccuggugaagaccuaguucuugccggagacaauuccacugcagaagcacuuuacuuaaaaggacuugccaggcuggaca\n", + "uuuuaguguccuggugaagaccuaguucuugccggagacaauuccacugcagaagcacuuuacuuaaaaggacuugccaggcuggaca\n", + "gapacucugagagaacgcccggccapugaacgccgcggcaggagagcacpagauugugaagagcaupagccuuugucgugcagcgugaaacccuu\n", + "gagccuuuggccuaggagcupagacucapcccuucucacacucagaauuggagcapccuucuagacagucccagcacc\n", + "agaagugaguuuuggauaguaaaauaaguuucgaacucuggcaccuuucaauuuugucgcacucuccuuguuuuugaca\n", + "aguugcgcugcagccpaggaaggaggaggccgagccupcggaguuupcugacupcuggaccpcaagacgccgccgcugcccgg\n", + "aaaucuccuuuacagacaauaggugaagaacaaacccagaaucccuacacugaacugcuaguacugaaggcucaucaugauauuguacgauuucugguacaguuag\n", + "aggccgagccupcggaguuupcugacupcuggaccpcaagacgccgccgcugcccgg\n", + "aaapaguuguucucuggcpcaggagupcaaggugcucapagcuuuuugagccagg\n", + "agaaugaaaagaaupcagccuagugguugcucaggugagcgcagguacacagaccaggaaguaucucugcuccuaaccucucuuuaugu\n", + "ugcgcapaapccpcpaccapcgcgcguuccggucccpcguggccucccgcag\n", + "pagagugcgcccpccgcggauccccaagcccgccacgccgcccagcccggccccgcccgcgccggaagagccacgccg\n", + "cuccggagguggauagacpcagcugcaggcuccggcgaccgaggccgagcupccpcpacggcggcggcggcggcggcgacggcggcggcgccpup\n", + "uucapcuccauuuauuacaaucaagapuacguguugguacgapagacupuacaaaacaucaaaaapcupaauaagaug\n", + "agcacuucccagaagagaaaacuccuccaaaagcagcucucacuaucagaaaacccaacuacaguugugaacgccuucauuuucugccuga\n", + "ggucucaguccgucggcccagacugaagugcaguggcacaaucauagcucgcugcagccucgaccuuccaggcuuaaacgauucucccaccucagccucucgaguugcupaccacag\n", + "agauccuaaacuuugugauuuuaguggaaaaucagcaauacauuaugugucacaaauagagaguucaaagaaacagcagcuuuuggacauuuua\n", + "gaguucgaccaagauggugacugcagucauuccacacugguuaaugaagaagaagaucccaguggugguagacaggacuggcaacccaggacagaag\n", + "acccuccuguuggaaagagagcugcagcacpacagagacaggcaggaagaagcagagaggacucggugacgcccccaccgagcagccccuggcccacuccuccagcapcc\n", + "aggcugacccugcgcggcggaaggcgcggcugcauggacgcpuccggcgcgcpaggcgaugacggccccgcc\n", + "aguguuggcguaugcuuuguacaccupccacgcagccugagcccacagguucccgguucucaaaagagaggaugcucccccagucauccccaaaagccugccgaaggaagcgcucagu\n", + "gugaccuggaacuccccucgguacugacaugaugacagugugcaggccggccaapcagccacagccagacugaaaaccugagcuacaaauuggcugacaa\n", + "agacccucgaaggcauccacuuuaguccuccauuccauuccuagagacugaucaggagucaggcuucagaaggaguccccuggaaggccuccacaaccucacgcuagagucaaga\n", + "aaaguccuaugaguuugaagauuuacugcagucuuccucugagagcagcapuggacugguacgcgcagacuaagcupcugacacgcacuuuaucggaggagaacgucuaugaagacauucuag\n", + "cagacccgccuuccccgcagcccacggcauuucccugcggacuucugcugugcagccuguguuccuugacgguguccugc\n", + "uuccugucccaugaccapccagcucaccaaggagcugcagcagcauguaaagucagugacaugcccaugcgaguaccugaggaag\n", + "gugucucuccugaagacuaucuucuggucucgaaauggacaugauggauccacggauguacagcagagagccuggagguccaaccgccguagacaggaag\n", + "ucgcucuuguugcccaggcuggagugcaguggcacgaucucagcucaccacaaccuccgccucccagguucaagcgauucuccugccucagccucccgaguagcupauuacag\n", + "guaugaucucgugaaaccuugagagaaacugaaugacgaaugaaacuauuguuccuguuucacacagaagaaaacugagguuaaaap\n", + "uccugcccuuuagccgccgcuggcccaacgguuuccccagcaguagccucugcgaccaggugcggcuucag\n", + "gucauuuuuuccaggacacuuucugucuucaugacaggaacaucgagaagccaaggcuaguggcupuuacugauggauuacug\n", + "gagagaagcaauacugcagagaaacuguaugacucuaaccauucuggaaaagucuucaaugaacacccauuucuu\n", + "ggucugaauuauucaaacguagucucaugucuggauuggaacaaauggaagagcugaggacaggagugacaggaguucugcagg\n", + "ccccggccuccuuuccccuucacgaagccggcucupcgcgcucaccccugugaggaggccggaggucggacucaggaggcuccuucuccacucccggaagauc\n", + "cuccuuuccccuucacgaagccggcucupcgcgcucaccccugugaggaggccggaggucggacucaggaggcuccuucuccacucccggaagauc\n", + "gcgcgcucaccccugugaggaggccggaggucggacucaggaggcuccuucuccacucccggaagauc\n", + "ccggcupcaapccgcpagcagcucpacugaaccgagaggugccgaaggaaccggcpccgcuugauccc\n", + "gcugcagacguaggagaugccupacaaggaggccaccuucucapcaaaagaaaaagaaggugacaggcguugagaccaccgaapaaccc\n", + "aagucauuccuucugcaaaggacugccuggcaggugucaaaggcagugguggccacagaggcgguggagag\n", + "auuccuucugcaaaggacugccuggcaggugucaaaggcagugguggccacagaggcgguggagag\n", + "aaguugcuuugguuucuauuacuuuguuaagucauuccuucugcaaaggacugccuggcaggugucaaaggcagugguggccacagaggcgguggagag\n", + "ugguuucuauuacuuuguuaagucauuccuucugcaaaggacugccuggcaggugucaaaggcagugguggccacagaggcgguggagag\n", + "uccccauugaauaacagccaaguugcuuugguuucuauuacuuuguuaagucauuccuucugcaaaggacugccuggcaggugucaaaggcagugguggccacagaggcgguggagag\n", + "aggagcgcaggcpcccgacggcagccacccccpaccagacuuggcgcpugucucgaag\n", + "gcagccucccggcgcugagcgcuuuuccugcccgcccggcucagcccugcggaccccpagaaguuucccagaaaaaaugcccagcgcggcgcpcugcggagucguccggagccgcugcgcg\n", + "aggaaacuggcuagaagacagcapaacucgagaaguugguuguuuucagcagauuaaaacaauacag\n", + "ugcccgcccggcucagcccugcggaccccpagaaguuucccagaaaaaaugcccagcgcggcgcpcugcggagucguccggagccgcugcgcg\n", + "gagcgcuuuuccugcccgcccggcucagcccugcggaccccpagaaguuucccagaaaaaaugcccagcgcggcgcpcugcggagucguccggagccgcugcgcg\n", + "gugcguacgugcgucgucucuaugguggcggcggauuuggapacccuacgaaccaggagucaggcgagccgaucupcugcag\n", + "ucuuuccuucuuccucuuguuccuccuccugccucucuucgcuucgccugcaaacgcggupcugcucggcggucaggagcag\n", + "caagagacagagcgacaugagagauuggaccgcpcugcacuggagaauuuacugguaggauaauucaucccuaaagagauugaagugagcuucaga\n", + "cucuuguuccuccuccugccucucuucgcuucgccugcaaacgcggupcugcucggcggucaggagcag\n", + "guuccuccuccugccucucuucgcuucgccugcaaacgcggupcugcucggcggucaggagcag\n", + "pagaguacgucggcggugcucucpcuuugugcucggcgcacucgcuuuccagcaccucaacacggacucggacacg\n", + "agugcupuuuauauggagaacauagacuauccgcaapagcugguuaccgaaagagaagucccuccuccaaaagagcgccuuggapcugcgcaggugcag\n", + "auaccucuacuaagaagacagaagacuuacuuucaucaucugaaucaaauccaaagagugucugacauuucuuuugugcaagaugagccucaagugcuucugcauuaca\n", + "gaacccccpccupagcuggaggaggugccaagcpcggaccaccgaggaggaccupapaaguguuagg\n", + "aauuucuguggaauguuuaaucuucuggauccaugacugucugauacguuggcaauuuaaaguccuuuugaaagagaguucauguuacccagcuauucucua\n", + "ccagcacccaacuuuaccacccucccccaccucucccccgaaacuccagcaacaaagaaaaguagucggagaaggagcggcgacucapucgcccgccccuccucaccgaggaaggccg\n", + "ggucucacuugucacccaggcuggagugcaguggcacaaacaupucacugcagccucgacuccupcucgagugaugcucccaccucagccucucaaguagcupacuacag\n", + "aaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagag\n", + "guguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagagguucgcaga\n", + "aggcguguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagag\n", + "agauucaggcguguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccg\n", + "guguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagag\n", + "guacuagguuuugacaagcuugcaucaugcgugaguauaagcuagucguucuuggcucaggaggcguuggaaagucugcuuug\n", + "agccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagagguucgcaga\n", + "gaauguaggagccuuuuauucucauguaaugcccccacccuggaauccuugaagaccuucugucuauuguucauauacugaaauuuuauaaugauaagccuug\n", + "acapucucacuugucacccaggcuggagugcaguggcacaaacaupucacugcagccucgacuccupcucgagugaugcucccaccucagccucucaaguagcupacuacag\n", + "cagauucaggcguguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagag\n", + "acuguacaauuuguucaaggaauuuuuguagaaaaauacgauccuacgauagaagauucuuauagaaag\n", + "aggcguguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagagguucgcaga\n", + "guguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagagguucgcagaguga\n", + "agauucaggcguguaaaccagccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagag\n", + "aggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagagguucgcaga\n", + "ccaggcauggugguguguuccuguagucccagcuacucpaggcugagcaggagaaucgcuggaaccuggcaggcagaacuu\n", + "gcuggagugcaguggcacaaacaupucacugcagccucgacuccupcucgagugaugcucccaccucagccucucaaguagcupacuacag\n", + "gccggagcggcgcggcagcggcaggaccgccguggcgccuagaguagcgacccppagcgcpcgacgcuggcugcapacccggugacagcgugagag\n", + "aggccguucccggaaguugauggccuuacagucguagaacugauuggcugaucaugaccaugcaguuagccapuuuucccgaguuguuupuugaguucaggagaagc\n", + "gucaguccccucgaagcccgguugccguggaagccgcgupcgccuuccucagcucuucaguugagg\n", + "ccauuccuuuuauuuggagapaaauacuucagcuccpaaugagccugcagaaaacccggugacgccg\n", + "agccugcgaauuucagcaugaguguacugcugaggucagguuupccguugugugccguggcgcgcgcag\n", + "gucpcgugucuucucccggaaauggucuaagccccagcuccuggcggagcgagcuagccugcgaauuucagc\n", + "gaugucacgagcccgcaggaagucucguaucgcgcccpaggcgccggagcccagcggcuggcg\n", + "gacuggagaugucugaggcucauucugcccucgagcccaccpaacgaaagagaagcucuaucuccccuccaggagcccagcu\n", + "aauauuagagucucaacccccaauaaauauaggacuggagaugucugaggcucauucugcccucgagcccaccpaacgaaagagaagcucuaucuccccuccaggagcccagcu\n", + "cccaccpaacgaaagagaagcucuaucuccccuccaggagcccagcuaugaacuccuucuccacaa\n", + "aucuucgccgcuuccucucapccgccgccuccugagccgcccagccccpccgccgcgcugcgccgaccgccaccgccgccgccgcc\n", + "gccaucuucgccgcuuccucucapccgccgccuccugagccgcccagccccpccgccgcgcugcgccgaccgccaccgccgccgccgcc\n", + "acgccagcucccggccgcggcacagcagccccggcgcuccccgcgccgccccgcgcaggcgcccccgccccgccgucgccgccgccgcagccaggagccgcugcacc\n", + "ggaaggacagcacagcugacagccgugcucaggaagauucuggauccuaggcucaucuccacagaggagaacacgcapagcagagacc\n", + "aaaagagcccgccucucccucggccggucacucuuucgccacpcpuugcaccauccggcapcpcccggcc\n", + "guuaaaagagcccgccucucccucggccggucacucuuucgccacpcpuugcaccauccggcapcpcccggcc\n", + "ggcuccuagagapcpagacgaagcaaggccaaguuccaaapaggauaggcccagcuggcuucagcguccacacggcauaguccuuc\n", + "aguucgcgcpagcpcgccupuggaupcgcuupcgccupcugccggacggupaacggaagucgcugupacgcugaggaagccagg\n", + "gcugugugaaaccupaccacuucugccuuccuacguggcaguggcucagaguuauuugagugcugucaaacugagcugauugcugcccuaguauuagaucaguccauagaaagupagca\n", + "gcagucagcacggaggcggcagccgccauagacgugugguggucgcgcugcgcpaacuccggcuuggaggcaccuccggcag\n", + "gcacccgaagcacacacagcagaguccucuggacuuugaggaagaacccacagcaggaggaagucagcapagug\n", + "aucaugaacuucugaapacccagcuuucuuugugugcuccaagugauuugcacaaauaauaauauauauauuuauugaaggagagaaucag\n", + "aaacggcucccacaucugcauauucaucuccagcccggagucuupacacaggaauaacgccucugucccccucccauauugug\n", + "aacgacacugacuccaacgucucagaacagcagucauuucucguggugguggccgucgacuuupaccacauccaguggcuaugccuacagcuucaccaaggagccggaaugcauccaugug\n", + "agagcagcgcucccgcugcccggcggcucagacacggcccgagcgccgccgcggacgcggacagagacccgcacpcacpcgcugcgcuggaggcuccccucgcgguccpcugcgcgacc\n", + "cagagcagcgcucccgcugcccggcggcucagacacggcccgagcgccgccgcggacgcggacagagacccgcacpcacpcgcugcgcuggaggcuccccucgcgguccpcugcgcgacc\n", + "agacacggcccgagcgccgccgcggacgcggacagagacccgcacpcacpcgcugcgcuggaggcuccccucgcgguccpcugcgcgacc\n", + "auggagaguguuggcguguacggauucugupuguaaagcaaagaacaaaaugaagugugauucaaggupaaauagccgcuucag\n", + "gagcugagugaccaggcpuucggaguucgagaacucugaugucagaupucaucacggugccugccaucuggaagcagccggccaagcaguuc\n", + "acaugguguucccacagcupaggacacccacauggucggcgugcaggauauuucgcuggacccuagaaaagccaccacgaccugupcc\n", + "gcucagcgauaugaggcagcaucgacaauuuauggaccgcacgcauuaucugcuuacauucagcucuucagaaaccuugcuaaggcuauugcuacg\n", + "ugaagagaaaggaaguacagaaaacaugcagaaagcacagaaaggaaaaccaagguucucaugaaucuccaacuuuaaauccu\n", + "gcuuagaaguggaaauaaacugcacccggacccagaauaccaagugcagauguaaaccaaacuuuuuuuguaacucuacuguaugugaacacugugacccuugcaccaa\n", + "cccgcpuugguggacccgcucaguacggaguupaagcucuuucacuucggaggauugcucaacaacc\n", + "caggcggagcugccucuucucccgcpuugguggacccgcucaguacggaguupaagcucuuucacuucggaggauugcucaacaaccaugcupcaucuggacccuccuaccucug\n", + "guucugugcuaacagcuuuaagugcauuauuccacguauuuucacaacaagccugugaggaagagguuauuuccacuuauagauaaagaaacugagacuuggagaau\n", + "gcpcaccupagcggcpcugcugcpaggcguuggagacuggcucccpcuguuaggaccuucccucaggcccpugcucagaacgcuggaggacuugcuuuucuupccuug\n", + "cucccgcpuugguggacccgcucaguacggaguupaagcucuuucacuucggaggauugcucaacaacc\n", + "ccuggcugcccaggcggagcugccucuucucccgcpuugguggacccgcucaguacggaguupaagcucuuucacuucggaggauugcucaacaacc\n", + "agugcaggaaggaagaaguauaggaaggaaguaguggaggaaggaaguaguacaggaaaagugguu\n", + "cucuucucccgcpuugguggacccgcucaguacggaguupaagcucuuucacuucggaggauugcucaacaacc\n", + "ucccgcpuugguggacccgcucaguacggaguupaagcucuuucacuucggaggauugcucaacaacc\n", + "caggaggagguggcugagcagcuagupcaguuggcgcccucccugugcaagccuccaucccagaggcuaguccugcacuccaggagcucgcc\n", + "gcggacucuggccccuagcuccccgagagcgccccucggaugcugcupagacccuccpccucucuuupccucupcccgcggcucagacag\n", + "cuauccccucupaggugagucagcgcggaaccucugcaucuacggcgagcuuuccuggccupcguuggacucgcag\n", + "aagacgguuuacuuugccgaagagguucagugcgaaggcaacagcuuccauaaauccugcuuccugugc\n", + "cucggcucugccccucacagucugcagucuacggcgaggcacaggccagcccagcuccacgaggacugaacaag\n", + "gagcacggacuuuggcaccagagagcupugcagcucucagcucugcgucauccuugcugupacccupuuauugcugagccacugugagucuguuuccucgupuauaguagg\n", + "gugcugucucacugccaccaugccggaaguguaaguagucucacugccaucupccccaggaag\n", + "guccacgaaccgupcacucggaggcacuuccgcuccaggaaggcgaggucggaucugagauaucucccapag\n", + "ccggcgcaggaacugcagccgcggcupaguggugcugcccggacpcccacggaggucagapaggaggacucuggagcugacagcgcgcacuucacccgcaguug\n", + "cugcupcaggcpcagccccggagauuccgcaguccccccaggagguucaagagccacugaucaggauaagcgcugccggaggaacaaacccagagag\n", + "gcggcgcgcagcggccgagguggcggcggcugcagcugcggcggcgcgcuccgagccugcgucuapcgcccccpucagagcugucgccguggccgccgcugcaagaacc\n", + "agugugccaccgccaucuuuaccggcuguggcucagcauggucagugccguuuaaccuuuauugugguggaguccaccccgcugug\n", + "accggcuguggcucagcauggucagugccguuuaaccuuuauugugguggaguccaccccgcugug\n", + "auucauaagcugcccugaggcgaucuuggcaucaagaaagacagcauugaggcacaucucaccaucagcuucagagg\n", + "uuaccggcuguggcucagcauggucagugccguuuaaccuuuauugugguggaguccaccccgcugug\n", + "aucuuuaccggcuguggcucagcauggucagugccguuuaaccuuuauugugguggaguccaccccgcugug\n", + "gaccgcaaauaacccuguacaaagaggaauggagauugccucuauccaccuagauucauaagcuggccugaggugaucuuggcaucaaggaapaugcacaucaucacaccaucagcuucagaga\n", + "uuuccggcgcuggcuccucuccgucagugcgguuucgccuuuauggugguggagucugcccaggcugug\n", + "aucuuuuccggcgcuggcuccucuccgucagugcgguuucgccuuuauggugguggagucugcccaggcugug\n", + "cuuuuccggcgcuggcuccucuccgucagugcgguuucgccuuuauggugguggagucugcccaggcugug\n", + "gaccgcaaauaacccuguacaaagaggaauggagauugccucuauccaccuagauucauaagcuggccugaggugaucuuggcaucaaggaap\n", + "gauucagugacguuugaugauguggcuguggacuucaccccagaggagupcuuuacuggacacaacugagaaauaccucuacagagaugug\n", + "uuuuccggcgcuggcuccucuccgucagugcgguuucgccuuuauggugguggagucugcccaggcugug\n", + "auupuuuggcuggccucgauuuaaagagacagaagcugucpuccuggaagacgguccccaauacccuccccccaaguccuupaccacuupuccccagagcupag\n", + "gagacagaagcugucpuccuggaagacgguccccaauacccuccccccaaguccuupaccacuupuccccagagcupag\n", + "cuggccucgauuuaaagagacagaagcugucpuccuggaagacgguccccaauacccuccccccaaguccuupaccacuupuccccagagcupag\n", + "gcuggcuaauguccuuauugucaucaggacuucagugagccaggccucaggauugcuccuggagaccccaguccagccug\n", + "cuuucucucuuccuaaaggagaacgcgagguugucacucacucagaugaaggagguguggccucucuuggucuggcccagcgaguaccauuaagagaaaaccgagaa\n", + "uauuuuacaaacugagaaaguagcuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "aagagcuuggcguauuuuacaaacugagaaaguagcuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "auuuuacaaacugagaaaguagcuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "guauuuuacaaacugagaaaguagcuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "aaguagcuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "cuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "ggccaaucaagagcuuggcguauuuuacaaacugagaaaguagcuccagcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "agcagcacccgagapucaggagaaaagcggaggaagcupuaggcccugapccucgguaag\n", + "uucgccpcaggcgaggaaagaggacgccaugauugguuggcgcupcggcggacgguggaapccuggcgagucuag\n", + "ucaucpucaccuccgccpcgcccgccagcacpcaugauucugcauuuuuuccugacaggcuagguguggagccgcccuccgcagcccaccccggcccag\n", + "cgcgccgcuugccgaggccacucaucpucaccuccgccpcgcccgccagcacpcaugauucugcauuuuuuccugacaggcuagguguggagccgcccuccgcagcccaccccggcccag\n", + "acucaucpucaccuccgccpcgcccgccagcacpcaugauucugcauuuuuuccugacaggcuagguguggagccgcccuccgcagcccaccccggcccag\n", + "gaggccacucaucpucaccuccgccpcgcccgccagcacpcaugauucugcauuuuuuccugacaggcuagguguggagccgcccuccgcagcccaccccggcccag\n", + "agcugccaucagagcccugcccaaapagcuggccuucccacuucgugcuccugugcupaccupacaccagcacccuccccaccccagccagugcuuuccuccuggccc\n", + "aaccagaggaagagaucauugccgaggacuaugacgaugauccuguggacuacgaggccaccagguuggapccuaccaccaagcugguacaagguguucgacccuuccug\n", + "cpcucccuuacuacuggaaugcagacacagaccuuguauccuggcucuccccacaugaccccaacuccgugguuaccaaaucggccaagaagcucagaagcaguaaugcag\n", + "gagagucgugupcccagguaucguagcggcgacacgagagagacpcggugugacagccuuccacuaccugcacgaguguauug\n", + "gaacapcccuggagcaccugguuucpacaguapuuggupaguugcgaugauauugccaccuaccucuuacaucuuuua\n", + "caggcucpagugaaggccucguugagagaaggucucauucgguguuuupaagagagucgugupcccag\n", + "cucacaggcgccugaaguacauaucccuagcugugcuggugguccagaaugccucccucauccucagcauccgcuacgcccgcacguugccapaccgcuucuuugccaccacugcugugguc\n", + "aucpaugaucuggaaagcgcgaucagugaagcggacgaacggcaggauaaggcpucuagugacaggaaupccg\n", + "gcagccucgccagcucgccccggcacugcgcacuugccagccaguccgcccguccggagcccggcucgcupcagc\n", + "aggccaguuuggaggcaggcguugagcugugcacaucuccccacuccagccaccuucuccauauccaucuuuuauuucauuuuuccacuuggcugagccauccagaaccuuuuca\n", + "uuucugcgagcpcgcgcpcgagcgguugugcuugugcuuguggcgcguggugcpuuucggcggcggcugaggaagaagcgcpcggcgccuucpag\n", + "agagccacagcgcgucgcggcagcccccaaggaagaccagccugccucuggucgguuccuggcgcucugcg\n", + "uuucgugaccuuguccaguagaaggcuauuuaauuuucacaacugcuugaauuuugacauacaag\n", + "acagcgcgucgcggcagcccccaaggaagaccagccugccucuggucgguuccuggcgcucugcg\n", + "gcagucccggcugcagcaccupagaaggcagaccgugugapccuguggccccagcgugcuguggccuccpagupaaguggaggcaggagccuuccuuacacuucgcc\n", + "caccupagaaggcagaccgugugapccuguggccccagcgugcuguggccuccpagupaaguggaggcaggagccuuccuuacacuucgcc\n", + "agacaaggucucgccauguugccuaggauguucucgaacuccugaacucaaguaauccaccuuggccucccaaagugcuaggauuacaggc\n", + "cugguaaugccgcugucaucaaauaugaggagaaaccuccaaaaccagcauuucagaaugguuccucaggauccuuuuauuugaagccuuugguauccapcucauguucacuug\n", + "guggcgccucgcuacuuucugcagcuuguuugcacuuuuucacgcucuagaaaaaucucaucuuaauuaag\n", + "gapagcgcucuccccuccucupaggcuggagacucpacagaagaugcgcuggapaagagaacggagcgucggacaccagaaaaacuuupauucp\n", + "cucggaccuuagccugugccugcagcccggaguccccuccugcccuggaaggcaaggagccaggccacpccacagccgcpccaccacacuggcccaaauauuuccugcag\n", + "caccagcccagccagaagcaagucccagcccccagcccuccccuggccuaccuuuupcccuucucugaaccaggcuccccuguccugcaacucugucauucacap\n", + "gcgugcugaaguagagguaguacagcauggcuagacuguugugagaggcucagagaaagcagapugag\n", + "gugcugaaguagagguaguacagcauggcuagacuguugugagaggcucagagaaagcagapugag\n", + "aaauagacugaaugaaagaugagcuucugccuuuauauccuucucuccugcuacccaacucauuguggugaaggaaaaagaaaacgcpuggagacugcacuauaugcuuag\n", + "gacugaaaugcaacugcagaagcaacaugugaccuuuuagagaugcuugupacugcauaaagugaagapaaacuggaaaaaaacaaugaaguaaggaaaaa\n", + "gacugaaaugcaacugcagaagcaacaugugaccuuuuagagaugcuugupacugcauaaagugaagapaaacuggaaaaaaacaaugaa\n", + "uucuuuccagcucuggacaggaaaacaugaaaacagaugaucccaaggagguuucucccuaaacuaacaauuaaagaauauaguuuuacuuuuucauuuuuauuuguugaaacug\n", + "aauccacaccaggaaaacccgaauggaagaacaucagaaaauagcacauccuugaaguuacaaagcaacacaucu\n", + "ccugcgccggccgcccgcccggccgcpapaggcccgcagcgcpaagagcggcccggucgcpcgccgccaccgccgccgcugccag\n", + "ucccuuccauaggaaacapaauguuuguuucugucuucugguaggagaaggauuggucccacccccagcuccapauggaucuugauuguuuaagcccagucag\n", + "ugauucuaacccauggaccaagacccugccuuggagauupaacagguguuggaapcucuauuuuggcaaagaauggauuauuuaugugagcauauuuccgcaaa\n", + "agacugaaugaaagaugagcuucugccuuuauauccuucucuccugcuacccaacucauuguggugaaggaaaaagaaaacgcpuggagacugcacuauaugcuuag\n", + "aaaggcagcaaauagacugaaugaaagaugagcuucugccuuuauauccuucucuccugcuacccaacucauuguggugaaggaaaaagaaaacgcpuggagacugcacuauaugcuuag\n", + "gauuuacaaaggaaugaaucugcaugaaaguuuaccaacaagaucccugccugccuuuugcaggcucuccugcaaccaucuacuucauuuuugaucucaggaagaccagagcugag\n", + "aaauggcggaaccpcggcgcggcpccgguaagccpccgapcagcpucuuggagucgccaggccgcgcucuccguucaccgcuccag\n", + "gcaugauauagugcuaugguuccugacaaacaggacaaagacgugacaacagccupuggcagagaaguaacaa\n", + "ccagccaaggucucuggccugaapcgcuccucgccucccgcugcucuuccuggcccccgucguggacuu\n", + "auuggcacagcaacgapacagugaggacggaagcccaaguggcacaaaugcagaaacucccucuggugaugauuucag\n", + "ccucuccuuggcagauacuaaucuaccauccgaaguggagccagagcugcgcaguuucauugcuaagcgucuuucaagaggugcagucuuugaapcupuaauguugcaucuguggagcuaaa\n", + "cgcccccggcccgccgcccggccuugcaccccacccccggcccagcggcccggccgcuccuaaaagccaucuucuccucucccagccaag\n", + "gauaccgacggcugcacpagcapagcgguuuggcggagacacapccgcucagaggccgccgca\n", + "guccguuucagaguuuuucgcuuucgcuggcugugcuugcggagcacuuupuuucauuuguaaaggagccggagccccag\n", + "aguuuaacccuaauggcuacacaggagagaagcggcaugaauagacpuuucccapugcggacggugcuuucccagaaacucccpcugugag\n", + "uucccagugaccugacagcagaggagcgucaagaacuggagaacauccgacggagaaaacaggagcugcuggcugacauucag\n", + "aggcugaaggaugagauagcagaaguagcuaaugaaauugaaaaccupauccacagaggaaag\n", + "gaggcgagcpcgcpuggcgcggcpacgcgagcggcgagccggagcgcggagcccggcucccgcacc\n", + "gcgagcpcgcpuggcgcggcpacgcgagcggcgagccggagcgcggagcccggcucccgcacc\n", + "cpcgcpuggcgcggcpacgcgagcggcgagccggagcgcggagcccggcucccgcacc\n", + "apccpcggugccgaggccpccggagcpcgaapccgagcggcpccpccpccpcapccpcgupccggcaggaag\n", + "cuugcuuccacuucaggccugccugaggcacuuccacuggucuccaguuacuugcaaggucaaguacaaccugcaag\n", + "cuuccuugcuuccacuucaggccugccugaggcacuuccacuggucuccaguuacuugcaaggucaaguacaaccugcaag\n", + "agucpagcgcgcgaggcgcpagccupaccaggagcgagagccgccuaccugcagccgccgcccacggcacggcagccacc\n", + "cpagcgcgcgaggcgcpagccupaccaggagcgagagccgccuaccugcagccgccgcccacggcacggcagccacc\n", + "ggaaguugugcucuuggugaaupuucuuccuuuuuuauuuaccgguggcugugcuuccaauuuaggaagaccccggcgaccuguuccucacccccgcuucgcccucacacuuucp\n", + "gccggcagugaagagguuagcucccagcccaggcapcauaaauuupcacagcucccacucucaggaccugcccgucaca\n", + "cggcgccgccggcccggagcugcccggaagucucgguuccgccgccggcgcucgccapaagcccpccgcccpaccucggcccguuccuccggacccgagaggccgccgcacp\n", + "gauggacccuccaguccaucugcgucucuccauuuguggcugccguuucuguccagugccccugaggcccucggcugcupuccguaggaagccgcgcc\n", + "ccuccugucucacuucaccucccccaggauggacccuccaguccaucugcgucucuccauuuguggcugccguuucuguccagugccccugaggcccucggcugcupuccguaggaagccgcgcc\n", + "aguuuagucugugaggaaacuggcggcugcugguaguuccaugcugucuguucagacuucagcuuggu\n", + "guuuuggagcccucucuuaagucagaacucugucccaaaaaucuucugagugucaucucaggacuuugguuauacucauggcacg\n", + "agguaaccugcpcggaucugaacppcgapuggcagcuggaguugauggccuagaucgcucpcccuaagcgcpuggacacag\n", + "uuuugcagaacacugaaaucuauggacucuaaaauggacuucauuuaaagaaacccacggaccauuaauggacaaaaacaugagucaau\n", + "guggapugacgccaupupcggagcgucupaugcgcupagccuaggauccccgacag\n", + "aaaguuuaguuuagucugugaggaaacuggcggcugcugguaguuccaugcugucuguucagacuucagcuuggu\n", + "cuggaggauugugupuggaaucccccuccccuuuauuuuuccaauucugcaaggcuuuuaaaauucaccuuacaucuuuucaaagcaagaaaauggaacagcauguguaggaauucuucguuguu\n", + "aacacugaaaucuauggacucuaaaauggacuucauuuaaagaaacccacggaccauuaauggacaaaaacaugagucaauauguauuguggcauucaaauccuagcacucupagag\n", + "accugguuguggapugacgccaupupcggagcgucupaugcgcupagccuaggauccccgacag\n", + "acpaggcgguaccugguuguggapugacgccaupupcggagcgucupaugcgcupagccuaggauccccgacag\n", + "uuuugcagaacacugaaaucuauggacucuaaaauggacuucauuuaaagaaacccacggaccauuaauggacaaaaacaugagucaauauguauuguggcauucaaauccuagcacucupagag\n", + "gcuccggagagagaccuguccgagcagaggccuggacuacaucucccggcgugccuggcagugugguggccucugugcgccgucugcacucguugcaggcgacg\n", + "ugguccacuccuuggcuuuguuugcugugaacuggauuccaaggacagccuucucagaagagcuagag\n", + "acucguugcaggcgacgaugcagapcuguaagugugguggcccgucupcuuucgccugcaggcauuccccccggccuugugucguccacuuaguugcgcacag\n", + "aggcgacgaugcagapcuguaagugugguggcccgucupcuuucgccugcaggcauuccccccggccuugugucguccacuuaguugcgcacag\n", + "uucuugaggcucggcugaggaugccpaapcugguggucpccuagagcggcgguugcacuuaguugcggcugcugucacc\n", + "cuugaggcucggcugaggaugccpaapcugguggucpccuagagcggcgguugcacuuaguugcggcugcugucacc\n", + "ggaugccpaapcugguggucpccuagagcggcgguugcacuuaguugcggcugcugucacc\n", + "ggagucpuguapuupugcgauuacgcugcuagcaguuacagugcagaagaacguggcggcupauupcguggucag\n", + "acacaccgacgcucacguagucgcgcuugccacaacccugcpcucuccgaugcggcgagcgagcupapcuucuccgcggcccaaaag\n", + "cuugaaugaupuaguguuugagaaagccucuuucugugccucccauggagaucagugauggcauuucug\n", + "gauugacaucuaaagacucuugguacaugaggaagaaacccggaaaaggaaagcagaggagucap\n", + "ggucuauugacauucapauguggccauagaauucucucaggaggaguggaaaugccuggacccugcucagaggacucuauacapacgug\n", + "cuugcuacacggacaucccaaagauuauuuacgccuccaggacccacucgcaacucacacaggucaucaacgagcuucggaacaccuccuaccg\n", + "gccuaaggugugugugcupcucccpagcagcugugcauccauccugaggugaagaaacaagagaguaaccaucuacag\n", + "aaaaaagccuggagcaggagcuggccagccccauccuggacauugaggacuuggucaagagcggaagcaagcacag\n", + "cucugagcuggcugacagcupacpuggcggcccucgacuggagucgguugaguuccugapaccccgguucuggaagguucgccgcggagacaa\n", + "guucuguggccgguuauucccaapaggacucaggcgaupapcgcggcugguguaggaggucggauggaguauggcaapaagugacggacuuugauuaccuuugaacagguggcc\n", + "agagcugcgcgccgcggcggcggaagauggcugcggccgagguggcggacacucagcugaugcuuggagucpcugaucg\n", + "auggagucuugcucugucacccagguuggagugcaguggugugaucucggcucacugcaaccucugccucccaggaucaagcgauucuugugccucagccucccaaguagcupacuacag\n", + "gugacucauuuuucuauuguccugaccgccaaagauuuuaacccagagaaguaugcugccuucacuaggauauuguguag\n", + "pcggcggcgugapcuccpucgcuggcggcguggacaccugagucccpuapucucccgcgag\n", + "gagugagcuguugccgcagaaupcugcuggcuccugcccugcuuccugugaucgagccggcccugaggacucuguggag\n", + "gagagcgcgcggcpcgucccggaacagucugcgccagacpcggcggcgugapcuccpucgcuggcggcguggacaccugagucccpuapucucccgcgag\n", + "pucacgugacugcgucuccccgcccucucaccccgcugccucuagguucupaagauggcgaaggucucagagcuuuacgaugucacuupaag\n", + "ugcccagaucaggccuggcacauaggcauuuaggaaauauuaguugagugaugaagaacuccaauauuuacuccaagaaguaaauauuaguggaaua\n", + "ppupcgcucuuucuuuuucucuuagaagapuuuagcacagguuuuuucguucucacuuccacaccaccuuaccgccucccgacccccccucucccccuccccaccuaucguc\n", + "gupcgcucuuucuuuuucucuuagaagapuuuagcacagguuuuuucguucucacuuccacaccaccuuaccgccucccgacccccccucucccccuccccaccuaucguc\n", + "auaucuggugcuccugaupccggccagucupcccagcucccccgagagguggucggauccucupcugcucggucgaugccugugccacugacguccaggc\n", + "cupcccagcucccccgagagguggucggauccucupcugcucggucgaugccugugccacugacguccaggc\n", + "ccgcccgcccgccuccgcccgcggcaagccagcccgccggcgccccggagcgcugccgccaccgucaccgccaccgcccgguccaggcccaagcccaggcccugcgcggagcggagcggcg\n", + "ggccguuccacugcgcggcggcgupapcgcggcgcgagcugagaugguuccgcccggcgccgcccccgcugcccgccgcccgccgcccgccgcgccgagcgcucccgcagg\n", + "apcaacgcgapaagaagguggcggcucccacucgcuucucccucpucpuccgagcugccaggccgc\n", + "gcgcgcguccgcgapcgcccgacgcpcugapcgcuggcgugugcccgcaggcggcccugcgcpacggcgcgcuccuggacaccgccggcuucaag\n", + "uggugcupcagaggccugcguggagcucccaggcaccugccuaagagccagccggcacccagccacugccagagagaggcagcucggaccucggcccc\n", + "ccugcguggagcucccaggcaccugccuaagagccagccggcacccagccacugccagagagaggcagcucggaccucggcccc\n", + "cagaggccugcguggagcucccaggcaccugccuaagagccagccggcacccagccacugccagagagaggcagcucggaccucggcccc\n", + "auuagauppcugcggcuuggagaacacucacaguucugaguucagcuguggacggaauaaugaapcagcugcagaaggagguagagcugcagauucagag\n", + "ccccuggaccugagaggcuucaauaauuguuaccugaguuggauugaauugaaauaaagaaguaaagauccuauaucaucuacugaaaucuuuaaagg\n", + "gcggcguucuuucuuggaacaaaacuagcgcggagccacggaacuccgcaguuugcguagacuugaauuuccuauuccucggacgauccauguggaaucc\n", + "acuagcgcucccccugcacccucuggccgcccpcgcpaccuggcccccgccuccuccacagucuccgacuugcgagccgcacggcccag\n", + "ggcaaauccagacagaaccuuugacuugguguugaaagugaaaugucaugccucugaaaaugaag\n", + "guuuccuguugccugucucuaaaccccuccacauucccgcgguccuucagacugcccggagagcgcgcucugccugccgccugccugccugccacugag\n", + "aucccugccagaaccaccacugcaaacacggcaaggugugcgagcuggaugagaacaacaccccc\n", + "gagugguuuccuguugccugucucuaaaccccuccacauucccgcgguccuucagacugcccggagagcgcgcucugccugccgccugccugccugccacugag\n", + "guaucugupagcuaauccuguccagguggaaguaggagaauuugaugauggugcagaggaaaccgaagaggaggugguggcggaaa\n", + "cuccguccccacccgcccgccgucccgccggcccgagccguggcgcccagagcugcgagccgcucgccccuccgccgcuccggcccpccgcc\n", + "cggacucagcgcguccuccgccagcccucgcgucugcugcccccgccauccaguuggugcgguccauggcgagcgcaucauggcgauugaag\n", + "cccucucgcuggcggacucagcgcguccuccgccagcccucgcgucugcugcccccgccauccaguuggugcgguccauggcgagcgcaucauggcgauugaag\n", + "ggaaccggaaguggagccupagccuugacguuaggaacgaagucuaaccuggaucuggagccgg\n", + "gagauaaucugaaugcuggcupcagaaaauuacuaagauccuguggaagugugaggauuauuaaacugaucacugucugauaag\n", + "gaccagcagagacuaggauggaugacggccuguccapcugaauggacacaggugucagcapccaccugguaaag\n", + "guuucaucaguuucacccuuuucugugugcggcugauuuuagaaagauugcuuccuuguaugguagcgauaaguuugauuugcccuaup\n", + "gccauguuccacacagucuggaguguaugucagugugagcugaagaccagcagagacuaggauggaugacggccuguccapcugaauggacacaggugucagcapccaccugguaaag\n", + "agugugagcugaagaccagcagagacuaggauggaugacggccuguccapcugaauggacacaggugucagcapccaccugguaaagguauggag\n", + "uuuccucgucccucccuucgcggugauuuuccggucccggcgcccggcgapcgcgcggcugguguccgccccgcccgaaag\n", + "cugaagaccagcagagacuaggauggaugacggccuguccapcugaauggacacaggugucagcapccaccugguaaagguauggag\n", + "ccacacagucuggaguguaugucagugugagcugaagaccagcagagacuaggauggaugacggccuguccapcugaauggacacaggugucagcapccaccugguaaag\n", + "cgagguaggagugccgcugupcagupcggcggcagcggacgagcggccaggcugaccaccucugccugacucag\n", + "agaacccauccgcgguccacccupccgcucccuggccucgcugcccugucagucgccugugagcuccugcuccuuccupccugcagcccuggagaauuugcucaccgag\n", + "pccgcucccuggccucgcugcccugucagucgccugugagcuccugcuccuuccupccugcagcccuggagaauuugcucaccgag\n", + "gacucaccugcccggagcgccaccuggccagacgccucaagaacaauagcuucuacccauucgugcagcaggagccaaacg\n", + "uupcpcagaaucagccuuuaaguugcagugacucuccggcgucacuguugcgcuucauagacgccgcguguacccgguuguccucaggcgcugucag\n", + "agauagaaucugcagugccugaaauccagccugcugcuuacucacauccucauacucagcugcagacugccugacagaapcugccaaacugcacuccagacagacaggugcacagccag\n", + "gcaaaugcguuuccggupupcpcuucgcgucuccuucuacggauaucuguggaccuu\n", + "agccuagcccgcaggccccucgcagccucugcgagcugcucpagacaguuuugccgagccuccguuuuuucacaugugcagugacag\n", + "pucpccupuccgacgguagupuagcpucucpuugcpuugcagguugcaagccgcaggccccaggcaacugccuucccggcgcc\n", + "gccagugucugccucucugcccccacpuuuauuugaucucacauuaaccaaggaggagaaugugagaaaapaaa\n", + "ggaggucacaaucacauugagccaaaacgcauccaguguuuucuccaguuacaaauaaaacgaau\n", + "gugaaaaaaaagugaagguguaaaagcagcacaagugcaauaagagauauuuccucaaauuugccucaag\n", + "cugcuggcupcgcuggccuuuugaucacaaugacuuuggcguauuucuuugcaagcuguuccccuuuuugcagaaguccucggupaucaccguccucaaccucugcgcucuuaguguugacag\n", + "guacagagcaguugccuccuggagucguguucapaauupauuccuuugguaacugccauugaaauugucuccaucuggauccuguccuuuauccuggccauuccugaagcgauuggcuucguc\n", + "cguuuuccupaagcggcpcpuggagcagccagcupuccpagcgccgccgccgccucgaup\n", + "guaaccucuaaugugaaguuagcgcacacaguucucaagcauguuuggaacuacacuguauccacaaaaaaauacau\n", + "guugcuacuucugugaaaugaggcacuuagacuagaugagcaaucuugacuuuugaapuggcaacuaccuuguagaauccagugaaaacucagaaccuuccucccugaaaaau\n", + "cgcguuuuccupaagcggcpcpuggagcagccagcupuccpagcgccgccgccgccucgaup\n", + "gaucucgcucugucccuuaggcuggagugcaguggugcaaucuuagcucaccgcagccuugaccuccupcucaagcaguccucccaccuuagccucccuggagcuggcacuacag\n", + "guguugaaaagucuccucuagagcuuuggaaggcugaaugcacuaaacaugaagagcuugaaagcgaaguucaggaagagugac\n", + "gagaugcacccuggagucugcgccpucccaccuguuucgccccgcgcggcgccucgcugcccccgcgucggugcugcugagcccaauccgccucccggcugaacuuggaggag\n", + "agaugagcaaucuugacuuuugaapuggcaacuaccuuguagaauccagugaaaacucagaaccuuccucccugaaaaau\n", + "cuacuucugugaaaugaggcacuuagacuagaugagcaaucuugacuuuugaapuggcaacuaccuuguagaauccagugaaaacucagaaccuuccucccugaaaaau\n", + "gugcgagcucagaucagcgupuggaggagaaguggaguuuggaaguucapcacapcacaggcccacgacugcagcp\n", + "gcccauugugacgccugccagccgcaggcupuccccgaggcpcggcauuuaggcucggucuccacagcc\n", + "capuccaguacgccuggcugcugcupcuggcgcagapacccacucuuccccccgccugccccaacuccagacaucaugugcuccccguuucpauccagaagcuuccagccagagg\n", + "caacaccuucuuuggauugaguuucuuccagapaacgaagaagaggauuaaauaauacauucaauucuaaaauaagac\n", + "caacaccuucuuuggauugaguuucuuccagapaacgaagaagaggauuaaauaauacauucaauucuaaaauaagacauggcccau\n", + "auaaucuccgcccuccccuucagaaccgcgccccacagcucggcgcaggucccgccccuuuccaucuacpcggcaggaggcccgaagcaag\n", + "ggaguccacagcugcugaaucugaapccaucagaagacuggcuucuccaugaugguuuauggacuaaggcaaag\n", + "gaccucaagugauccucccaccucagccuccccgagugcupauuaaagacgugagccacggcaccuggccugaauuuuccucaaauucaaaaaauccug\n", + "capccgacggcggupcggugcguugcgcaggcucpccucccgcucgccgcugcguupaccgcgcagcccg\n", + "cccaaacagagcguuuucugguccccgagcuccucccgaccccacccgcuccuacggccuccaaccggccccccccag\n", + "pcgcccpccucgugugacagcpcpucggcgccccgapcugcpagccgccpuccpcgcapcgugcpccuggccpu\n", + "cgcagcggcugacpccggaucgccuucgccgccgcccgcccgcaaaccuucgugcccggcccguccucgcccccgccuccgccaccgccucggcccgcagagcuugcccccuccccacccgcagac\n", + "guguguuccuuauucccuacguccugaucgcccugguuggaggaauccccauuuucuucuuagagaucucgcupccaguuc\n", + "ugauacaauuucuucuupauuuucacaaauggcaucauugugguggugaauggcauugacuugaucaagcacagaaaa\n", + "gcggcguccgagcgccagcggacugcgcaugugcaggacccagcaggucuagagcuuuucuguguuucuccggacuucgagcc\n", + "puuuccgcuccgcggcguccgagcgccagcggacugcgcaugugcaggacccagcaggucuagagcuuuucuguguuucuccggacuucgagcc\n", + "ggcguccgagcgccagcggacugcgcaugugcaggacccagcaggucuagagcuuuucuguguuucuccggacuucgagcc\n", + "uuuccaacauggcuagauccaucagaaacugaagccguggagaacgcucucpccuuugccacuucuuggaguagaagccgacagagagcuguuuggaaacuucuccuucacacaccag\n", + "ggauauuugcauuucaacaaaguaccaaaccucaagagaaapcugcuccaaggauggaagauauauuugguapagaggacuuuuuaucacccuugauucacuccauguaagcapaccuucug\n", + "aguaccuuggauuucugagupcaaggcuggacccugagcccupaccucugaagugaacacugcapccauuug\n", + "cugcaggccuccguguccccuggcugccggcuaggcaguccugcucucucpucuguguucucagcuucgagguccaggcugagugagag\n", + "gagcucpcggcuccaggcacuucuucccuugagupuggacuacugagguccccupcacggcguc\n", + "ggcagacaugcaaacccucaggcaagaggcugcacggcccuguauccccucpacccucgaggccagcuucccagcaccgcuguacaggugagccccucccuacag\n", + "cgaugacuaccugucccuggapuucccgcuggccaccagccaucaggcaggccacacgcuggaaguacacgccc\n", + "augaaucaugugacgguggcuugaggaggaaccugucuuuaaagcugucccugaagugacagcggagagaaccaggcagcccagaaaccccag\n", + "acugccugcagaaccccagcccgacuuucccugcgcacupauccugcuggaaccucagcugcaac\n", + "accuggaggagagacpcpuggccaggaccugagcuggagccupagcccgaaggccagacag\n", + "ucucgcgauagccagccgcggcugcccuugcgcuucccgagcuggcpuccguggugcpaucgagauugcpcu\n", + "aggaggagaaagcugaccgcuuaggccpuaguggucgucgugguuuuccuuguaguucguggucugagaccaggccucaaguggaaacggcgucacc\n", + "cgugaguccggcgcgcagaggaggaggagaaagcugaccgcuuaggccpuaguggucgucgugguuuuccuuguaguucguggucugagaccaggccucaaguggaaacggcgucacc\n", + "gcggagcgapaaacggacucggcggcgccggcaugaggagcugagcgucucpcgaggcpcugacggcagcacc\n", + "gccpcupuggagguggccgcpaccccpcgcggagcgapaaacggacucggcggcgccggcaugaggagcugagcgucucpcgaggcpcugacggcagcacc\n", + "acaaugcaccgcacaauggcccgaccgccgccacuaccpccugapccuggcggagcccgagcgcggcccggcccgcagcgupccccgagcgcg\n", + "gugaagagauuguuuucugaaagcugcguuggaggcugugacagagcugagagccuguguggagcggaupaggcuuucucaauaacauggcccuuugccauuagccuugcc\n", + "ccccgcuccuccgccuccgccuccgccuccgccucccccagcucuccgccucccuucccccuccccgcccgacagcggccgcucpccccggcucucgguuauaag\n", + "auauauacccpcgcugcgcuccaccuggccgccgccuccagcccagcaccugcggapagcgcug\n", + "guuucuauuapcccguggccaucagcgaapuccguccuucagccgucuupagcaaagcccgcaauuuauguuuuccaagccacaaaugg\n", + "aguuuguuucuauuapcccguggccaucagcgaapuccguccuucagccgucuupagcaaagcccgcaauuuauguuuuccaagccacaaaugg\n", + "gucccuaaaucgccpuugauguuggcuuuggaagaacuauuugcagagcguuuucugcacuggaaggapcuggaagcuuucuggaagcauugccgcac\n", + "gcaucuagaucaaguggcggcagcacaggcagcuggaagguacccacagaaagaaaucgagcacu\n", + "gcugaguggcagcuuccauccggupuuuugcucggcgcacccpaggcpccagcgaggcaag\n", + "auauaucaagaccuacagcccuupaagugcauuucugcauucgaagaagaaucugagagaaaccu\n", + "ggaggagguggcggupcggaacuccuagcggacaccucguggaguccggccggaagagcaaccgag\n", + "gauugucaacuuauuuuauuuuauuuucuucaagcaacaauugcuaaggaacagaauugucaauuuauuaaugaaau\n", + "agucccggacgcaaccccggagccgucucaggucccuppaacggupuuagacpacpaapacagcggccuucgaccgccccccgag\n", + "gugcggcucucgaggcagcuccagucccggacgcaaccccggagccgucucaggucccuppaacggupuuagacpacpaapacagcggccuucgaccgccccccgag\n", + "accaggaagcgcccgccccggccggagccgccauguaaccggcgccgcccggagcccgagccgcgcpccccagcgacccgcccgcc\n", + "gccccggccggagccgccauguaaccggcgccgcccggagcccgagccgcgcpccccagcgacccgcccgcc\n", + "pagaccucaucuuccaaccaagcuugcupcuagcuuuaaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccuaug\n", + "ugcuguaucuguguccugcugccucucagcccauuuccpaccuugcaggaugaggagauaacuuugagcugcucagaggccagcgcugaggaagcucugcucccugcacuucccaaaacag\n", + "acucacucaccacaapaguaaaccucacugacaucaaacucaacaguucccaggaguuugcucagcucucuccuagacupaggcuuccuggaggaggcguggcagcccag\n", + "agcuuuaaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccu\n", + "ccapagaccucaucuuccaaccaagcuugcupcuagcuuuaaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccu\n", + "aaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccuaug\n", + "aaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccu\n", + "ccapagaccucaucuuccaaccaagcuugcupcuagcuuuaaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccuaug\n", + "agccugaugcuggaugaccaacccccuauggaggcccaguaugcagaggapcccaggaccupaucuucagagcagagccuggagaccagcagcaucccaguaggccagacupccauapa\n", + "cuuuaaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccuaug\n", + "agcuuuaaucaaugcuggccugagaacaggagcggaacauugccuaguagacccugaggcuuuacaacagugccacugaccccuaug\n", + "acucgcgucuggcuaccagcuccccgcugcccugagcucggcpcuggcauucggcccpaaaagcggagcag\n", + "gucugcgaggcuaagugucuccgcggcgcaccucgcggcgagaauccggaggagaaggagacugcaaggauaggcccag\n", + "apagaccaagacaucauuguuuugaaguuucugaaaguguupcggcaaaaauucaggugccupagaa\n", + "cugaccugaaccuaagauuuaauaagguggugcagcupaagacacuauccgaacguggagcccaaapagg\n", + "ccauaaccagcagaccacagcauucaggcauccugugacpacaguuuucuccagaaaauagugaauucauucuucaagaaga\n", + "gcucggcgaacauggcggcggcgacggucpcpacacuuuaccugagcauugguccuacpugugccp\n", + "acugugaaaagcacuucuuacgccugagccaugaaauagacuggaggaaugugaccuuuagucagcugupucugaaaag\n", + "pcupcucgccapccpaccccuuccgauauccgcgguggagccgcccuucccaccccgcgucgcucggcguuagccaaggcccpcggcgccacccuccpcacuag\n", + "gacgaagaugaauggaaagaauuggagcaaaaagagguugauuacagcggccucapuucaggca\n", + "gaauuuucgcuuucagcagccgcauuuguagcagcucuuuugugaugacuuagucucuaagcccgugaaagaaaaagaaaacucucgguggcaagguugaaguagaaau\n", + "ccgagcucggagccccgcpccgcgcccgccgccggccccacccauccpucgaggaggccgaggcc\n", + "aguuugagcugaauuuucgcuuucagcagccgcauuuguagcagcucuuuugugaugacuuagucucuaagcccgugaaagaaaaagaaaacucucgguggcaag\n", + "aguuugagcugaauuuucgcuuucagcagccgcauuuguagcagcucuuuugugaugacuuagucucuaagcccgugaaagaaaaagaaaacucucgguggcaagguugaaguagaaau\n", + "acuuggcagcgagugcgcpaaguucagcgcgcgaguuccpcuucccgcccgcccgcagacgaccgccg\n", + "agagcpaggcgagcgcaggccugccgcggugacagcpcuaggacccuuggcgcgccggugcccugcgcugaccuccgcgcgucgcaggcuggcggcagccugcggccapaaccccuag\n", + "agugugugcggaacgcaagcagccgagagcggagaggcgccgcuguaguuaacuccucccugcccgccgcgccgacccuccccaggaacccccapagccagc\n", + "gcgcgucgcaggcuggcggcagccugcggccapaaccccuaggugccuuccagcccaaguggcaaaaaaa\n", + "ggcugcugaaaccgaaaccgcugugcugupcgcagcgccgagauugauucaccuucaccugugcugcacuccagcugacccaaguaggaagccagacgagcuguaaaac\n", + "aagaaaaugaaacagaauugaaaauggucuuguaaaauuccacuupuggcgaugcuuuguggcuugaaguguaapaugagaacagcaugugaauuccaagaaagcaacacaga\n", + "ggcgcppcagacggcggupacggccaggccccggccccgccaguguguccgcccggccccgcgucccggagcgcccgcacccggccccgccgccgccucag\n", + "agcaagaaagcuuucugcucagccauggcuacgaguccacgccuuaaugcaccccacagccagcggcaguggcagugacaacagcpaccugccuuugaagaucggcugcugcaapuug\n", + "gcgucupcccggccccggcgcppcagacggcggupacggccaggccccggccccgccaguguguccgcccggccccgcgucccggagcgcccgcacccggccccgccgccgccucag\n", + "agacggcggupacggccaggccccggccccgccaguguguccgcccggccccgcgucccggagcgcccgcacccggccccgccgccgccucag\n", + "aucucugcugauaagaaaagccupagguucugupcaacupuucuccacupcaaccccccpaaagaaggaauuu\n", + "acagaaaacccuccccucccugcugugcaugacgcpcucccucugcacacagugcacgaagacgcugucpagagcccaggauucaacacpccuugagaa\n", + "gacacugcccuggagagugacccgaugcagcagcugcacaggccauccuccccacccacgcaccccugcugagaac\n", + "acagaaaacccuccccucccugcugugcaugacgcpcucccucugcacacagugcacgaagacgcugucpagagcccaggauucaacacpccuugagaaau\n", + "gcugugcaugacgcpcucccucugcacacagugcacgaagacgcugucpagagcccaggauucaacacpccuugagaa\n", + "acacugcccuggagagugacccgaugcagcagcugcacaggccauccuccccacccacgcaccccugcugagaacaugucugugagguucagg\n", + "gaagapcuacapaupccaagupaauucuagcgaggcgccuacuauuugauggaggapaupcuag\n", + "auggcuuguuupcagugccaggupagupcaggcccggccccuuuugcaagucaccuccccaguucuccaacgcuuacaaggugugcuccgacaacuc\n", + "cccucuggcaggcucccgccagcgucgcugcggcuccggcccpagcgagcgcccggagcucggaaag\n", + "aagagaauupcucupaaaauugcagguucpagaaggacacpugcaugupcagapacuuagagaccggcugcgagaccacaggagaagccacuugcuccgaggcgccupag\n", + "agcuupccuggagcgaaacucggupugapugaaaugucaugaagcucpagaauaupuupaggc\n", + "auugcagguucpagaaggacacpugcaugupcagapacuuagagaccggcugcgagaccacaggagaagccacuugcuccgaggcgccupag\n", + "auaugugacgcaaauuagcuuacgagccpuggaggugucgucagcacccgccugcgguuggccgcguugcagcgagapcauguagaccccgccucguapag\n", + "augcgcucuccagcgcgcucuccaggagcuuuggcucggupuacugucgcggaggcuugucauucugacccpauuccucacagcgucuggcag\n", + "agacccaucuagacagaggaagaagcugcaacauuucagaaagcaaccaauuacugaggaccgaaugaccuggccuuaucagcgcugaaguguuaacggccgucccuguuup\n", + "gaggacpuguccapacggagaggcaggugagapagguggcuaagcuggcuauggugacaggacg\n", + "aagaagcugcaacauuucagaaagcaaccaauuacugaggaccgaaugaccuggccuuaucagcgcugaaguguuaacggccgucccuguuup\n", + "guguuugucccucggccgccguggapuggaacuggcacucccaccccugacaupcucacuucgcauuagcccugugcuucacuacccaacgc\n", + "aaucuggaagaaggacacagcucaacaguggcugcccauuacaaugaacuucaggaaguugguuuggagaagcguagucaaagucguauuuuuuaccuaagaaacuuuaauaauugg\n", + "aagugacguaagcagacacgcguggcgcpccgccguuuccgcaaacagaaucgcguuuggcugugcug\n", + "auaagaggcgucauuggcgcccgagcugugaccgccgccacupcagccagcacaaucpcggagguggcgcugccccuucag\n", + "acccacccgccgcacguacuaaggaaggcgcacagcccgccgcgcucgccucuccgccccgcguccagcucgcccagcucgcccagcguccgccgcgccucggccaag\n", + "auuccggcagaguuccucuaucucgucuuguugcugauuaaaggugccccugucuccaguuuuucuccaucuccupacguagcaggaaaucagcauc\n", + "gcugcgcgcgccuupauugacuguccacgcucgcccggcucguccgacgcgcccuccgccagccgacagacacagccgcacgcacugccguguucucccugcggcucg\n", + "acugcgaagcccagcugcgcgcgccuupauugacuguccacgcucgcccggcucguccgacgcgcccuccgccagccgacagacacagccgcacgcacugccguguucucccugcggcucg\n", + "agagacaacagugaaugacaaggapccauccaaucccugcugccaccuccupauggagcccuapagccccugugcugccccugccguggcaggacucacag\n", + "ccccaccgcugcacugaagcccapcuguggagcagccucucuccuuggaccuccucucggcccuaaapacupcagagccuuccaggacu\n", + "acpuguacacagcagcggcgucgcggcccgcagccccgcggcggcggaaagguaaccgacccgcccupugcugcgugcgcugccugcucccgccugaggaaaacacugccc\n", + "auacpuguacacagcagcggcgucgcggcccgcagccccgcggcggcggaaagguaaccgacccgcccupugcugcgugcgcugccugcucccgccugaggaaaacacugccc\n", + "ucgcggcccgcagccccgcggcggcggaaagguaaccgacccgcccupugcugcgugcgcugccugcucccgccugaggaaaacacugccc\n", + "gcuguggagaccupccuucugcgaucacccuaggaguugauccagauaugugccucacgcccugaucacuccccccaaauuaguauccgcagagauucgaggac\n", + "gacgugcacgcaguagccaggccugacccgcuggucccuugcuggcpaggaaagaggcggcacc\n", + "guuaccauagcgacgugcacgcaguagccaggccugacccgcuggucccuugcuggcpaggaaagaggcggcacc\n", + "guacaugugaagauuuuuuggcagcuuagcguggaaaccauugaucacccugcucucauuucuaccuguucuguguuggcaapagagugcccaa\n", + "agcgcgcagcgugcuuggaaccggagcauccagagaggaugaggcpacccggcccaaguupugcaucucucpcguccggcagcggcuguaucucggcaugaauuaagaagcuaggaag\n", + "gagcgccgcggcugcaggcccccgccgcapauggaccgccgaggcggcggccpcggcggaggcggaggcggccggcccgg\n", + "uggucuggagccgaaccggcaauaucucugaggugugacuguucucucagcuucaucaaauauaaaguggaaagaguuuuguucaugaagccacugaaugaaccauugcuugccuuaaaggaag\n", + "ggcucgcauccccauagugcupuuacagugaagguacgccccgcgcucugcucuggagaggcapupauapaacgucucgaguggcgcccgcaguc\n", + "cuccgcgcccgcucggccuccgccgcccaaacuuuucuccpcgcgcguccccggcggccgcccccggcaupcaccgcgccgcapccugacccgccgcccgcuccgcccccgccugcc\n", + "pcugcpcccggcggccpcuggcupccgcgcuupuucccgcgccggcucccgcacccgca\n", + "aauuagcagcagccucugucaccauccaaagauuacaacccaugaaaccauugaauuugugccuuguaucagaaagcaaaggagaaugaaaaagcacagcuaacauugcuugaggaucuag\n", + "guaauaagaggaaggcaauuugucaccaguuucugcuacagcacaaaucuaccuuuaaaguaaaucuuaaccuuaag\n", + "uuugugccuuguaucagaaagcaaaggagaaugaaaaagcacagcuaacauugcuugaggaucuag\n", + "gaaagaaaagugaaacacaaaaggaaaaauaaaugaaaaaugaacaccaaauucuuuugguuugcaaacaaggugcaucuaucuccagaaucaaaucucuuguauccaccaccauucu\n", + "aguaggcagcagcggcggcggcggaggaggaggcggugguggaggugcgcggccugaagaggagg\n", + "gguugccauuapacuccugagguccuaucuccaggcugcggugacugcacuuucccuggaguggaagcugcuggaaggcggaccggccgcc\n", + "guugccauuapacuccugagguccuaucuccaggcugcggugacugcacuuucccuggaguggaagcugcuggaaggcggaccggccgcc\n", + "acgucggcgcaggcgcgucgcggcggcapcgcpcuucuggaggcggcggcgguggccagcgcggcggcgccggccguauucuccpcugcggagg\n", + "uuugaggccauauaaagucaccugaggcccucuccaccacagcccaccagugaccacgaaggcugugcugcuugcccuguug\n", + "cuccauuggauaugacugugcacuggagccgguugugcuguucucucagcuguacacacccaucaaaucacagugccccugaggacgagagaaaauugaag\n", + "guucccccggagagaaggcuggugcagcuugagcucugupcaagucugacupccuuucucacuuuugccuguguuugccuugcagcuguguaa\n", + "guuggauggagugcaguggcgcaaucucggcucacggcaaccuccgccucccpuucaagcaauucuccugccucagccuccggaguagcupauuacag\n", + "cuguguaaaugaguauggaagauuaugauuuccuguucaaaauuguuuuaauuggcaacgcuggugupaagacgugccucguccgaagauucacucag\n", + "agugccccugaggacgagagaaaauugaagguaggcaauagccuggcugapcucuugcucagcaaucuuugug\n", + "guugccucuuggugcugccuuggccguauuuggcacccagaaugcuucauucugugacggucuauuaauaagguugccuugcuagaguuuggagcapccucag\n", + "auuggccaaaaupaaggauuggauuccacucucuuccacgaagagucaaupacuggcuaagaucaaagucugaggcuuuuuccaucaguaaucag\n", + "ucccuuuuugcuuucuuuuacgaccacaugaaacuugagaagccaccuaaagcuauaucauuuaguggaguupcaguucccaaguguccaacaagaaggccugguuuaggcugcg\n", + "guugcagcuggcagugcggcpcgcpcgccggagcgapcccgcpcccggcuauuaauaacgcggccgccagcccpucgcgcagcc\n", + "pauccggugucgguugcagcuggcagugcggcpcgcpcgccggagcgapcccgcpcccggcuauuaauaacgcggccgccagcccpucgcgcagcc\n", + "agcuaaguggaaaaaggaauccgaaggaagaacgccugaagcccaggucupaapcccagcagcuucucucuupagaaagac\n", + "guaauuuuccugcgccucpcgagcagcggcgcgcaaggaaagaucpuuccguuuuucccgcggauucuggugccugupccggugacccaacacc\n", + "aauuuuccugcgccucpcgagcagcggcgcgcaaggaaagaucpuuccguuuuucccgcggauucuggugccugupccggugacccaacacc\n", + "gagcagcggcgcgcaaggaaagaucpuuccguuuuucccgcggauucuggugccugupccggugacccaacacc\n", + "gacguaauuuuccugcgccucpcgagcagcggcgcgcaaggaaagaucpuuccguuuuucccgcggauucuggugccugupccggugacccaacacc\n", + "acuuccggccgcggcggccucagcgccggcccgaapaccaggccgccguccccagcgagaggcaugcagcgcugaggagcggcgacccagcacggcggcgcc\n", + "cggcacuuccggccgcggcggccucagcgccggcccgaapaccaggccgccguccccagcgagaggcaugcagcgcugaggagcggcgacccagcacggcggcgcc\n", + "gucuauccccuuacauccuccuaggacccggucgguagucgucgccccagcccgccpcgcagcgcccgagccgcggcccucgagacpaccgagagcauc\n", + "uacauccuccuaggacccggucgguagucgucgccccagcccgccpcgcagcgcccgagccgcggcccucgagacpaccgagagcauc\n", + "auccuccuaggacccggucgguagucgucgccccagcccgccpcgcagcgcccgagccgcggcccucgagacpaccgagagcauc\n", + "aaauugaggcaaaagaagcaugugacuggcuccgugcugccpuucccgcaauacgcucaguuauaugagg\n", + "auucacaauuucccaucaacauuguggcugucaagaaugaucaugauuuucuugaaaaggaccuuguagaaccucuuugcag\n", + "aaaaaucgcupucuguugagcuguccupcupugccuugcucuuugacugagacuggagacagacggcaacagccacaggcagacugagguggcaauaggaaaucugccgag\n", + "guccugucccgcagcgucccgccagccagcuccuugcacccuucgcggccgaggcgcucccuggugcuccccgcgcagcc\n", + "ccugucccgcagcgucccgccagccagcuccuugcacccuucgcggccgaggcgcucccuggugcuccccgcgcagcc\n", + "gcugcacuccccgaaagugcggcagaggugucaccgaugucgucaucaccapaggaagcggagcggauucgcag\n", + "gcauccauucuggacuugcacucapcccugucugucpaagcacuuugugaaccuguacag\n", + "cacggaagcgcggacggcgcacgacgaguacuggcaugcgcacguggacaaggugagcgcgcccgupcapugagcgugcccguggacaag\n", + "gugaccuacggcuccuucgacuacaccucgcugcuguaccucuccaacuaccuggaggacuucggcggapcgguuc\n", + "cugcgccgugccugccucgcgcucccuguuacggcguucguccccpccuggcgcccgcguccggcccggcuccgcggcggccugguccg\n", + "acucgcgucccugcgccgugccugccucgcgcucccuguuacggcguucguccccpccuggcgcccgcguccggcccggcuccgcggcggccugguccg\n", + "acccucuuggugugcgcgucauggccgucagcaccgcguucccguccucuuccgcuuggccccagaaaguuucgguucugcccggcgguggacccacgagcgc\n", + "gugccaccauggagucugaccacugcugagcagacagccaccgapccgaaauucugagccuuccucuggacccaggcaggagacauacagacaagaaaggcaaacucacc\n", + "gucupaggugaggagcgucucugcccggccaccccaucugagaagugaggagacccucugccuggcaaccgccccgucugagaagugaggagccucuccgcccggcagccacaccgucupaa\n", + "cucugaagucagaaaccucaucucccacuacagaccugccapcccaggagagcucgacccacccaggcacaccauagccccagag\n", + "aggcuucuuccggcucggccgugcugcucagcpuguaaacagccucugcgguguaaacagccucugcgguguaaacagccgcggcpcaggccaggacugucagugcccgccccucpcag\n", + "paagapaaggaggccuggagucuggcgapacuupagaggauggugaacgagccacggcagagaggaugagagcguggaucccugg\n", + "pagaguuaguggaapacuuaagagaaapcguggucuuuuggaaapcgauucupucguaggagccpccggaaguauugauuagugcuggaagguggaagagcag\n", + "gcagapcgcagccuuuapaagapaaggaggccuggagucuggcgapacuupagaggauggugaacgagccacggcagagaggaugagagcguggaucccugg\n", + "gccgcccgccgcccgccgcccpccacugcapccgcuaacgguccggcgccccucggcguccgcgcgcccccagccuggcggacgagcccggcggcggag\n", + "caugaaggaagaaggcauggcuuagcuaaaaggagaaaugucccagaaaccuccauacugacagccaggaaguagucucagaggcuuuggauuccaggaaagaagcug\n", + "aaacccaugacgaagaagapcuguucupuggagcaggaacuuucuuggcucupuuuccuugucugucaaaugaccag\n", + "auggagucucacucuguugcccaggcuggaguacgguggcgcgaucucagcucaccacaaccucugccucccagguucaagugauucuccugccucggccuccugaguaacupacuacag\n", + "uagcccugcccggccccggaggacuugcaacacuccgaggccaggaacgcuccgucuggaacggcgcag\n", + "gcuggaguacgguggcgcgaucucagcucaccacaaccucugccucccagguucaagugauucuccugccucggccuccugaguaacupacuacag\n", + "cuagcccugcccggccccggaggacuugcaacacuccgaggccaggaacgcuccgucuggaacggcgcag\n", + "uuucuccacuguggcucccauaaacaagucccuacuccuuucccccacgupcugauuuapauaaaaggaggccapaggucauuugccuggauuccugcagcuaguucaugaacccag\n", + "gcccaggccauggcuaugaupaggagagagcagugagugauagcuucpccuggagagupaugaccggaaagugcgacacacuuuuauccgaaag\n", + "guuuacuccaucaucuccgugcagcugcucaucacuguggccaucauugcuaucuucaccuuugu\n", + "aapaaguuccaaacccaugacgaagaagapcuguucupuggagcaggaacuuucuuggcucupuuuccuugucugucaaaugaccag\n", + "gauugcuuuucuccucucccauuucaggucccagcagcupuucccccucagcccgugagcagcc\n", + "ccgccccacgaggccggcgcgacpcpcgcggagccccagccgagccuagcccugcccggccccggaggacuugcaacacuccgaggccaggaacgcuccgucuggaacggcgcag\n", + "ggagccggccuucuccccgucucuaguaguuuccgcaccgcugacgcaugccugcgcgcacagcupccpcgcguccuacgcagcagccgcgagccpcugcgg\n", + "cgaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "cauuuugugaagagacgaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "auuuugugaagagacgaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "gaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "gccuggagcagcagcagccaggaugaccuggagccappccuucggaacagaugcacacccuuccupugaug\n", + "acgaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "gaggacacguuacuaagaguggaauuaauccguauugugaguacgucugucuuuacuguugccuccaucuugaauuuaaguccucaua\n", + "ggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "gacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "uugugaagagacgaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "uuuugugaagagacgaagacugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "gcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "ugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "cugagcgguuguggccgcguugccgaccuccagcagcagucggcuucucuacgcagaacccpaguaggagacucagaaucgaaucucuucucccuccccuucuug\n", + "agaaguggcccuugcaggcaagagugcuggapcggcagcggcgaccggagcgguaggagcagcaauuuauccgugugcagccccaaacuggaaagaag\n", + "gcaggcaagagugcuggapcggcagcggcgaccggagcgguaggagcagcaauuuauccgugugcagccccaaacuggaaagaag\n", + "aacaguugccuuuuccucucacagaaggaagauuucauuuuguuugagacgagaaaccaaaccacacaccaaagagapu\n", + "gaacaguugccuuuuccucucacagaaggaagauuucauuuuguuugagacgagaaaccaaaccacacaccaaagagapu\n", + "gccgcguuuugccuccgcagcagcucupcucuucucagcugcgcgagcagcugcuccaaugccccggaguggcc\n", + "gcacacagccauccauccucccccuucccucucuccccuguccucucucuccpcucccaccgccgccgcpccpagccaccggccgccacc\n", + "gcupcguggccugacugcgcggccagacgccagcgccauggaggaguacgcucpagcccug\n", + "upagcagapcagcacuuccuccagcuccaaaagagugcacccaccccaacguuaccaauacacucgugcag\n", + "gcggaaagcuccgacgccggugugcgucuacgcupcguggccugacugcgcggccagacgccagcgcc\n", + "gacaugcgguauagcgacccaaucgcugcccgguaauaggcggaaagcuccgacgccggugugcgucuacgcupcguggccugacugcgcggccagacgccagcgcc\n", + "guccgucccgcucguugguggcgcuguuacauagcccguagucagaggccuuucagcccapccggcgcacg\n", + "ccucaacuuucaggagacccguccguggccuuauuuauuccacccuuccuguacaucguagcgaaucaauccguggcgccgcacuccuccgcaucccucuuuaaca\n", + "cgcguauggagcccccgccccccggagcugccaacauugccaacgccaccgccacgcuacacacag\n", + "gagcuaucugcucagcuuaauagcaggacgcuggcaacaggcacucccugcuccaguccagccugcgcgcuccaccgccgcu\n", + "gccucccuccaacacaguucuccaagcucuagaaaucucugacacaucuugaccaugagaccacggcugguuuuuggcag\n", + "auucacuucauuaaaucuagaggcaguugagcaupagccgucuguauguugaauuapcucgcacucuugcgcaacacgucaccagucggaaacup\n", + "ggcaguugagcaupagccgucuguauguugaauuapcucgcacucuugcgcaacacgucaccagucggaaacupuuugcuucugugauuuauuucauuauugugcug\n", + "agaggcaguugagcaupagccgucuguauguugaauuapcucgcacucuugcgcaacacgucaccagucggaaacupuuugcuucugugauuuauuucauuauugugcug\n", + "cuuuaaacaaccacuggccacagaaccucagcccucuaaggucagaauauuauugcuuuuaccaucagaaguuuaaaucuucapaaaaugaag\n", + "gucuguauguugaauuapcucgcacucuugcgcaacacgucaccagucggaaacupuuugcuucugugauuuauuucauuauugugcug\n", + "agaggapacggcugucaucaaugaagucauauucauaaucuaguccucucucccucuguuucuguacucupugacucagagapaagagauucagccagcacacuccucgcgagcaag\n", + "aguugagcaupagccgucuguauguugaauuapcucgcacucuugcgcaacacgucaccagucggaaacup\n", + "gcgucpagcagcggcucpcagcugcuccugcccgcacccuccccuggagcccpaggacaaggcgag\n", + "auuaaaucuagaggcaguugagcaupagccgucuguauguugaauuapcucgcacucuugcgcaacacgucaccagucggaaacupuuugcuucugugauuuauuucauuauugugcug\n", + "gugcgcgcaggagccagugcgucpagcagcggcucpcagcugcuccugcccgcacccuccccuggagcccpaggacaag\n", + "uuuccgguacacgcpaaaucgccuccugccagugucugaucgcucgccuccgccuccgccucugccgccuggauugcauuauuauuuuuauccpuugccguuugcugcggauggug\n", + "cggugcgugccugaucggaggugucaccuccacuuuccgcguuuccuccggcguggaupaggcugauug\n", + "agccuucpccuuguaguagguagcaugaaacagcagauuugaguauccacaauccuuucaguauuaaauuuucaguaaaauaaaauuacuuguau\n", + "cggcaggcgcccpuccucagcgcugcagacuccugaccugccgacugcggaucccgaguccccggaucccggacccauccuguggagcccacuccuggcag\n", + "aaagccugaaaagcuaucauggcagcaaggcccaagcuccacuaucccaacggaagaggccggauggaguccgugagaupuuuuagcugccgccggagucgag\n", + "cucacucucgcauucuucccucacucccccaguucaguccuucucuugucuuuucuuccucuuguccuuuguccuccugcuccauccagucupcagag\n", + "cgugcuggauguauggaaaccguaguaaacagcaugaaucguguuuuguuuuugaacagaccacuggccuugupauuggcugugugcaauacuccucacgag\n", + "aggcuaagaauauuguacacaaagauucuugauguucuugaggaaaucccuaaaaaugcagcauauagaaaguauacagaacagauuacaaaugagaagcuggcu\n", + "uggagcuaagcuguuuccapugacagaguggcgaccucgguggucgauugagcaggucugagaauuguucccaaapuugugcgucaccgagucguuggcgcuguc\n", + "gcuaagaauauuguacacaaagauucuugauguucuugaggaaaucccuaaaaaugcagcauauagaaaguauacagaacagauuacaaaugagaagcuggcu\n", + "agccupcagagcucagcuuggucccgccgcccggccggugcucccuggcgcagccacgcaggcgcaccgcagacag\n", + "gcccggcagguuggcggaccggcpaggcgcagccupcagagcucagcuuggucccgccgcccggccggugcucccuggcgcagccacgcaggcgcaccgcagacag\n", + "ccuuccuaacaggcuccggcaggcguuapccuuccuaagugcuacccgaaugcguguccagupaggagaapaggaccaagaaccuagaugaauggcccuagagag\n", + "cpaggcgcagccupcagagcucagcuuggucccgccgcccggccggugcucccuggcgcagccacgcaggcgcaccgcagacag\n", + "aagacgcggaagugcccggcagguuggcggaccggcpaggcgcagccupcagagcucagcuuggucccgccgcccggccggugcucccuggcgcagccacgcaggcgcaccgcagacag\n", + "uccupucucuggaggagcccaggaaggaggcuccgcugguuccgcupucaggcgcugacpaccpcugcggcaaucguuagcpuc\n", + "guaagaagaaaauacgaupacccaguuaggaggcgcuucauucaguccugucccaucauaaggaucccuaacagguuuuugagag\n", + "gcccccuuccccugucuccupucucuggaggagcccaggaaggaggcuccgcugguuccgcupucaggcgcugacpaccpcugcggcaaucguuagcpuc\n", + "ggagucaucaagcuuugguguauguguuggccgguucugaagucuugaagaagcucugcugaggaagaccaaagcagcacucguugccaauuapa\n", + "ggagucaucaagcuuugguguauguguuggccgguucugaagucuugaagaagcucugcugaggaagaccaaagcagcacucguugccaauuapaauggaccguuupuuccuuuagca\n", + "gacuggcccagccgcaccgcgucucccgccuucuccgcagccccgcaggccccpcccugucauucccagcgcugcccugucuugcguuccaguguuccagcuucugcgag\n", + "cuucuccgcagccccgcaggccccpcccugucauucccagcgcugcccugucuugcguuccaguguuccagcuucugcgag\n", + "ccugcpcggugacuggcccagccgcaccgcgucucccgccuucuccgcagccccgcaggccccpcccugucauucccagcgcugcccugucuugcguuccaguguuccagcuucugcgag\n", + "acuucccggaagcgcagcagacccgcucaacuucauccupuugaggcggaggagaacuuccagaauu\n", + "acaugaccacuucccggaagcgcagcagacccgcucaacuucauccupuugaggcggaggagaacuuccagaauu\n", + "gcuccpcucgcccccgccgcucpcaggcgcgccgauggcguuucugaggugacgccgcccacaccpcuucuccpcggaggaaacaccu\n", + "gugaacuacauaaaagaacugaaauaaucaggucacucacgaagaagguaaaagcucuugaauccaaucaaaugga\n", + "gcgguggccucgcggugccuaggcupcugccggaccgugaggcugugagucgcgcggacggagccggacaaaagcpcggcggcggcagg\n", + "agugcgccugcgccgcgucggcgugcggaacgccgcggugucucggcgccucugcgcgcpaag\n", + "puggcagugcgccugcgccgcgucggcgugcggaacgccgcggugucucggcgccucugcgcgcpaag\n", + "acugcgcaggcgcgcpcaagapuggcagugcgccugcgccgcgucggcgugcggaacgccgcggugucucggcgccucugcgcgcpaag\n", + "guaupcuuauuuugccaaagaaaacacagcaguugcacccuguuuugcaaaaaccaucaguguuupaaugauucugaugaugaugaugag\n", + "aaaaacaagguuagccugcagcagagccgcagcagcaacagccaccaaagcpcugaaapaagagaacuuagauuugaccugugcaaggaccucagcagcuuggacacagcccacugcagag\n", + "uuaucaucauccuuccacuucaaaucacacucaguccuccuccuucugacacgccauucuucuucuguuuuuguuug\n", + "aagguuagccugcagcagagccgcagcagcaacagccaccaaagcpcugaaapaagagaacuuagauuugaccugugcaaggaccucagcagcuuggacacagcccacugcagag\n", + "agccugcagcagagccgcagcagcaacagccaccaaagcpcugaaapaagagaacuuagauuugaccugugcaaggaccucagcagcuuggacacagcccacugcagag\n", + "acaupauguagagcuggaaagaucugcagaauccupcugaaaguugcuugupaacauggaccugcaagcuugcuuccaucaauuggacagaauuupagcacacupaag\n", + "agaaacgcupcgcccacccuggcagacuaacgaagcagcucccuucccaccccaacugcaggucuaauuuuggacgcuuugccugccauuucuuccagguugapagccgcagaggcggag\n", + "auauaggcccccgacguuucauguacaaucgugguaugaugaagugaaagacuuuagcuacccau\n", + "cuccuaucgagcccuggcucuccpcagcuggapucgcgcugcgccuguupcugcaccucggaccapcuucugcugcaucugcagcc\n", + "gcagauugcgcgapagcgagcgagcpcgcugccaggagcccgcagcccuggcgcccgccgccgcccggagccccgcaauaugccgccgcggcccucuggcucuaggcc\n", + "ugcugcagucaaaauaagcagccaguguuugauaaagacagcuccucuuaggaagaacugucauccccaaacacauagagagacacucucugucucucgauuacaauc\n", + "aguguuugauaaagacagcuccucuuaggaagaacugucauccccaaacacauagagagacacucucugucucucgauuacaauc\n", + "augauuuccagaauggagaagaugacgaugaugaugaagauauugauuauguuugcucuuggaaugaacuacuggucuugcucag\n", + "gaaagugaauucugcauuuaaauuucapaaccagucagaagcaucuggauuaggcauuuagugauacaaggauccagaauaacaaaaacuauguaccagccacauucacacaacag\n", + "uuauuuaugauuccaucugauauacauaggagagaaacugauagaagaauucugauggcaacuguaugauagaagcuauauaaagucaaguguccauuuucuuucaacuauauuugagcauacccag\n", + "aaacuuucccucucggccucggagacggcgccccggccgugccggaguggagaucgccaggcucggaggaaccggcagcucuccacgccccugcccgaagccugacccgacugccucucucagugag\n", + "agucuacuuuccapugagcaagccccagacgguaucuccuggaugccagugagcggcugagagcugaagcucccuggacacucaaggcucuuguggugacag\n", + "ucugacguaaaggcgugcapaggccuagcucugucuccuggacuuagagauuucagacacagaagucugucc\n", + "ggccacgcggugapuggapaaggagapuggcgcpaccpaaugaaagacacagauggcaagagagacagc\n", + "agccacaaaugcccucccugccucccucupcccccaagaucuapuccucucgugccuaggcugucugccugag\n", + "gaaaaaaaaaaaaguaccgcuccagagcaggagccuaggcagccgagapugcccgaaccugagucugaguugcggccacuucaggagcugagaggagcag\n", + "agacagcgugagucupucupaggagaggcuaucccuucuccacguggucggcucaucugcgcup\n", + "gaaccgacacgaggcuucaccupaagcuucaagucugccuaccugugaaaggucaggccccaacaccccuucupaaauccuacag\n", + "cuaggaugcauuucucucacugaaccccauccagcagaggacagaagagucagaagapuagagaggauuuagauacucauagaagauguaguggagg\n", + "cgagucccacgcgccacccccpcgcccucgacgguggaucuagcggcggcgaggaggcpucccggccccggcgaaccccagucccggcccccggccccpcccagcuucggc\n", + "gccuacgcpacccaaccgcggcgaccggacgugcacuccuccaguagcggcugcacgucgugcca\n", + "acupugugcgcagcgccuggagcaugagccpugguggcgugcacggaggaucgcpaggcugccgccucpacaccccacucacacag\n", + "aacagaguguucugaacaucaacacaaaguggaagaaccuuaagcugaagguacaguauauuauuuacacugaapcuuguguguggacaagaaagcgcugacagcucaa\n", + "gcagcgccuggagcaugagccpugguggcgugcacggaggaucgcpaggcugccgccucpacaccccacucacacag\n", + "ggcaaaaggauguauacacuccaucuucauuuaaaacacuggaggauuggaaaggagaaaaggaacaggacagaaaaaaa\n", + "aaaagaaagaapucucuccauccaucccuuucugauacuuucccugaaucccagucuggaaapuaguaaaagaggcgg\n", + "aguguucugaacaucaacacaaaguggaagaaccuuaagcugaagguacaguauauuauuuacacugaapcuuguguguggacaagaaagcgcugacagcucaa\n", + "acacuuggacagcaaacugauuucaaaccacuccuuuucaaagaucucugapagacauugcaccuggccacugcagcccagagcaggucuggccacggccaugagcaugcugagccauc\n", + "cugcgccaugupccugaagcgcgugucugcugucugugccagugcuccugccpuccccucaggugugucguuuccgucgcgcuuccgcccucucggcc\n", + "aggcuguggccaggccagcupcucpagcgccagccugagaggagcgcgugagcgucgcpagccucpcacc\n", + "pcuuapaaggccgagccagccupucaaagaagucaaapcugccuggaggaggcagccugucagcuggugcaucag\n", + "aguccugcggugccuuccucgagucuggccugcuuuccauccugcuaaguacuupcauuucccucuuugg\n", + "aucccagaggccaaggcuuggapcagcupcuugccccuuagauugaguauccupcgcuagcgagcuugguccugucpacggccucugagugcugccuuggucagcgg\n", + "cpuacacagagaagcggcucccgucggaggccgagucgucgccacgaucgcccccuugguggacucgcaggccgagcggcuuccccgcagagcucgaggapcagacggcggcpcgcc\n", + "gagaagcggcucccgucggaggccgagucgucgccacgaucgcccccuugguggacucgcaggccgagcggcuuccccgcagagcucgaggapcagacggcggcpcgcc\n", + "agagaagcggcucccgucggaggccgagucgucgccacgaucgcccccuugguggacucgcaggccgagcggcuuccccgcagagcucgaggapcagacggcggcpcgcc\n", + "agaagcggcucccgucggaggccgagucgucgccacgaucgcccccuugguggacucgcaggccgagcggcuuccccgcagagcucgaggapcagacggcggcpcgcc\n", + "aagaucucucuggaccagcucpugcapccucugcpagcccuccuagaccucugcggcuucuccucuaac\n", + "cagaaauuuccgcuuucuuucugcagcaggaaccgcggcugcuggacaagapugcgguggauacugaccuuugcuccggccucgu\n", + "cgugaagacacagcgcaucuccccgcuguaggcuuccucccacagaacccguuucpccucagagcgucuggugag\n", + "auuuccgcuuucuuucugcagcaggaaccgcggcugcuggacaagapugcgguggauacugaccuuugcuccggccucgu\n", + "cuuucugcagcaggaaccgcggcugcuggacaagapugcgguggauacugaccuuugcuccggccucgu\n", + "cuuucugcagcaggaaccgcggcugcuggacaagapugcgguggauacugaccuuugcuccggccucguguag\n", + "aguuucuuacapcaaccggapugcaugugupuguggacggcggaggcuguuaaucccuuug\n", + "cuccuucccugucucugccucucccucccuuccucaggcaucagagcggagacuucapagaccagagcccagcuugccaggcacugagcuagaagcccugcc\n", + "agaaugagaucaugucuggccuguugcaagaaccagaaugaaggauggagcagaaguuggauupcggcaagaapa\n", + "gcaucagagcggagacuucapagaccagagcccagcuugccaggcacugagcuagaagcccugcc\n", + "ugcuuuguaggaaaggaagagauuagcucuggauccgccgaccucucuuggcaggccuauccuuugagcuccuuugcauuggcagaacau\n", + "cacugagauuaugaggcucuggccuccacuggccacucacucgugacccuuuccaccacggcggagccuuccaagccuaccuccugccguguggugaucuaccugcagcpag\n", + "uuucccggauagagcgcuaugcaugcapacuuguagucucaggcuccccagccggcupcupcagcacuccpcggagucgacgagcgcaggau\n", + "gcuggauccucauagaccguuguggaaagcacuuuggcaccauuuugaauuaccuccgagaugacaccaucacccucccucagaaccggcaagaaaucaaggaauug\n", + "acagcuupacugcugapcaggcggcugcaggcuapcggcucggaguccgcuggccacccagcugagaggagaggcgcccccpacg\n", + "gccauccagagcgcggucacaguccgacuggcggcacggaggcggcggcggcggcggcggcggcagcggcggcggcagcggcggcggcagcuguagcugcagcagcag\n", + "guaaagagagcguuuucccaaagaaaauaacauagcacagaaggaaaaauaaaaagaaauugcugcagauuuuacuuuaugugagaaaaucuacaauuucuucgagacacucauauaaag\n", + "acacuaaaacaccaccauuuugguucccaaccgucucccacguagcpcagaggaagcuggaggaggcugapcupcagcacggcgupuagcagcgguggcgaccgcugcaccaa\n", + "ggugcaucugacaagccuuagaugaccuccagcaacuucaguucucaccgaauuacugcauuucagccuuacugagaagcagccagucauacuauccucaaauuuu\n", + "ggagagguagapcagaagaaaapucaagaaggcaggaccccgugaagcacaccuuuccuaaggauuuugacgaaugagaaugaagauaaacu\n", + "cggcuccgagccuucgccggcgucccgacccgaggccggacccgaggccagucccgccgcugcgcagccgaagccagugcpccugagapacgcgcgccccpcccccgccgcpcacc\n", + "acacgcuuacgccgacgaccaacgaccgcugcaggcccpccgcugccuggccguuguapuccgcgcguccccuggaggcuuuggacgccgucupcgucccgacggcugg\n", + "uggaagauagaugauaagccuguaaaaauugacaagupauggaucagcugugaaaaacucuuugg\n", + "gaccuccauguucccaaugaggaccgcaucaagcagcugcupcaggaugccuggacuucgcagaagagcgagcuggcpuuucuauccccggcuc\n", + "uuauugugacgccgaaaacggagaaaccccpuccggcgagapcugugacagucggagucccaagcugcgguucggcugcugccgag\n", + "uuuuggcccuacauuuauuuaaagccugaauuupaguaucugcaaagcacugaagguuuuggacauugucuuuuccugcuguugaaagagacccucuucauauauacaacauucag\n", + "ccapcaaccagaccgagaggagcauguguaaccugaaacaggugagccuauggagacaguaccuaaugcgacugugcacggaauauguguaugcagcaugagcuccapaauaa\n", + "guguguacpuguguguguguguguacgccgacacgucggugcggaccgacgcpugucaggagcupacggccpcag\n", + "cgaaaacggagaaaccccpuccggcgagapcugugacagucggagucccaagcugcgguucggcugcugccgag\n", + "cuuauuauugugacgccgaaaacggagaaaccccpuccggcgagapcugugacagucggagucccaagcugcgguucggcugcugccgag\n", + "accagcguucpagccugucgcagcpaccgacggaauccggagcaggcgacapcgcagaagcp\n", + "gaagaguaagcpccgcgaaguuggagapuupacguuaapucpucuugguacuggupugaa\n", + "auacagccuuuuccucccucuccaugaacucuggaaacaguacaucapaccugugcagupcucaagccagacac\n", + "aagaugcaupuccagaguauaaaggaacccaggagcagcugaaggcaggucagaugaaggcuagguggcuggaacugcaacc\n", + "ggagaggccugcugguucuugapcccaagugguugcagcaccgcaagcugcucacaccuggcuuucauuaugaugugcugaagcccuauguggccguguucacugagucuacacguauc\n", + "gugcacuggagcupagcaaaggaggcucugugagaggapccaguucagccgcagcaggaggacugacag\n", + "aaucgaggcuucaugaaggcaaaggcaguggcaucucagaauuugacaaaccuccuuucaucagugacugguuccauuucaggcuggcccaaagucaaa\n", + "cccaauucugagacgaaguccugacaucaccaaaucgccucugacaaagucagaacagcuucugaggauagaugaccaugauuucagc\n", + "agacuucugcgucgcggaagcpucccgcaggucgccacgguupaaacgcggcggacgccgcccccgucccgaapacucgaaa\n", + "gucuuguccugcaagguggauucccaauuccauuguccacagcugaagcccaugcuauucuugccucuccauucuggccauguggauuccuccuccaaucaag\n", + "agaugaggaaguggcaggcaggcaggcuggccccpacuucucucuggcccugcucccuccgagcgcuccgccguugcccgccuggccccuacgg\n", + "cgaucacucacucacucccucacucacucccacacucacucacucacgucucccccagcucaccuccuccccaccccagc\n", + "ggaguagaguapcaggagaaacupccaggcugcacuuagcucaapccucgaggacucucugcgucucuggagacaapcacuacacgcacuucaga\n", + "uccgucauuccccugcgcucucuuuccucacccuuccccccgccaccgupuuccagacuupauaaguaaacagcpuggagcgaggccuacggacccaggccag\n", + "cuccuucgcgccggcccuuccgcpugaucagcuggucugcgcuccccugacgupcupcacgucaccgccga\n", + "cuccuucgcgccggcccuuccgcpugaucagcuggucugcgcuccccugacgupcupcacgucaccgccgaauggcagccuccagaaagccaccgcgaguaag\n", + "acggcagaaugccuccaaaggugacuucagagcugcuucggcagcugagacaagccaugaggaacucugaguaugugaccgaaccgauccaggccuacaucaucccaucpagaugcucaucag\n", + "gcpugaucagcuggucugcgcuccccugacgupcupcacgucaccgccgaauggcagccuccagaaagccaccgcgaguaag\n", + "gacccggcgcuagcccgcccgcccgcccgccggcucucgcgccuccuucgcgccggcccuuccgcpugaucagcuggucugcgcuccccugacgupcupcacgucaccgccga\n", + "ccugucpcugaucpagagapauguaguuccaggaagapacgacaggcgcaaapag\n", + "aucuucgaccccccggaggagcuggagcggaaggugupaacuggcgaggcuggucuggcagucuuccagugugguguuccacacpugccggcaucagcacugccucuggcauccccgacuucag\n", + "guucgccagcauccaagauggcggcapcpcccaaggcgcggcgcgaauugugacgcaggcguccggcgugcuccgugcgcaagcgcuuucggcggcgauuag\n", + "gugcuccgugcgcaagcgcuuucggcggcgauuaggugguuuccgguuccgcuaucuucuuuuucuucagcgaggcggccgagcug\n", + "gugcuuguucccgcuucugccacacgcaaaauugucuuuguuugccuuuggaucgcaaaggcagaagaacagcaucacuaaaa\n", + "ggacaauaguuaaaaauugguugaaaaacacugccuuagaaucucccaguauguuucugugauuccaucuccuccaccaagag\n", + "aguccgucuguccaucccgccgcgccpcagucuaggcggagcpcucaggcggcggcggccucgacgcg\n", + "ucucggucuucgcgucugccagccuggcuggcaguccgucuguccaucccgccgcgccpcagucuaggcggagcpcucaggcggcggcggccucgacgcg\n", + "acagcagccuugacaaaacguuccuggaacucaagcucuucuccacagaggaggacagagcagacagcagagacc\n", + "gcggccgcgcgugaggccgapapcggcggcgcgagcggcggcggcggcgguuccagcaugaagaggagagcuggccuppcagcaugag\n", + "auugcapapaaggagaggaugucuucuauaaaaaagaccuaaaaugguugacagcuccuuaauucgcuuuaucccaagugcaaagugaucucuccugaugccugcccugaaagu\n", + "cagugagacauuggacguguuugcucaugaagaugcaguauauggcuugucugugagcccaguga\n", + "acacucucpacucauggagacpuguucgaauccagauccugcucaaggccuuccuaccucgg\n", + "pcgcpccgcgauggcagcggcggagcapcugagcccgcugcccgcccgcaguucccggccccgcuggccccaguc\n", + "gcacuuggagauguucuuauggccaucuaucuuuucacccugguggaggccgugaauaggcauuuuccccauuuaaagaaaaa\n", + "pcccggcguccuccucgccgcccgcagcguccccpcpcgcpccgcgauggcagcggcggagcapcugagcccgcugcccgcccgcaguucccggccccgcuggccccaguc\n", + "ugccaauaggauaagaaauaagcuguaugaagaaauccaguuugagaccaggagccugupcaggcuac\n", + "gcacuucuuccugcugcuaugugaauaaggacguguucguuuccccuucugccacgauuguaaguuucccaaggcuucuucagcccugcggaacu\n", + "gcaaagaaauuggugcaaaauaauucagcuucaggaaagaucuggcaagauggcugaauaggaacagcuccggucgcagcucccagcgagaccaacacaggapugauuucugcauuuccaacugag\n", + "aagcguuucccccgcccggcuucaucccugcuggcggcccagcgucguucuccuccugcgcgaggcggccaaggccugcuggcccggagccgcgccuccacccgcgcgag\n", + "pacuuugcaggcagcggcggccpcggagcpaucgagcccucgccgaggccugccgccaupcccgcgccgccgccgccgccugucacccpccgcgcpccgugagcguc\n", + "acgagucggcggcgcuaccgapcugupcgcgcagcuggaaccuccggcugucagugcgcuuacaguuccuaaccccgacccugcgcgcagcccgcacu\n", + "auagacgccacgagucggcggcgcuaccgapcugupcgcgcagcuggaaccuccggcugucagugcgcuuacaguuccuaaccccgacccugcgcgcagcccgcacu\n", + "cuauggcuguagaaaaauaacaguacugcucccaugaaaaucugauuuucagcagugugaaccugcccagaaggaacugauggugagag\n", + "guugaggaggaagaggaggaguuggucuugcugucucaggaguggcaaagguggaagaaaauucuugu\n", + "guagcgaguugcacucuugugcuccpcagcaaaggaccuuguaauugccagcugapaggcuggccpuagugcpaacgcgagugcaaagcuucaucggaguacggaaaugagg\n", + "gaggcuccggaccaagccccuucagcuucucccuccggaucgaugugcugcuguuaacccgugaggaggcggcggcggcggcagcggcagcggaag\n", + "guuuuuacccucagcggcuuucggacuguacagauccuggaaggacaaaagauccuggcuaacuguucuucucccuaccag\n", + "ggagugccgcuuccupcuagagacaagcaccagccugcaguggagaacgcaggaccccgcugcccagaaggagcagccacg\n", + "gccugcggaggacuggcccagcaaggucccaggucuucccucuccucagcgccuaagagagaggcccagugcpugaggagucgcgaggaagaggcggaaggcgccggaag\n", + "acagguuuucaccauguuggccaagcuggucucaaacuccugaccucaggugauccacccgccucggccucccagaguacuaggauuacaggcaugaaccaccaugcccggcccag\n", + "uuuuuuuuuuuuuuuuucuauuuugccugaapagugccgcuuccupcuagagacaagcaccagccugcaguggagaacgcaggaccccgcugcccagaaggagcagccacg\n", + "uucgcguccccgagapcgcagcagupccugcgagcupccpuggccgcgccpucggaguguggcuggagapccgccccggaagcggugcugcgcccaacguccccuucucccc\n", + "ucaagacagguuuucaccauguuggccaagcuggucucaaacuccugaccucaggugauccacccgccucggccucccagaguacuaggauuacaggcaugaaccaccaugcccggcccag\n", + "acacgcggcccgcucagguccpagagucggcccgcggcucuggagcgugcaucugcgaugccagugaacgag\n", + "aaaauugccaagcaacguuggagcagcucggcgccccaaacgagcaggucgaugccugaggauuuaauggagaaaucccaaa\n", + "ggaggacuggcccagcaaggucccaggucuucccucuccucagcgccuaagagagaggcccagugcpugaggagucgcgaggaagaggcggaaggcgccggaag\n", + "ggaagugcaggcaaagcggcucccpagcgccgcgcgguccugcgcpaucagcgapccgcgccccggcpcpcggc\n", + "aagaagcgcucgcccaggaggaggcapcaaauuggugaacapcggcguguccuuauacpcacgaacucgcgagguccu\n", + "gagaccugacagaugccaaaacaaaggaacaguupauccaggcagcaugagguagaauggcaaaccuaccapuauucugaagaagacaagaguc\n", + "auauccgacauucaccugagcagguuucgagauccaggcagagcgguagacuuagagaaauucuguucugaaacuauugacaucauucaaccagcucucguccuagcaacag\n", + "agcupcugagacugapagagaagcuggaggcugaucuugguccagcagaagcugagcagagcugcugucuuuggucuuucag\n", + "guuggcuggcuccucuggcugauggcauguugagguacaupccagcggcagcgapcauccaauccagapuccacucuagaggccaggccaccagcacc\n", + "aguugacgcucupccgccaccuccgcggacccugagcgcaagagccaagccgccagcgcugcg\n", + "cuccacgcucgugccgcuccccccccgcgcucccaguugacgcucupccgccaccuccgcggacccugagcgcaagagccaagccgccagcgcugcg\n", + "cgcucccgccgcuccuccacgcucgugccgcuccccccccgcgcucccaguugacgcucupccgccaccuccgcggacccugagcgcaagagccaagccgccagcgcugcg\n", + "ccaguugacgcucupccgccaccuccgcggacccugagcgcaagagccaagccgccagcgcugcg\n", + "agauuccaggaccugugguuagcggacuccuauugauguuucupaacucuagaccuggaaguucag\n", + "ccuagaauaccaaaggagcccgcagcuccuuccgccuuccucaacupacacagagugucacacagaggacucugaucugucccugccagag\n", + "ucccaguugacgcucupccgccaccuccgcggacccugagcgcaagagccaagccgccagcgcugcg\n", + "auucaugcaggaggcauucugcaugcaggcagugacugcagauuccaggaccugugguuagcggacuccuauugauguuucupaacucuagaccuggaaguucag\n", + "cccgcgcucccaguugacgcucupccgccaccuccgcggacccugagcgcaagagccaagccgccagcgcugcg\n", + "aaaaugcuacgcuuaaauuuuccuggaguccagauguccuucugaauccacuaaaccuugugaagcgaugugaacgucag\n", + "pcccpcggcggcggcgacgcgacgucgcgaggaggaggaggcggcpuccaggaggccggccagcgcauggaggaggaggcc\n", + "ugcgcagucggugccaucuucuacgccccupagcguuguggcugcuguuuccuucggcuuuccuccuccugcuccacc\n", + "gcagucggugccaucuucuacgccccupagcguuguggcugcuguuuccuucggcuuuccuccuccugcuccacc\n", + "aucuucuacgccccupagcguuguggcugcuguuuccuucggcuuuccuccuccugcuccacc\n", + "cacugcggaaggcgcggapagcagcagcuggucagcaagaggcugcugagaaacgacgccccagaggaagcuggagapauguguggcugcgauccucpaaaccgag\n", + "gugcagcaguuccugcggcaagcccagcpacagaggaaaaggagagagapcucuggucagccuucgucgaggcuugcagcacccugaaacacagcaaaccuucauccg\n", + "auuaccuagupagguggccaaggcaucugccacugcugcugacugccacuaccagccggagccapccuggucgagacaacuauuuuugag\n", + "acugcugcugacugccacuaccagccggagccapccuggucgagacaacuauuuuugagguaucugaggcuaccccacagcacucucuggcauug\n", + "gcaagacucguggcugugacccaupccucugaggaggcguuguaaguccgcccagcuccccacuugcugugcucucacuca\n", + "acuaccagccggagccapccuggucgagacaacuauuuuugagguaucugaggcuaccccacagcacucucuggcauug\n", + "ggccaaggcaucugccacugcugcugacugccacuaccagccggagccapccuggucgagacaacuauuuuugag\n", + "gcaagacucguggcugugacccaupccucugaggaggcguuguaaguccgcccagcuccccacuugcugugcucucacucaaugcgaapaaccaag\n", + "gcuccagcpacgauggcpcagcgccgugccaggcgguaauugcagacagacuaauuuaaagag\n", + "cugauuugcauggauggacucucccccucucagaguaugaagagapagagaucupaagcucagcuucagcugupuagagaagacaggacucaggacaaucuccagc\n", + "ccaucugcugacucaacuugcuaguaucpcagcagccaggaccacagcuccuccagcuccuuugugaccuuuuccuucagcuucuucaaauacupuuag\n", + "auauacuuuuaaaaaacuccccguagaaggcagcgaagaagacaaaucacaaacuggugugaauagagccagcaaaggaggucuuaucuaupaacuaccugcau\n", + "uuggaaaaaguuuugaaugcacaagaacugcaaagugaaacaaaaggaaauaaaauccaugaugaacaucuuuuuaucauaacucaucaag\n", + "cuuaugaacucugguuuaagcaaauccucupaguuggauucuguucgagagaucuuucagaauggccau\n", + "gacucaacuugcuaguaucpcagcagccaggaccacagcuccuccagcuccuuugugaccuuuuccuucagcuucuucaaauacupuuag\n", + "gcugaccuauugcugaggacuaugagaaaaaaguuauuacagaaugagucauauggaaaacacuugcaaacagaagaauauugagaacaua\n", + "acucagaagcuuggaccgcauccuagccgccgacucacacaaggcaggupugaggaaauccag\n", + "ggcuuuccuggcaggccuggcppccagguugccaugacgaccgcggcuaggucgcggcagacucg\n", + "gcuggaaugcagcggcaugaucucaucucagugcaaccuccaccucucacguucaagcaguucucaugucucagccucccgaguagcugguaaaacag\n", + "agacucgguuggugacuccpcgcgucgaagaucuuguaccugucguucgcaguggcucacuuuccca\n", + "gugagugaagauggcagagaggacgugaccagcacucacccuuguccaccugcccaguggcaccgcc\n", + "guugugacuagaaacgucaauaaaagcuucuaaagacccacaggagagacccaaagucuucaagccuggaguuccugccugguucuuccugaggucugagcaccuucuaaacuacauccagaucug\n", + "gacccaaagucuucaagucuggaguaccugccugguucuuccugaggucugagcaccuucuagacuacauccagaucug\n", + "acccacaggagagacccaaagucuucaagccuggaguuccugccugguucuuccugaggucugagcaccuucuaaacuacauccagaucug\n", + "gccuuuuccucuccgcccagccagugcccagcgcpcccggauccggccpcacuucccacaggcgccgcagagcagcgupugcaggcugcaguggcuggcgccguccucgcccggccaggcc\n", + "gagucagugaccuucgaggauguggccgucuacuucucugagaacgaauggaucggccupcccugcucagagagcccuguacapaugug\n", + "auugaagaaugucccggauuccacupaagguccuccugaggaaugucauccggcacacagaugcucacaauaaggupagguacaaccuaguuacuccucaacgcuuacugaag\n", + "cccugagcgccaggcuucpcccpaaucgccgccgccgccgccgcagagcugcagcucpccgagg\n", + "gcagcagagugugccugugaggccaggagcguggagcucucaaaggaccaucuuguuuuucugguuuuaaaccag\n", + "acucauuuuucaccaaauucuuuuggugaaggacgcuucagaaacggccaucacugaagagcagacccguuupuucuccacgcauucuagacucccgaagag\n", + "acagucuuggagacauuacuccugagagacugcagcugauggaagaugagccccaacuucuaaaaauguaucacuaccpauugagauacaaacagcauuuaggaag\n", + "gucucaucugaguagcagcuuccugcccuccuucuuggagauaagucpcuuuuggugagacagacuuucccaacccucugcccggccggugccc\n", + "agacugcagcugauggaagaugagccccaacuucuaaaaauguaucacuaccpauugagauacaaacagcauuuaggaag\n", + "gcagcugauggaagaugagccccaacuucuaaaaauguaucacuaccpauugagauacaaacagcauuuaggaag\n", + "uggaagaugagccccaacuucuaaaaauguaucacuaccpauugagauacaaacagcauuuaggaag\n", + "acauuguucugaucaucugaagaucagcuauuagaagagaaagaucaguuaaguccuuuggaccugaucagcuugauacaagaacuacugauuucaacuucuuuggcuuaauucucucggaaacg\n", + "gaaauagcugucuaucacaggcagcuaggaacugcuugcccacuuuuuuuuguucugaaagaaaggauacagaccaucupcca\n", + "aguuuucuugaaguacaacuaaggacaggucaccacuaggcacuaacaucgcugacuugcaugauuauggagauggucuaucugaugcugaaaaugucucuaguuuuuugacaacggcuaaauaacc\n", + "gauauuuucuuuuaaaacauccauaucucuucuuugccauggaaacuacacccaaucuaccugaaccugcggcaccccucugaugacccauuuggauucucugauuucacugccaagauucuca\n", + "aacagcugcucucggcgugcuccggcacuuggcagcuggacaggcagagugcugaugugaaaaauaccacgacaaaaccacccua\n", + "auggaguuucacucugucgcccaggcuggagugcaguggcacgaucucggcucacugcaagcuccgccucccpuucacaccauucuucugccucagccucccgaguagcupacuacag\n", + "guguucauuucacupcagguugucuaccagaaccaapccucuuugaauuuucuuucaagcuauuaauaagaggcaugcauccuccuagacacaaucauccauuuaguaaaauag\n", + "ggucuggauccccugugccgucgccucuuccuuuuucgacgccuccgccgccgccugaggaggcgagcuagccpaguuacaccgccaccgccag\n", + "gaaaacuauuuuucagcguuuguaaugguucuaauacugaucugauugcugaguccaaggauauacagucaugccucacguaaugguagucccauaag\n", + "gcaggucuugaacuccuggccucaaguaguccuccugccuuggccuccuaagguguupauuacag\n", + "cuucccccguaaggaaauggccpagcuccapacccaggcgccgucgcuucggcggagccupcugaccagccaggacagcpuaaacccgaacaauucugcgcgagguapaggcc\n", + "guucaugcaupagaucucagaccaguuguuacagauccggcaggauguggagucaugcuauuuugcugcacagacc\n", + "gccagucapagcggccguggcccagacagugaggaagcgcgaaggcggagcaaccgaggaauccuccggagaagaaucagagccgucgcuaccgccacuaccgccaccacc\n", + "uuuuaaaaggcagugguapuagapuggcaguggagacagcuggagagcacugaggacgcggacccacpuacugugugagcugugaagcccgcuupagaccccacugccagccag\n", + "gugaccaggcauugaugcacccccaggaaggccacgcgcucaggagccccccccgccgcuggcugcugcucac\n", + "gcugcuggugcuccucgccucuupccupcagugapccggcpcgupccgaguggccgcpcgcc\n", + "gaaauacucgucucugguaaagucugagcaggacapuggcugacuggcagauccagagguucccuuggcaguccacgccag\n", + "gcgcgcuuccggcccgagccggaagcuccgacugcggcggcauccpacggcpcpcuggccaccacpacaggaag\n", + "acuaguagcuggugcuccaggcuggcggcgcucaccuuucuccuagccpugacccapauuuauuuuauguuggcuuucucugaa\n", + "pcuppcpccccpcccaggcguugccgacucucgucgcuguccgcccpuaaagaggcuccucucccggapcccgaagccuagcaucgccuucaggcpaaag\n", + "gcpuagucggcgcgaggcggagcuuggcaguuccguccacuucagccgcagcgucccucaccpugucucgccgcagccuccggagaggaacagacccucacucucucugucagaaaa\n", + "gucggcgcgaggcggagcuuggcaguuccguccacuucagccgcagcgucccucaccpugucucgccgcagccuccggagaggaacagacccucacucucucugucagaaaa\n", + "ggcagcapccpagaupcggupagcgcpapaccpccgagccpaapcuccggugacuuaapapa\n", + "augcacccupcupaugguacuucuguucgucuggcauuauugcccuuggucauuuaccggcagcccupccccuccuugcucuucuccaugacacuaggacucccuuggucuugaagcugg\n", + "uugguggcugaauuccugcaggaccagaaugcaccccuugugucccgugccccucagaccuucaag\n", + "cucuucuccccucccccaagccagcaccuggugccccggcpucgugcggcgcggcgcuccgcg\n", + "cagaugccuaupcuucaucaaccccugauuuuagaggaacugcgucauuguacaucucugucuuucucucuuaggccuccaagccuuupaguagcuucugaagaugag\n", + "auuauugcccuuggucauuuaccggcagcccupccccuccuugcucuucuccaugacacuaggacucccuuggucuugaagcugg\n", + "paagcaggagapccgaccgagcgcaacaaagcugagcggcgcgucgcuucaggaacgaagaagccucguu\n", + "guucugcaagagcuggaagcuccaguupuaaggaggcucccaucccgagcuugcguagugguucuguguggcgcugag\n", + "guugucauggagaccgcguuguuuaccucucuguucugcaagagcuggaagcuccaguupuaaggaggcucccaucccgagcuugcguagugguucuguguggcgcugag\n", + "gugacuuuccccucpuccagguapccuggagcugcugcaagugccgccugugcupaapacc\n", + "gcggcugcacuggcggcagcuggagguguaauagugcpuagupuuuggagaaguuccgaggcggcgguggcgccggucaggacaaggauagcggaaccpcccupcuugucgcucacc\n", + "ccuccgcgcagucccugagucccgcaggcccugcguccccgcugcacacccccguccacucccgugguccccgguccggc\n", + "agucccugagucccgcaggcccugcguccccgcugcacacccccguccacucccgugguccccgguccggc\n", + "gcacuggcgugagugccucuucuauccggcccuguggccccagcuccgcaucugccuccgcgucucgcccgcggagcagccucggcuggaauuccuc\n", + "aaacaaguggcugcggccgucgcccaggagucaucggacgccagaaucuggugaggauccagagaggccuaaug\n", + "acagaucagcugaugccggapuuugaagccgcgccgcgapagcgaggucgcagugacagcggcpcgaucggacccaggcugccccgccguacccgccugcgucccgcgcucccgccccagc\n", + "cgcgaacagacggacgcaccggcgagcgccgapacaggccgagcgcpcgccggaggcag\n", + "gugupacaggcacuggccucagaccpccacacugaggucugcccuucucccgcuggccgccacccaagacacc\n", + "ggccgaggcgcgaacagacggacgcaccggcgagcgccgapacaggccgagcgcpcgccggaggcag\n", + "gacccucccgapccugaccguggagguagcacugcacacccacucccugupccggagccaggaggcacuuccupugucggagcccagaaggaaaccaguggccpaagcaccagcugg\n", + "gagaccuggcgccccggccgaggcgcgaacagacggacgcaccggcgagcgccgapacaggccgagcgcpcgccggaggcag\n", + "ucccuccccuaggcuuggcugcugccapuucugcgcuggccaccuggccgcaucccugcccucgag\n", + "puaguupucugacuucguccccucgccauggccccaggacccccacgugugaagccccuggcgcccacucaaccuucgagaagguccguucaag\n", + "cuccuguccaaauaugacccccagaaggaggcagagcuccgcaccuggaucgapacucaccggccucuccaucggccccgacuuccagaapccugaaggauggaacuaucuuaugcac\n", + "agauuupagaaggauuucaaaugacuucccuucgagcugcapcuaucuupcaucuugaccuccacacauuucupagaacuccucgugcagcaggacaucagguggcaaag\n", + "gugaucugcccaccucagccucccaaagugcuggaauuacaggugugagccacugcgccuggucuuguuuuccaaguuguaacgcccuucacg\n", + "cuucucccugcgccupacugcggccgccucucuaaauagcagccaugaggcgccupcaguguccucgcpccagcgacpcaggacgccccguucgccuagcgcgugcucag\n", + "gaguugguguccugccugcgcucaggaugapaaucuggcccuggupcguucuaaucagccuggccuuccugucacugcugccaucuggacauccucagccggcuggcg\n", + "pcccggcucccpcgcggcccucpcggacggagcpcggccggcggcggagacggcgcgcggcgcuucpagccagcpugcugguggagccggacgcpcgcag\n", + "gauugccuuugagguuauuuuaaaaguuuugaguuguacagcacuugauuauuuugcugcauugugaaaggaccucuccagca\n", + "gauugccuuugagguuauuuuaaaaguuuugaguuguacagcacuugauuauuuugcugcauugugaaaggaccucuccagcaaugauuacuucagaauuaccaguguuaca\n", + "ggauucaacuaaugaaacuacugcccauuccgaugcuggcagcgagcuugaagaaacagaggucaaaggaaaaagaaaaapucguccuggccggccucca\n", + "uccgugguggaugacuggauugaaucauauaaacaagacapacaucgcacuucuggauuuaaucaacuuuuuuauccaguguucaggaugucgag\n", + "guacugugagaauagagauguuucgaaauaugcagaaugcagaaaucaucagaaaaaugacugaagaauuugaugag\n", + "cccgcgcgugacuccccccugccggcugcggaggupppacggcgcccccgccgugugcgupcpauggagcacgcgcccuggagccccggagccag\n", + "ggagccaucgauaacucuacgcucggccucgaucgacucgcuccggcuccccucgccguccuggacacggcggagugcggagccgcccguaag\n", + "uuauuucuucggacugcuucgcggugcacggauucagcuucugcccagupcuuucagcuguuugcgcgucucucugucccccuccccuccccccggcacaccucugucuacg\n", + "guuauuucuucggacugcuucgcggugcacggauucagcuucugcccagupcuuucagcuguuugcgcgucucucugucccccuccccuccccccggcacaccucugucuacg\n", + "ccgcgaguccaccgagcggccucugaggagcagccgcaggaggaggaggaggucgucpcggcpcggagaccgcgcucucgcuuccccggcggcggcaapcaggaca\n", + "cucuccggccucccuccgcgccggugcgcggcgccccgucccagccgcagccgcagcggccgccccucccggacccgagagccgcugagccgcgaggccpccpcgccggccpa\n", + "uacaaaaagaggupuacacgccaguccacagugguccugaucaaagugagaacagacagcapaacaucacccucuucagacuggagucagupaacagacccaag\n", + "agugguccugaucaaagugagaacagacagcapaacaucacccucuucagacuggagucagupaacagacccaag\n", + "ggucucccucugucacccaugcuggagugcagugaauguggcucucugcagccuugacuuucuggacucaggcgauccucccaccucagcuucccaaguagcupaccacag\n", + "gcgcguugupcucccgccpucccccgcggcugucgccgccgccuacgccgcugccuccgccuuccugccccgcgucpccpcgccaccuccccccugccucccucuccgcugug\n", + "gcugccuccgccuuccugccccgcgucpccpcgccaccuccccccugccucccucuccgcugug\n", + "agcccagcgcguugupcucccgccpucccccgcggcugucgccgccgccuacgccgcugccuccgccuuccugccccgcgucpccpcgccaccuccccccugccucccucuccgcugug\n", + "gccucucuggagcccagcucuupcccccugcacucaccugcucuuccupcuggcugucuccugcucauccagcc\n", + "ucucuggagcccagcucuupcccccugcacucaccugcucuuccupcuggcugucuccugcucauccagcc\n", + "gaugauauaggucuugccuuucauuuuaacugccauucuggcaacugaacguuggcaguaaacgcagcuuaguugucucagaggacucaca\n", + "agccgcccaggcagcaaagucaggcggucggcuucgccagcagccgaugagucucauccuguggauugcccagcgccapaucaggauccggagagguguccaggaggagcagacccucagaccag\n", + "auuuuaacugccauucuggcaacugaacguuggcaguaaacgcagcuuaguugucucagaggacucaca\n", + "augauauaggucuugccuuucauuuuaacugccauucuggcaacugaacguuggcaguaaacgcagcuuaguugucucagaggacucaca\n", + "agcaaagucaggcggucggcuucgccagcagccgaugagucucauccuguggauugcccagcgccapaucaggauccggagagguguccaggaggagcagacccucagaccag\n", + "aguuggaagccggaccccagagccugaggupcagugugccapucccuugcggccuccucaag\n", + "cacgcaggucaupccuuggcaggagcgguuuuggcagapupccggugccucuggaag\n", + "gucaupccuuggcaggagcgguuuuggcagapupccggugccucuggaagguaugaagauguaaaugaag\n", + "aggcguccggcgugcuccucccucccugcagccccpcagcaucucccagaggcuccgcggcccaggcuccuggugugucugcagugcagguggcuccuggaagacccucag\n", + "gugccucgccggccgcucpcagcucccpccgcggccagccgaggaucagagcgcuugccccpucugucgcgucgcaggcgccgccggagcccuggcc\n", + "gucccuacaguguucaaggucacapucaaaauauaucagccagapaagaapuggcucuaugguguugugagccaucaggacuccauca\n", + "gaacggcggccgcpuggugcggapaggccuugcpcggaucpcgcuuggcggcggagguggupaggcggcpcpagcgcpucaggccggccccggcg\n", + "ggapcgagaggacugagugugcugagcccccccpacgaacccccggcugauggagcucugaagcpcagaggagcucaagacucaggccaaugacuacuucaaag\n", + "aggugcgcagcgagcgcuccgagcggcgcgcaccaggcggaugccccagccpcccagcgaacgccag\n", + "capcupccpcpcggcggcagcggccaggugcgcagcgagcgcuccgagcggcgcgcaccaggcggaugccccagccpcccagcgaacgccag\n", + "auccuccupaagcuucaauacagcugugcaagucuggagucuacaagagccuacuauagacauucuacaaccaaccagaauc\n", + "agacapucucacuauguugcccaggcuugucaagugauccucccaccucagccucucaagaugcupauuacag\n", + "gugacaaacagcauguuuggugcuucaagaaagaaguuuguagapucgacagugacuaccaugacgaaaacauguacuacagccagucuucuauguuuccacaucggucagaaaaagau\n", + "apagacguggupcgguccuuccugugacacgacccuugagugacaguucuauuugauugccuccgguacugugaggaaaggacacgacucu\n", + "aaacacaaacacgaacacgaacacgcucagcguccccpapcggacugaagccaccucaccauucaucgccccuggaccccgcagucccccucggacucapccagagccuucu\n", + "cuugcucccagcagccuccgcgguggauacgucgccaucuuggauccgcpacaagaaaauucaugcg\n", + "gucuugcucccagcagccuccgcgguggauacgucgccaucuuggauccgcpacaagaaaauucaugcg\n", + "auugcagccaaaauuggaggcgaugcugccacgacagugaauaacagcacuccugauuuugguuuupccaaaagagacaguuggaagauggag\n", + "agagugcuccgcggccguguggagcgaggccuuguucccgcguugagccgccgccgccgccgccgccuccucagcuucagccuccgcgccaggcccggccccgccgcgcc\n", + "uguggagcgaggccuuguucccgcguugagccgccgccgccgccgccgccuccucagcuucagccuccgcgccaggcccggccccgccgcgcc\n", + "pcgguaggcpccuggcccucccgcugcgccucgagupaucccaacpugaccccccugcapaguapcgcacupucaccaggagcggcgccugg\n", + "aguuggaaagagaccacagacuuugapaagcucacucaggaucugcucuccggcaaaguaguaagugag\n", + "gaaaacucauuugcucuuggagcagucaggcagugacugccuucggcuuuuuuucugcugacuaagaucuccuauagagagcuacaaca\n", + "aggagaguacaggucgugcugcaguuaguucauugaaaacucauuugcucuuggagcagucaggcagugacugccuucggcuuuuuuucugcugacuaagaucuccuauagagagcuacaaca\n", + "uaugacaucccuuucccuucucaaguggacacugcuaugcucucaccccucacucagaacuaagagucuccag\n", + "aguaacggccgcaugguaacucaggcgccpcgcacuguccuagcugcugguuuuccacgcugguuuuagcucccggcgucugcaaa\n", + "agapacucccagcuccagcucacccauucuacacuugcucuuuugcucccaaccaggaagccauc\n", + "cuuuccgcgcugccugcagccpaapcgcuucgupcgccuccaggcgcgcugacpcgucccguuugugcccaggugaugacggcggcggc\n", + "cccuccccgccpcgcgcugcccgcagcuccacgcgcgccapccgcccupapcgcgcgcgcgagcggcgaccggagaggagcucpcggcggag\n", + "cacucugucgcccaggcuggagugcagcpugaucucggcucacugcaaccuccaccuccugguucgagcaauucuccugccucagccuccugagcagcuggaacuacag\n", + "ggucaaggucucguccuuacugcuguguguccucugcuccuagagucccagccucuguggcccuaugaccugcagguauupagauccacaacuaagucgccaggacccccuggaagccuagaaaug\n", + "ggacpuuucaccauguuggucaggcuggucucgaacuccugauuucaagugauucaccugcuucggccucccaaagugcupauuacagg\n", + "ggaucauugacauuuapauguggccauagaauucucucuggaggaguggcaaugccuggacacugcacagcagaauuuauauagaaaugug\n", + "gucucaacauaugcacuaguggaagugccaccucaugugaagaaugucugcuaauccacccaaaaugugccuggugcuccaaagag\n", + "gugccccgccccuuucccguggcgacpcggcuaagcaacpagcpcucuacucagugguuucgagccccccacgccccaa\n", + "aaapagugagucugacauuacacauaccagcacacagccugugguuuuggauccuggaguaccugucugguaccugguacccggcacacugugaguuccuggacaucaapcug\n", + "cgcaggaagaggaagauguuagagauuacaauuugacugaagaacagaaggcgaucaaggccaaguauccgccagucaauaggaaguacgagugugaguagguggcuuacuucucucuuuacau\n", + "uggauuguauuacacagagcaugaauauacuucuuuagguuacacgcaupagauacucuggaggaagcauuugagcaaugugca\n", + "cgcaggaagaggaagauguuagagauuacaauuugacugaagaacagaaggcgaucaaggccaaguauccgccagucaauaggaaguacgagu\n", + "auuuggaucauacagcagauguccagugaguauagcpaguucauuccuuugaaaccacgucaguaggaagacuga\n", + "uccagaggugcguggucguggcgcgapauccugaggcugcuccagcagugcgccgccgccgucuccupcggcuupuuagccpag\n", + "ggauguuucagcagccccugagaaggaagaggaggaagcugapcccgcugapcgcaggaccugapaguccuacauccagcucguccapugugcaggaguggcaggaugguugc\n", + "gccaggcugaggccgcggugccgcaugagguacgcggugcagacggcggccgagcggcugcggccguucuugcaguagacuaggcaggcgccgccggcgcgcaccgcggccucc\n", + "ggacpagcgcpcguccgcgguggcugcagucccgucggucucccugcuguccggcgcgagcucuucgagucuugcuug\n", + "pacpagcgcpcguccgcgguggcugcagucccgucggucucccugcuguccggcgcgagcucuucgagucuugcuug\n", + "guaggcgcapcuggcaagcagucpacpagcgcpcguccgcgguggcugcagucccgucggucucccugcuguccggcgcgagcucuucgagucuugcuug\n", + "ggcaagcagucpacpagcgcpcguccgcgguggcugcagucccgucggucucccugcuguccggcgcgagcucuucgagucuugcuug\n", + "agacgccpcggacpaggaccggaggaccgaggacagaaagauugguggacaggagcagcggccggupapcgcucggcggcggccugcggcc\n", + "ggcggcccuggaggagacggaggccgcpupcccgaggcgcaagaggaagaugaggacgaagaagaggcgcugccgcacuccgaggccauggacguguuccaggapucuggcu\n", + "guuaacgucccuaaaacccgccggacuuucuguaagaaguguggcaagcaccaaccccauaaagugacacaguacaagaapcaaggauucucuguacgcccagg\n", + "gaaagcggcguuaugacaggaagcagaguggcuauggupcaaacuaagccgauuuuccggaaaaag\n", + "gcuaaaacuacaaagaagauugugcuaaggcuugagugcguugagcccaacugcagaucuaagaga\n", + "gucpugaguggaccacccuuuaggcggaguccuuccuuaagcucccgcccgcggcuccgaacugaguccucucagccgcccgapcgcugcgcugagccuuacacucu\n", + "uugucaggccgccggccccggccgcuccaaauaaaccguggcuguucguggaggapagaagcacggcccgauugucuccpucucagcapuuccgcpagccugccaggcuugaag\n", + "apucuugcuagucuccggagacgccaaauaggcucgagcuccgcggcgaucucauuuuacgaguugaugaagaauc\n", + "acacggaggcggaaggccggapcaguccgccgcpcgagcgcgcaugcgccuuccupacccacggcaggcgcgaaucccagcggccggcpcggcp\n", + "pcaguccgccgcpcgagcgcgcaugcgccuuccupacccacggcaggcgcgaaucccagcggccggcpcggcp\n", + "gcpcacacggaggcggaaggccggapcaguccgccgcpcgagcgcgcaugcgccuuccupacccacggcaggcgcgaaucccagcggccggcpcggcp\n", + "gcagauggaguuauugccaugguguuaggacaagcugauuguguuaaagcaugugacacaccuaauuucagaaaccagapaaaucgccgcucauuaaaguucaag\n", + "guucpaucgccucuagcuucccaggacaaccagccacggauccugupcaggapcugccaaggcccaguuggaggcucaauuu\n", + "accucaccaupacgcccccgaccucgugcggccaagacguggauguuccugcucuugcuppagccupcag\n", + "agagaacugaaguacupccuccuccacupuccgaaucaguaggugaccccgccccuggauucuggaag\n", + "acaaucucccuuuucaagccagccucugucccuccuacucaaccugcuuuaucucuaggccuuccuccuuccucuuccacagucuggcuucucacauugucacucuag\n", + "pcagaggauaccagcggcagaccacaggcapcagaggcacgucupuccccucccuccuuccuaucggcgacucccag\n", + "gcpccpcpcgcggcgcccagagcucapagacaaapaccgguuccucucuaggcgccaag\n", + "cuguucuaauaguccaccuaaaguaaagaaagcuccgapuaggaccuuccaaucagccaucuacaucagcucgugcccgucuuauugauccuggcuuuggaauauauaag\n", + "gaaggcugcggcggcgucpuacgcgcacacguugcaucuucuuccuuucgcpuccuccguaguucuggcacgagccaggcguacugacagguggaccagcggacugguggag\n", + "cuuucggaaggacugguaacuugucgugcggagcgaacggcggcggcggcggcggcggcggcaccauccaggcpcacc\n", + "aucacuuucugaguggauagaggaggcccgaagaagaugcuaccuaccagccucucucapcgcaggagapugguagagagaugcuuguugccccuggaaacugcaaguaccccccag\n", + "gacugguaacuugucgugcggagcgaacggcggcggcggcggcggcggcggcaccauccaggcpcacc\n", + "aaucacaauucuuggaagaggagaacuggacguugugaacagaguuagcugguaaauguccucuuaaaagauccaaaaa\n", + "gcacuaaucacaauucuuggaagaggagaacuggacguugugaacagaguuagcugguaaauguccucuuaaaagauccaaaaa\n", + "cuaguuucaacuuccuuuugcagcaaguucuuuccugcacuaaucacaauucuuggaagaggagaacuggacguugugaacagaguuagcugguaaauguccucuuaaaagauccaaaaa\n", + "ggaagaggagaacuggacguugugaacagaguuagcugguaaauguccucuuaaaagauccaaaaa\n", + "acaauucuuggaagaggagaacuggacguugugaacagaguuagcugguaaauguccucuuaaaagauccaaaaa\n", + "aauucuuggaagaggagaacuggacguugugaacagaguuagcugguaaauguccucuuaaaagauccaaaaa\n", + "cpucuuugacugaapuaggccaaguggagguaucapacgucgcgcggcacagaagaggaccagccuggacgccpacgcuguc\n", + "gucpcuguuuuccupcgaggagaaapccpccpccpcgcgguggcucacgccugucaucucagcacuuupaggccgaggcpcagaucaccugagacgaggacgcugag\n", + "caucccggaguuccuucccguccucccacaugcauccccugugcagagcugcgcuguugcupucapagcauggagugcacagcugaacagag\n", + "ggcucupcuccuucccccupccaccagcccuggcuuggaaccacagcaccugcccuccgugccuggagcugcucaggag\n", + "ugcgcpaggcpcgcupaggcggcgcggagccggcugagcgcapccgagcugcpcag\n", + "ggaaggugcccugagcucagcccuaaauaccugguacuaaagagucaguggcugcuucagaugccaccaga\n", + "gaccugaaggugcapuugccuggugcagguuccucupaugagguucugapcacccagccuggccuugcuccagaagccupcucugcgcacagap\n", + "ucauuucccaccccuggugupauuuppcuccupcagagugcgaagcuccggagccgaggccacuggauccccagugacugcucppucccgcugcguggag\n", + "guuggccccagccgcugguucccuguggcugcugcuggupcucupcuccuucccccupccaccagcccuggcuuggaaccacagcaccugcccuccgugccuggagcugcucaggag\n", + "accacagcaccugcccuccgugccuggagcugcucaggaggupaggugapcaggaggccacaacagccg\n", + "cucuucugccgucucagccupcgucgcugaagcugugucugcpaggcagcggaaggcggcag\n", + "gcuguuuuccupcgaggagaaapccpccpccpcgcgguggcucacgccugucaucucagcacuuupaggccgaggcpcagaucaccugagacgaggacgcugag\n", + "gugcgcgcuucucccgagguggaacpcggcagucaagcgccggcguucucugccgucacccuuuccuugccggccggcacuucggcugcagaguuuugcccacgcuucgagacuuapagcag\n", + "aapcpcupcucguggcugagccagcagcugcagcagcuacpaguggccpuggccggcpugccagccgcc\n", + "acgaapcpcupcucguggcugagccagcagcugcagcagcuacpaguggccpuggccggcpugccagccgcc\n", + "pcupcucguggcugagccagcagcugcagcagcuacpaguggccpuggccggcpugccagccgcc\n", + "ggccccggcuccgccccpccugcccapagagcggagcgguccgcagccpucpucpccccucccpaggagcguggagcggcggcggcggcggcggcag\n", + "gcucaggagaggccccggcuccgccccpccugcccapagagcggagcgguccgcagccpucpucpccccucccpaggagcguggagcggcggcggcggcggcggcag\n", + "cagaaaugauggaagaauugcauagccuggacccacgacggcaggaauuauuggaggccagguuuacuggaguagguguuaguaag\n", + "ggaccacuuaauagugagucuuccaaccagagcuugugcagcgucggauccuugagugauaaagaaguagag\n", + "acucccgagaaaaagcagaaugaccagcgaaaucggaaaagaaaagcugaaccauaugaaacuagccaag\n", + "uuugcupaagcgcgccaggaaccagcccuggcagaaguguuccaccaguugcacgauccucaccgcaacauuccuuauccaaucccuuaccg\n", + "cgacgaguagaacagccccucuaugguuuagauggcagugcugcaaaggaggcaacggaggagcagucugcucugccaacccuc\n", + "aaaugauggaagaauugcauagccuggacccacgacggcaggaauuauuggaggccagguuuacuggaguagguguuaguaag\n", + "guucagaauacagcugagcccagagauugcauggcaccaagagagguuucugucaagccgucccguuccgagaugccccaucgcaccaacgaagcaacugcugagcag\n", + "apagagcggagcgguccgcagccpucpucpccccucccpaggagcguggagcggcggcggcggcggcggcag\n", + "uagagacpuuucaccguguuagccaggauggucucgaucuccugaccucgugaucugcccaccuuggccucccaaagugcupauuacag\n", + "gaaugcugcaaggucucupagucaaacuauuuugauggcuauuuugacucugguaugguaugaaaag\n", + "cggcuccgccccpccugcccapagagcggagcgguccgcagccpucpucpccccucccpaggagcguggagcggcggcggcggcggcggcag\n", + "gugugacguuucuccagauacuucaugcuguucaccuguguccucgccgcaccacugccgcacacgacuccugaacc\n", + "guagcucaguuccaagaacacuuauugaugcuuacaccpccaagcccugugaupcccupuuccagag\n", + "aggaacauggcaacccgugugugucucaucccagaaagagaagacuuuaaccacugugaugccugagaauccaguga\n", + "gaacauggcaacccgugugugucucaucccagaaagagaagacuuuaaccacugugaugccugagaauccaguga\n", + "agauggugugcuuccagcugauaccaggagcagaaguuuugagaagagacuguuugucauguggauaguggaaagcccugcucucug\n", + "gaacauggcaacccgugugugucucaucccagaaagagaagacuuuaaccacugugaugccugagaaucca\n", + "agacagagucucacugcguugcccaggcuggucuugaacucuuggacucaagcaauccucccaccuuggccucccaaagagcaggaauuacag\n", + "ucccaaagacaccugucgagauccccaggaauugugucuaccaaccuaccuuccuaucagaagaggucucugcuacaucucccagacagcagc\n", + "gcugaagcgcugccgcugccgcuacugccgcugcapaaaaugcugagcccucccpccpupcggcggcggcgapcggcgacpacccgcuucccgagcgcggcggcggcggcc\n", + "uuugcuguuacacaggaagagagcaggcagcaucaguaucggcucagcauccuucccccuucuguucgauuagaag\n", + "cugaucgaagcaacagugccauaaagaaaupcuagauauuuccagaggcugcaaucuggaggcguuuggaggu\n", + "gacucucugauguuupagcagauccgagcagcugagcapuggcuguuccuuuccuggauuapcugaaucugupaaccagaccaccccugagacaggaggcagcccug\n", + "gagcgcgccgccupccaggcagccgagccguccgagcagcupcupagcapaacccggagcupaaucpagccpcgcpagcugcgcgaagccpcggagcacgcgagcu\n", + "ggccauauuagcagcgguuauucggugagcgguggugguuuauucuuccguggaguuaapcuccguggacaucucaggucuucapucuuccaucug\n", + "agugccaagccuggacgccpcccgcgapcpcugapupucugupcaggaccgagaguupuggcuuccguccucaggaguucg\n", + "ccacauuauaaucuaugacugccucucucaccuaacugccaguauuagcuuuucaggacaggaacugguuuuacacauuuug\n", + "gcgcaugcgcpccauauuagcagcgguuauucggugagcgguggugguuuauucuuccguggaguuaapcuccguggacaucucaggucuucapucuuccaucug\n", + "uuagcucucccggaggugccggugaacucaaaauagugcugugcccggcgucaggcguggagacaacagaaaguugugcuuaaagcucgaaucagaaauccccg\n", + "auauuagcagcgguuauucggugagcgguggugguuuauucuuccguggaguuaapcuccguggacaucucaggucuucapucuuccaucug\n", + "aucuaucuugcuguguuuggacaggccagccccugaaacaucuupcaauggapuuaacuucucaaaguuuaauaggcaagaccagcaaccaugcaacaag\n", + "aagauacucuauaaaugaugauucaaugaaugccaagcccuguucuaugcacugaagaccaaaagaaauaaaagacaucauuccugcucu\n", + "gacuucaacuaaccaacuaaagaacuguuccccagagcauuguuccugagaaggaaaagaguccaaacaccuacccacaccugcuuugugccaagaauccacaguuggauugcaaggacagu\n", + "gcguucaagacccagcuguugagaguagaaaagcagaagaaaggacccgaggucagcaagugcccuccccaca\n", + "gcguucaagacccagcuguugagaguagaaaagcagaagaaaggacccgaggucagcaagugcccuccccacaaupcagaucugccagcgagaaucg\n", + "cauuguugaugcucuugagagcaucagccaggacauuaaugugcaccacugugguggcguggaaag\n", + "aaaacaucuaucuugcuguguuuggacaggccagccccugaaacaucuupcaauggapuuaacuucucaaaguuuaauaggcaagaccagcaaccaugcaacaag\n", + "agaacuccagagapaaaacaucuaucuugcuguguuuggacaggccagccccugaaacaucuupcaauggapuuaacuucucaaaguuuaauaggcaagaccagcaaccaugcaacaag\n", + "gaggaggagccgccgagcagccgccggaggaccacggcucgccapcugcggaggaccgaccguccccacgccugccgccccgcgaccccgaccgccagc\n", + "aggccagccccugaaacaucuupcaauggapuuaacuucucaaaguuuaauaggcaagaccagcaaccaugcaacaag\n", + "gagccgccgagcagccgccggaggaccacggcucgccapcugcggaggaccgaccguccccacgccugccgccccgcgaccccgaccgccagc\n", + "cccgcucucaggcacugcuggagaaccgagaccgacuucuuucucuuuacccucauuggcgcuucucuccugcaguccgccucupcccugccg\n", + "gaaugaaaggaaacaaccuccggcgacagagccccgcucucaggcacugcuggagaaccgagaccgacuucuuucucuuuacccucauuggcgcuucucuccugcaguccgccucupcccugccg\n", + "ugcugucaaapaaaaccccccaaguaggugacagaguauugguugaagcuacuuauaauccuaau\n", + "ccaccggugucuccuucuacauccgccucugcgccggcugccacccgcgcucccuccgccgccgccgccuugcugcugcucaaagcugcugccgccccuupcuaaaag\n", + "cuguccccggcgauuccugcggacccagcugcggcgacgccaggagaccccaagcugcaucgccgagugg\n", + "auguggcaguuggagccccucgapaapagccauuuucuuuccugguuupaaagaguugcucaucaguuugcpagaagcuguuugccuucagcug\n", + "gagucccgaccucuacauguugugcupaaaugaagccugugauuuggacuccacagugucugcucuugcccuggcuuuuuaccuagcaaag\n", + "aaccguaacagccaccagacaagcuucaguggccggcccuucacauccagacuugccugagaggacccaccucugaguguccaguggucaguugccccagg\n", + "acaaccguaacagccaccagacaagcuucaguggccggcccuucacauccagacuugccugagaggacccaccucugaguguccaguggucaguugccccagg\n", + "augccacuguguacguppccuggaugagaagguuagugaaccgcugcugupaacuguuucuccaggcuggaccaguagucaacacccac\n", + "gacucugcccacuuccaccagagacacauugagaaggaggaaacuauggccuccaggcuuccgacggccugguccugu\n", + "aacaucagcuuuccaaaccagaugugguaucucaguuagaggaggcagaagauuucuggccaguggagagaggaauuccucaagacaccauuccag\n", + "aaucuggauuuuuaggaaccagugaccuuugaagauguaacacupuuuuaccccggaagagupacugcuggaccucaaacagaagucccuguacapaagug\n", + "cccagcguuagcccgcggccaggcagccpaggagcggcgcgcgcucggaccucucccgcccugcucguucgcucuccagcuup\n", + "agcccgcggccaggcagccpaggagcggcgcgcgcucggaccucucccgcccugcucguucgcucuccagcuup\n", + "aaggaaagaauauuuupcuaaaagagccccgugucuuugcugccugguaauuccugcacgcaucuuuuccuauuuugcaacgccauaggcuuccagcgacugcuggugauguuucug\n", + "gaaacggcccgagaagcucgcccggagaacpaggaauaugcuguggagcuccucugccauauaaacaaaaagag\n", + "cugagaagaaaaagacuguuuggcaagcuuaugucgauaggauaacugaauagcaaccugcugcucaucagccaau\n", + "cucuuacccggcucuacaaauuacugaaguccacugauagucccuccuucgugaagcauuccugaagaccccagccugacagaucuccccuuccucugaccuccuguauug\n", + "cucugagugaupccuacugcagagcccgccucccaccacagugcuggcccagaauuuuuuauacgaacuaguucguaacuaaacguuggaagcaucaccauauugccagugagaa\n", + "aucauucaacuucaaguggcacauuaucuuuuaagccuagucaaucauugauuacucuuccuacugcccaugug\n", + "agucuugcucuuucacccaggcuggagugcugugguguuaucucagcucacugcaguuucaagcuccupcucaagugaucuuaccucagccuucugaguagcupacuccag\n", + "accugagucagagccuaguccggcaugcugccuagcccagccacgucucauccuauucauggcagagcpacucucacccucucccagcaaugucuaaagucag\n", + "gcccaaggaucacucaugcuuccaggcugcacagagcacuguuggaucuagcugaacgaauuguuuucucugucucug\n", + "agacaaguucucacuacguugcccaggcuggugucaagcuccpccucaagcgauccucccaccucagccucccaaagcgcugaaauuacagacg\n", + "gaacuggagaucagccagaucacuuguaugcacaaagcugcuguggaucugucuuucaaacaagagcugcagaaaacgcuauagcaagguugaagcuuuauccacucug\n", + "acucaugcuuccaggcugcacagagcacuguuggaucuagcugaacgaauuguuuucucugucucug\n", + "auggaaucuuggaacgucucaugcuupaaggacauggucagauuuguuguaagaaagacugugcagaggaguguggcaaapauccagaagaugcaag\n", + "cagauggaaucuuggaacgucucaugcuupaaggacauggucagauuuguuguaagaaagacugugcagaggaguguggcaaapauccagaagaugcaagguauuauuuagaaaag\n", + "gcaguagcaugugacauggaaguuuauauuaucapugugcucaccugguugcaaauuugagaccaaaguuuuacuuuaacacuuggagcugguaaaggaug\n", + "cucuuccugucuguaccapcggcgcguggucuacgccgagugacagagacgcucaggcuguguucucag\n", + "gcggccucuuccugucuguaccapcggcgcguggucuacgccgagugacagagacgcucaggcuguguucucag\n", + "uaggcuaccuccgcgcuccacccagagacpucgcgcugcucccgccgccgcaaccccpcccucgugccggcggucuccccucuuccacpcgagauuacugcauagcagag\n", + "acagccccgccccgcacggccaggcgaagcggagccggccgugcgguguguguguauguguucgcpcgccgucucagccccpaag\n", + "cucucuugccugcagccauguaaguugugccuuugcuucuccuucaccuuccaccaugauugugaggccuccccagccauguggaauu\n", + "uuccuccuucacaggcucaugcucucucucucaccugccgccauguaagaugugccugcuucuccuucugccaugauuguaaguuuccugaggccuccccagccgugcaaaccu\n", + "acugcggaggaaagcuuuggacaugaaaccuauuuuuggcuucacuuuaaggaguggaacucuauuaaaagcugcgcugguguuuuuuug\n", + "agacagaaucgccuaagcugaaguguaguggcgccaucauagcucacugcagccuccagcuccuuggcucaagugauucuccugccugagccucccuaguagcuaggacuacag\n", + "gugcuauacguggaugaccugcuuaguuuuaauuuuuggagaaauacauuuuauaaaacauuuucaucagauugcuaaaauu\n", + "aaaagcaacugagcaaggagguuggauagguuguguggaggacagaugauaacuuuguuuuggaacac\n", + "gupaaaggauuguuuuccuguaaugaaguccaucuuguauuacugagucaaggaaacuauaaucaacauuugg\n", + "cuugccugcagccauguaaguugugccuuugcuucuccuucaccuuccaccaugauugugaggccuccccagccauguggaauu\n", + "gcuucuaacccuccuuuaugugacucagagaaaggagaccucauuccaaguuccaggauuaauucug\n", + "cagacagaaguuaaguaagaggcuuupucaagacugugacuggauucaaauccuaaaguuuucgcuacacugugugcugugg\n", + "uuccuccuucacaggcucaugcucucucucucaccugccgccauguaagaugugccugcuucuccuucugcc\n", + "ggcugucuucccggagacccgaccccggcagcgcpcggccgcuucuccugugccuccgcccgccgcuccacuccccgccgccgccgcgcgg\n", + "cagcgccpagaaccgaaccccuggcggccgcgaccccggcucccgccccggccccggcccgacccgcc\n", + "gcggcgugugcgccuccpcugcugauuagaauapacuuggccguggauggaauccpaaacccaaaccggagauggaaggaugaggcugcguuugcagcgcgugaaupacgcg\n", + "cgcgcucagacgccccagcuccgccgagaggccgcucgcgccpuccuuccucuuccccaagugcaggcagagcccccggagcc\n", + "gguucuauuucuuaaucuuggcuggaaccaaagaaguuguuaucugccgucugaucaagagagaacccauagucccugcauu\n", + "cccagcuccgccgagaggccgcucgcgccpuccuuccucuuccccaagugcaggcagagcccccggagcc\n", + "ugcugauuagaauapacuuggccguggauggaauccpaaacccaaaccggagauggaaggaugaggcugcguuugcagcgcgugaaupacgcg\n", + "agaugacuggagucauuuacauugcuagcacgupugccguuugcuguugccucggacuucucccgugcuguguuuucccggugaggaaacaggaggcacuuugcagccgaca\n", + "acucgcuuaccggaggcuucaguccccggcggcgcggcgacagcuapuucacggccacupcagaggagccgcgagaag\n", + "gccacguugauuguacpaaaagccuuuuuaaaacaucuuuuacguugcuuaaaccuacaguuucgaaagcauuccgaaggcuaaa\n", + "cuccugccapccauccaggugaccguguccaaccccuaccacguggugauccucuuccagccugugacccugcccuguaccuaccag\n", + "cuccugccgcgcggcgugagcgccpcucpcccccccggccgcccgcccccuccccucccucccuccccuccccuccccucccccccpccccgcgccccccccgcccccgcccccccc\n", + "agugaucgcugaccucccgccauguuccapcuguuugaaacacaggacagaaugcuacacgcagaaggaguccccacuccuguuaauugcagagaaugcaguaaaccccaagcacagca\n", + "guccuaacaacuuucuucaaccugaguguccucuaucuucacggcaacagcauccagcgccupaggugaauaagcuggcuguccuuccucggcuccguagccugacacucc\n", + "ggaguauuuccauuuuaaccggaaacaaucccugaacccacaggaaugaaugccuaaugguggaguuucagccaucagugacag\n", + "aguacuuauggcgccugccpuuguggugacgaaagcaguugccauggaguugcucugaguaacccugaggcagupacgccaagacuggagaggaagcgacugcgg\n", + "guccuaacaacuuucuucaaccugaguguccucuaucuucacggcaacagcauccagcgccupaggugaauaagcuggcuguccuuccucggcuccguagccugacacuccaupaacccc\n", + "aaagagcugguucccuggcaggcuggapcaggagcupccacgcuggucupauaguupcapag\n", + "cugguucccuggcaggcuggapcaggagcupccacgcuggucupauaguupcapag\n", + "acggagucucgaucugucacccaggcuggagugcaguggcacaaccuuggcucacugcaaccuccgccucccagguucaagugauucuccugccucagccuucugaguagcuggaauuacaa\n", + "gaagcuggacagagccgguuccuggaaagagcugguucccuggcaggcuggapcaggagcupccacgcuggucupauaguupcapag\n", + "gaaaaagcaggaaggcacggagucccucgccuucgcccuggcugcgcuguccccuucgcgcgcpaupuuugag\n", + "gcugccucgcucpugacgucagcgccccgguccccgccgcagccgcugcauccuccgugcccggccugagcuggagucccccgcgccccccgcguuccgcccggcc\n", + "gucagcgccccgguccccgccgcagccgcugcauccuccgugcccggccugagcuggagucccccgcgccccccgcguuccgcccggcc\n", + "gcpaauugaaaccgccgcugaagccaacaagaauuugagaacuguaaauaccaagccuugaaapacc\n", + "cugugugacguugaacaagucacuggaccucucuguuccucugcaaaacagcaugaaccaauucauuaacuacuucuccaggaugca\n", + "gaucucucucuguugcacaggauagagugcaguggcaagauuuuggcucacugcaaccucugccuccuguguugaagcaagcgauucucaugccucagccuccuaa\n", + "caaucugaguccccggccagccgaauccaagccguguguacugcgugcucagcacugcccgacaguccuagcuaaacuucgccaacuccgcugccuuugccgccaccaugcccaaaacg\n", + "cagucuuauagcuggaucagcuaccaagagaaguuguaaaccaagaagagaaaagcauuucaauuupacauuuauuugcaccuggaa\n", + "agcugcuuggagagcuaagcuggaapugcuuaucccugcguagaaacgccugccaaugcuuucucauuuggacccagacuccagaucpag\n", + "ucuuauagcuggaucagcuaccaagagaaguuguaaaccaagaagagaaaagcauuucaauuupacauuuauuugcaccuggaa\n", + "agagcugcuuggagagcuaagcuggaapugcuuaucccugcguagaaacgccugccaaugcuuucucauuuggacccagacuccagaucpag\n", + "gccaaaugaguccaacuuccuggaauuugucucccuguuagaauccauuaauacuuccaagaugacggcauccagucaacugaauggcucagcugagcagaaugaagaaagupcuucuccgag\n", + "paaauuagauccuguuauuuaaaaucuggaaaucagaaagaaggcccuuuacagccucuaccaucaaauaaugacugucucucucaggcucg\n", + "aacugaagacaucaaggagaauguacuggcgauuuuacucauuguccugguuucccuccuuggauuucugaccuugagccaaggcuuuugcaaagau\n", + "ccccgacugccugaaccgcgccaggagacggaccgcaaguccagcguacccacagacgacucaggcpagacgagcgguguc\n", + "acgugacgacuggccccgccucuuccucucggucccauauugaacucgaguuggaagaggcgaguccggucucaaa\n", + "aacagacuggcggcgcgcggaaaacgcgucacgugacgacuggccccgccucuuccucucggucccauauugaacucgaguuggaagaggcgaguccggucucaaa\n", + "gucucuugcugcagcuggugcuccaaaucuggucuuagcugcuucgugucuucuucuccagccucuguggcccugugaccugcagguauupagauccacagcugapacccccggaagccuagaa\n", + "guuucugguucuaccaaggaguaucugcuguuaugagcugguggaaaggcuaucacpauucuauuuacuauagaag\n", + "guuuuauugaaaacuacagcuggagauauugacauagaguugugguccaaagaagcuccuaaagcuugcagaaauuuuauccaacuuuguuuggaag\n", + "cuuauuaugacaauaccauuuuucauagaguugugccugguuucauaguccaaggcggagauccuacuggcacapagugguggagagucuaucuauggagcgccauucaaa\n", + "cggagcaccaaccccugcucggccccguaccaggaagcgcuppcagaggagcggaguugaggcagaagccag\n", + "guuuauuuucuugaaaaggcuccaggcuucggcuuggaaaaucccaccgccaaaauugagcccagcagcuggagcggcagugagagcccugccgaaaac\n", + "gagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "gugcaggagaacuccccagcccagcaggcpccuggagcccuacuuugacuucaucaucaccauupcacucgaggcug\n", + "aacaaggagaaugacacccugaaggcacuacugaaagccaauguggagaagcccgugaagcuggagguguucaau\n", + "ggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "acaaggcgcaggaaucgagcgccgagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "agagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "aggaaucgagcgccgagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "aaucgagcgccgagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "cgagcgccgagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "acuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "ggaaucgagcgccgagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "agcgccgagagagcgagucggugcuacuggcgucpucgguccpuaggcgcagcpacuggaccupugccgagcggagccgcugcc\n", + "uuucucgaggagcucuccupcggcugaagaaggagcuucuucuccggagugcgccggcgguggcgccugcggaccuaacuagcuccagguuaggccgagcuuugcpaaagcagcg\n", + "gcuucugcuuggcugccuaguccacagccucccgauucaccauucaccuggucccagcaacagaagucucagcuggacacacaacaugcuuuaga\n", + "guggaaucucacucugucacccaggaugcagugcacuggcguguucucggucucacuguaaccucugccaucupcucaagugauucuccugccucagccuccggaguagcupauuacag\n", + "cuuucucgaggagcucuccupcggcugaagaaggagcuucuucuccggagugcgccggcgguggcgccugcggaccuaacuagcuccag\n", + "caaacguguuugcggaaaggaguuupuuccaucuuuucauuuccccagcgcagcuuucuguag\n", + "guagguaaguucugucuuaccggugcaccggcgcacugaggaacagccgcagccgguguapcucauuguuagcgcuggucggugapupcgaggupcagcucggagccag\n", + "augcgacgcggcuaaacgagcuggapapaugucucacugccucagcpucuggccggupugaugcaggagguuuuguugaggaa\n", + "caugaacuugcugugcauaaaaagaaaauugaagaagucgaaaccugguuaaaagcucaaguuuuagaaaggcaaccaaaacag\n", + "cgagaggcucggcguugagcccpuapccagguggcugcccuuucaccuapuagucccuggucgccuccgcucuucgccuaaaapaugcagcuccpaaa\n", + "guaccuccgagaggcucggcguugagcccpuapccagguggcugcccuuucaccuapuagucccuggucgccuccgcucuucgccuaaaapaugcagcuccpaaa\n", + "gugaauuauaguuuaauguacugcaaguccuaaacuacggaupaacuauuacaguuuauaaugucaaaaacuuuucuuagaccaaagguaucuuccacaaag\n", + "agcccpuapccagguggcugcccuuucaccuapuagucccuggucgccuccgcucuucgccuaaaapaugcagcuccpaaa\n", + "accuccgagaggcucggcguugagcccpuapccagguggcugcccuuucaccuapuagucccuggucgccuccgcucuucgccuaaaapaugcagcuccpaaa\n", + "gcugcuggaaacgcaguuccgguuaggcggcugaguuuguuuacguugcuaacagaucuagccccugcuuucccuaguuccaguuccaag\n", + "auauagcuaauugaagauucucaucuuguguguaagcccaguuugcagcaaauguggacuaauuuuauauagcag\n", + "gugcuuuugaagaugaugauaucacgcacguugaaggaaguguagauccuauucgagauauagaaauaauacaugaagagcuucagcuuaaagaugaggaa\n", + "cuuccuccccgccuccagcugccggcaggaccuuucucucgcugccgcupaccccgugucaucgcccaggccgagcacg\n", + "caaaauuccugccuuucuaaaugugguggauauugcuggccuugugaaaggagcucacaaupcapccupaaugcuuuuuuaucucauauuagugccugugauggcaucuuucaucuaacac\n", + "gcugacagcaapcpucccugccgccgccuugucucgcgcapuccggcupuagcggagcccccagugcggcc\n", + "acagaagcgacgacgcaggacgaggaggaggacgaggaggaggaccuccccggcgcgcagcugccggcagcppaagag\n", + "gaauccaucccuuucacuuuuaacuugcaacaacaacaacaacaaaaaugugugaucuuuggauuuacaaaacuuuugagcuuuagagaaapaaagaggaagaagugaaa\n", + "agcuccccpcccccugcccggccpcgcugacagcaapcpucccugccgccgccuugucucgcgcapuccggcupuagcggagcccccagugcggcc\n", + "auucauuacccuucccuggaucupcuuucggaaucucgaccuccccuuggccuaucuccugcagaaaaauuagg\n", + "uguguccupacucugaauggccugagugugaccggcgaugcugagaaccaauaccagacacuguacaagcucuacgagaggugugagguggug\n", + "cagccaccaauucgccagcgguucagguggcucuugccucgauguccuagccuapcccccpccggacuuggcupcucccuucacccucugcggaguc\n", + "aauucgccagcgguucagguggcucuugccucgauguccuagccuapcccccpccggacuuggcupcucccuucacccucugcggaguc\n", + "uacaacaguguauaaacaaggaaaccaaggaagauuuuucuccuucagaacucggacccugaauaccagguugagcuggagcuga\n", + "uuaaccccuuaguacccaaaagaagcacagapucccagguugaaaaaggaaaucuuuucaccuucccauucauggaaug\n", + "gucuggcguauucugacaggacacagugagcaucuguagaggagaggcuugaaauaaaggaggagcacgaauauucccuggauuucuggag\n", + "gccugcuuuaaggcuggccaguucugcaagaaaggcaaggaggaggagacuggcucacaccucuggag\n", + "gacccccuucugucagcugupcuugacacuacuugaacaagaaaaggapaaacugcaccacauaagugaag\n", + "gucuuugccauucggaucgcupaaagcggupaauccaacugaagagcagccagaggagagcugaagagaggapaggccgaugaccupcucupccucugaag\n", + "ggaguauapcuugaacugagagccuggccucccagaagguuuuaauagaccuacggcacagaaauugacacagccc\n", + "ggaaaaggcccacaaagagaagcccaaccagccagcccccaggccgccccgccapacccaccaaugaggcacag\n", + "auuuucuuccgguggcuggucuccggcggccccguccccgacupccccgugcccccccgcccccgcggccccccgccgccpccagccgccacc\n", + "cuccaugcggacagcugugaggcccccggagaaagccacagagagaaaaugcuuucagcupugucaagaacuuuucaagaguggcagcuguugaaaucaaaagaguggccacagaag\n", + "gguacupcuggcugcgguggcgcgcpcgcggcacccggaagucggcggcgguggcggaggcg\n", + "accucgcgaccugugucagcagagccgcccugcaccaccaugugcaucaucuucuuuaaguuugauccucgcccuguuuccaaaaacgcguacag\n", + "gcucaucuuggcagccaacapaugaauucuacagccgacccuccaaguuagcugacuucupaacaacaacgagauccucagug\n", + "cggaggcggugagugcgcggcuccpcuggccgacuccgcuaguggcccggccggccupcucpcuccpcucupcucupugcgcggaccpccaggcugcuugaag\n", + "gugcgcggcuccpcuggccgacuccgcuaguggcccggccggccupcucpcuccpcucupcucupugcgcggaccpccaggcugcuugaag\n", + "gcaggcugcugucucacagagcgagaaggugucaggagcagcccaguugugucucucucucuaccucugugaapcgcga\n", + "gccauagcaggcugcugucucacagagcgagaaggugucaggagcagcccaguugugucucucucucuaccucugugaapcgcga\n", + "guccuagccgugagugccccgccugccccuagcggucccuggcgucccgguuccugucgcgcucaccugcgccgguagcgaagaaaucgccccpac\n", + "ccagugagcuccuccgacagcgaggcccccgaggccaaccccgccgacggcagugacgcugacgaggacgaugaggaccppuc\n", + "aucgacgacaucgcggauggcgccgugaagcccccacccaacaaguaccccaucuuuuucuuuggcacacacgaaac\n", + "aggcupccggupagapaggcgagccgaccgcupcugcupcucccgcgcccucgcgcuccccgccgccagcccaggcgcaggcapcgcaggcggcggcpcggc\n", + "gaaugagaccgugcugcaccaguucugcugcccagccgccgacgccugcuccgaccuggccucccaaag\n", + "ggacagagaucapaaauaaaggcagaaggcagugagapaggcuaugccugcugcuuggauucucupcucacucccacagug\n", + "uuggcagcuaucgcuguuuguagcugcaucaugcccaugugcuuucuuuccgcccaggaugugaagccgguagagaaauaaagcaucgccccucugcgcgccccuccccgucugcuaga\n", + "uucuucucuuccccggcagcacaguguggcuguuugucuccuugcccgccaaaguucugcccaguccaacgacuccacgcagcucgcccuug\n", + "guuggagugcaauggcauuaucuuggcucacuguaaccucaaacuucupcugaagcgauccuccucccucagccuccugaguagcuaggacuacag\n", + "uuaacuuuaugaagugcaucauaaaacaacguuuuauuugaaguugcugauacggaauucagaupaggaccaauucuucuuggcuacuauuaaauacuuuugaauaucaaaucucag\n", + "acucgaucagcccgccggcuccggagcggcucugccuucccgagcgcpacgcggcgcccupaggapcgaagcgacgcggcg\n", + "auuccaguuuggaauuauaaagaugcuaugaacauucuuuuucuucaacaucuguuuuguggacaucuaguuugauuccuguuggauaaauacuuaug\n", + "caagaaguugagaaguuuacagaccuagagaaacucuaccucuaccuucagcugccuucuggucucagcaauggagagaaaag\n", + "cccccucpugaauuguuuauaagcuaccuagauacuuaccuguaucucaucaauaauaaaaucacaaucugag\n", + "agcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "pagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "auggaguccugcucuguugcccaggcuggagugcaguggcauaaucuuggcucagugaaaccuuugccucccag\n", + "agaaaucuuaaaguagaagcgucacaggacuuguucuuccaaaugcugcauggcaaauauuauuaggaaauauacuuaacauuuauuuauuuuuauucucaau\n", + "guuggugcacacagccaucuggucgaccuuagacacpaaggcaagcacccccugguugaccuuagacauggaaag\n", + "gcgcccgacacccpaggccccgccagcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "gcccgacacccpaggccccgccagcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "augaauuuacaaccaauuuucuggauuggacugaucaguucaguuugcuguguguuugcucaaacag\n", + "augaaaauagauguuuaaaagcaaaugccaaaucauguggagaauguauacaagcapccaaauugupuggugcacaaauuca\n", + "auguuuaaaagcaaaugccaaaucauguggagaauguauacaagcapccaaauugupuggugcacaaauuca\n", + "gacacccpaggccccgccagcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "auuuucuauaagaagcauaugcugguuuuauaaucucagaaaagauacguuggagacagucuguauuagcgcuuaccauguagaaggcauacucuuccuuag\n", + "ccgccagcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "aaugaaaaguggucaaacaacuuaacauggugccaguuuuccuaagcgugcuugccacugauuguaaugcuuuuauuguuuggcuucuugauaa\n", + "gccagcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "ggagccgccgccacccgccgcgcccgacacccpaggccccgccagcccgcpagaggcccagcpagucgcggaacagcaggcccgagcccaccgcgccpccccggacgccgcgcggaaaag\n", + "ggaaaggcaaaaaaguccgcaggcauagagaguggaaagaaggaacagcauacuaggcugguuugaaaaacaaucaauugcuag\n", + "auaagauuugugaccaaaucagugaugcuguccuugaugcccaccuucagcaggauccugaugccaaaguagcuugug\n", + "guucgcuccgcgccgcccgccugcuacgaguagaacgcuguccgcagcuugcgcauuucgcagccgcugccgccucgccgcugcuccuucguaaggccacuuccgcacaccgacaccaac\n", + "agugcugccugucacaccugagccagcaguuugugcaaccagaggagcgcaggcapuucccugcupcccpcugcccagcc\n", + "ugagccagcaguuugugcaaccagaggagcgcaggcapuucccugcupcccpcugcccagcc\n", + "gccucuccggauucuguuaacgguagugguggcuuguupauccguugagugaupagagugugcucuuuaacuucggagagag\n", + "uucacugaguucacuaaagacaaccuacagcugucacugucugcapaugaaaaaaaaucguuuuauuuccaagcaacauua\n", + "gcugguuuauuaagccucucaaagaaacgaccacuucugugcgcuaucaucaaaguauacgguggaaacugguauccgaa\n", + "agagcucacagccuccugccagcgcgcucucuguuucucugcagccccgaagcucgcgaauguagcaggcgccccaagcucgguccucaagaagcc\n", + "ugucuauauugacaaaaguccaaagacuuguugagccagcuaacupcuuuuuacaauggcuuuucaagauugcagaugccgccuacagagacgacagucauauuugag\n", + "gcpcccagcgagcggacgccpcgcggcggcgcgcggagaagugcggcggagcggcgccugcauuagcag\n", + "pcuccguucccggccucuucpacgcacgguuggaaguuguaccgugacgugauggucagaucggaugauagaauuuug\n", + "ggaacaacaauagcagaggccuuuguugcccucuccgcgaaacugcccaguaaccuggcauuagacpucccuggcugaccugauaaagaag\n", + "cucuacaauuccguguccaguccuggucacccauagucuuccaaaauccagcaagaaaaauccuucucagaaaggucucca\n", + "cccagagccagcagagcaggcugacgaccugcaagccacaguggcugcccugugcgugcugcgaggupacccupcaggaagcuggcugagccccaagaccccpcc\n", + "agagccagcagagcaggcugacgaccugcaagccacaguggcugcccugugcgugcugcgaggupacccupcaggaagcuggcugagccccaagaccccpcc\n", + "gugaaaauggugaucccaaagccuucuuaauagagauuuccuggacagaaacauauccccaaacaccuccaauucuaucu\n", + "aucaucagcuguaaagcagaguauauuagccaagcuacaggaagcaguagaagcuaaucuuggaaccgcu\n", + "gcaggauucugcuuucccuuggacuguaucacucaggacucugaauauucccugaaauaggaggaaaa\n", + "augcaaauaggcuucccaguugauuggcccaucuugccagcuucuuacugugcacguggcugacaaagagaapaagauggagccgccaucuuuaacaugauuggcacaacugcug\n", + "uuuccuaaauguugaggcuguuaaaaacaauauuacugaaguuugaaauuuggugguagcaaggagaucuaucaguauuuuuaaaaacaaacu\n", + "guggcagcpagcagcugcgccgccagcguggagcpaggcgugupuguggagaaaapagcgccagaccggaacgg\n", + "agapagguggcgauggugcgcccgguggcgguggcggcggcgguugcggaggcuuccuuggucggauugcaacgaggagaagaugacugaccaaccgacuggcugaauga\n", + "acugugaccaagccucucacccgccauccaggugccccugagccgaggaacgcaggcgguggucgupaapaagaggagccccpagacgacagcagc\n", + "aggugccccugagccgaggaacgcaggcgguggucgupaapaagaggagccccpagacgacagcagc\n", + "agccgaggaacgcaggcgguggucgupaapaagaggagccccpagacgacagcagcaupupcggccuucgagcccucuggacaagcagcagcggcagcaccuaap\n", + "aagcugccccgaguccgugagcaccgaggaccccugacccagcuucpccacccaccccgguggcagccgaucuucuguguucugcgupacggccgccuagagugguucagccacaaggag\n", + "gaauaugaaaacpccacugccuuggcucaacagcccugacaggauacacgcuccugacuucccagcgagaauaucuccgccuuuuggaugcucucugcccugaauccuugg\n", + "uccugcagcgaagccaggccccugcugcccpccuuccuggacgccguccgacucuaccggcagcaccaaggccacuuuggcgacgacgacgugacccuaggcucagacgccgag\n", + "cagcgcgcpcgcgcggcuggagccggcgccpcacggcaucpccuggacugcacggcccggcagcag\n", + "guucugccaccagcuggauuucuccaccagcpcgcugugcguggcccuaaacaaggcagccgccggcagcgcguacaggugcuucaaggagcggcgcgugaccaaggcuuaccuggcauug\n", + "cugcpcacauccaggagagccpuaaccaucagccaugccauuggcaggaacagcacggapccpcccacacc\n", + "gcggaagcgcugccaggcguccggagcggagcuuccapucucupucgccagcgcgcpcgcgcggcuggagccggcgccpcacggcaucpccuggacugcacggcccggcagcag\n", + "caaggcguggcpagacucugacccugcagaagcagcugcgguaccgcuuucccgagcuggccgacccugacaccugcuacpuucag\n", + "gucgccagcgcgcpcgcgcggcuggagccggcgccpcacggcaucpccuggacugcacggcccggcagcag\n", + "cucupucgccagcgcgcpcgcgcggcuggagccggcgccpcacggcaucpccuggacugcacggcccggcagcag\n", + "ugccaggcguccggagcggagcuuccapucucupucgccagcgcgcpcgcgcggcuggagccggcgccpcacggcaucpccuggacugcacggcccggcagcag\n", + "ucgccagcgcgcpcgcgcggcuggagccggcgccpcacggcaucpccuggacugcacggcccggcagcag\n", + "paagacuuuaacuapcgcgcagaugugugaggccuuuuauugugagaguggacagacauccgagauuucag\n", + "cuggaggaugaugacagaggucaggcuucgcuaaupccagugaggagcgguggaggcgaggccpcgccggcacacacacauuaacacacuugagccaucaccaaucagcauaggu\n", + "ggugcauuugcauguugcggagugauuagupuuugaaaapaaccguggcucggccucauuucccgcucugguucaggcgcaggaggaaguguuuugcuggaggaugaugacagag\n", + "gcgucaauuuaucaguaggcuccaaggagaagagaggagaggagaggagagcugaacapagccacgucuuuuccupapcugcuaucuaagucpcugcag\n", + "cacaggcuuaaggapuccccagcaccuuauccaucuguuuuggaaacgccggucgcccccuggugcuuccpcug\n", + "apcggaggcaccapaaaggcacuugaaugaagaaggaaaaugagaaccagauuguaacuucguccuaauccaccugccagaacuuuccuucag\n", + "gaacgcggcugucagaucugccacuuccccugccgagcggcggugagaagugupaaccggcgcugccaggcucaccugccuccccgcccuccgcucccag\n", + "uuuaacuapcgcgcagaugugugaggccuuuuauugugagaguggacagacauccgagauuucag\n", + "guguccaacggaugugugaguaaaauucupcagguauuacgagacuggcuccaucagacccapcaaucggugguaguaaaccgagaguagcgacuccagaaguu\n", + "auggcugccagcaacaggaaggapagagaauaccaacuccaucaguuccaacggagaagauucagaugaggcucaa\n", + "gcacuuagucaacaaauggcacgupagaaguuggugaguguuuggugaggacucuucapcuuuucacaagaacccucuguacacaaa\n", + "aaaaagaagacacgacugauaacaucugagaggaaggaaacugcauugugcupaucugcaugucacauuauaaaaagcaauuuuuuuuuuuaauagaaccagccuuucaaacaguuuccagag\n", + "auaguuuugaggcagcugugccaucaaauagccacauuguuucggaaccuggaaagaaugucacacucacuugucagccucag\n", + "gacaaccaauugaaaacagcucaaccuuucaggauagaggauggagcuaaccuguagagaacuaaaugaugguuguuaugcaaag\n", + "gagucggcpcggcgaggagcgcggagccggagcuggacgccgccgccgccaccgccaccugcgcggcagucaucaag\n", + "ggagucapagcagcagccucccacaggaugugagagaggaacupucuccagucacpagccaggagccggccapccgcaggcaggaapagcgaggcugaapaac\n", + "gucccuacacucugcapccugcupcugugaacupcccugacaacaccucggugcccaccgccaaguucgcccugaacggcgaggaguuc\n", + "agccuaucaagugucuguaauuaauuaaccaacugagauccaguucapugaaaguucuucag\n", + "aggaugugagagaggaacupucuccagucacpagccaggagccggccapccgcaggcaggaapagcgaggcugaapaac\n", + "ggaugugagagaggaacupucuccagucacpagccaggagccggccapccgcaggcaggaapagcgaggcugaapaac\n", + "ggacuccccgcgaaaaaccpcgcccaggccupaacgcagcgagcagcgccggccpcagacucucaccagugcgcaugcguggcucuccggcaccg\n", + "gacuccccgcgaaaaaccpcgcccaggccupaacgcagcgagcagcgccggccpcagacucucaccagugcgcaugcguggcucuccggcaccgguccguacuccagcgag\n", + "pacuccccgcgaaaaaccpcgcccaggccupaacgcagcgagcagcgccggccpcagacucucaccagugcgcaugcguggcucuccggcaccgguccguacuccagcgag\n", + "cgagguacuaggcagagccguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "gapcgugcgcgugcgcaggcgacgcgccgagguacuaggcagagccguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "gcaggcgacgcgccgagguacuaggcagagccguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "aggcgacgcgccgagguacuaggcagagccguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "ugcgcaggcgacgcgccgagguacuaggcagagccguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "cguggaaccgccgccaggucgcuguugguccacgccgcccgucgcgccgcccgcccgcucagcguccgccgccgcc\n", + "ccgcccgcccacgccccccacccpappagagaggcaaaaaguaagagaggaaaaaaaauagcaggaag\n", + "accaugaguapuguugaugaugaaguuggaagauuugugaauuuauccuguguuacuucupauucagaaugcucagugcuggcauggaggaacucacauc\n", + "cuccuaguauugcauccuacagaugugcuguaaacaucaaaagaagacggupaucaggagaug\n", + "aucugaacugaugucacagcaucaugcagcaggucaaacaaggcaucuccuaguauugcauccuacagaugugcuguaaacaucaaaagaagacggupaucaggagaug\n", + "aauuuauggccgaguuugguuuugcuguuuuggacugucucaacucccugcugaugccaccauacagagucagaucag\n", + "uaccaaaaguuuuucacguguaaugaaagaaaauuaaucucacuugaaacucauuuucuuaaaauaucguugauauag\n", + "cagcucucpugcggagcccggcpcuaggcgaggcgcpcuggccccgccccucaggccggcgaguccccuucucagagacuuggcuaggcgcggcgcgaggcpcgcupcgg\n", + "cuuucaaacccggccggcccgaguggagucagcucagucccggcagccgccgcgcgaggaaauggccgapccggagccacag\n", + "guguuggagcpccggagagaaguagagupcugcgaggagaaggaaacaggccuuucggaggcuccucaucccucggaggucaucccuuacuccag\n", + "aagugcpacccgcccpugugucpuacucggccggaggcggccggugagugaggcuuacapccccpaccaag\n", + "guucauagguggaagaaauucaucuccagaugagacuuuggacuuggacuupacuuuugaguuaaugccagaaugau\n", + "gaaccccagcauguuaauugaacuugaucacccaguugaaggaagaauaauaguagauguuggaucuucaggaagcugaagapcagugcccagaaauaccugucuug\n", + "auapauuugagcugaaccaaagcaucaacaccaaucagacuguuuccgaagaacuagaguuuucupucagca\n", + "acagccgcgagauuccgcgcupuacggucgcugauggccuccaacugcucccgauaauacagg\n", + "gagguguccaggcggaggcaguuccugcpagcaugcggcccccuucuccgccuuccucacagacagcuucggccggcagcacagcuaccugcggaucucccucacagagaagugcaaccucagau\n", + "acggagucucgcucugucacccaggcuggagugcaauggcgugaucuuggcucacugcaaccucugccuucupuucaagugauucuccugccucagccucccaaguagcupauuacag\n", + "agcugagcuaggagugapaugugagccacccccgcuuggcaccccgguggaucugguaacaaa\n", + "auaguguuuuuagaagaagcaucucaacaggaaaaacuggccaaagaauggugcuucaagccgugugaaauaagagaacugagccacca\n", + "aggacaaggccggagccuguguccgcccggcagccgcccgcagcugcagagagucccgcugcgucuccgccgcgugcgcccuccucgaccagcagacccgcgcugcgcuccgccgcugac\n", + "gcccgcagcugcagagagucccgcugcgucuccgccgcgugcgcccuccucgaccagcagacccgcgcugcgcuccgccgcugac\n", + "gaccccggcaagcccgcgcacuuggcaggagcuguagcuaccgccguccgcgccuccaagguuucacggcuuccucagcagagacucpcucguccgcc\n", + "acuuggcaggagcuguagcuaccgccguccgcgccuccaagguuucacggcuuccucagcagagacucpcucguccgcc\n", + "cggcaagcccgcgcacuuggcaggagcuguagcuaccgccguccgcgccuccaagguuucacggcuuccucagcagagacucpcucguccgcc\n", + "agcuaccgccguccgcgccuccaagguuucacggcuuccucagcagagacucpcucguccgccauguccgccgcagacgagguugacpcupcguggcccggccgcacuauggcu\n", + "gcgacuggccuccacuuuagacacacugauaaugugauucagugguugaaugccauggaugagauuggauugccuaag\n", + "cuggcuucpcggcggccccggcggccuguggacggacpupccgagguacaggccccacggccgccgucucccgcuucugcccgcgcagaguccgcgcc\n", + "aguacuuccuguucucggcuaacccuggcgcupccpcuggagagugaccguggucugagugaccupcggcugcgupccp\n", + "aguugccacuaggagaggcggugcuggcupucacaguccapcugcccgapapcuagg\n", + "cauucccagccaguugccacuaggagaggcggugcuggcupucacaguccapcugcccgapapcuagg\n", + "auuuccuuaaauucapuccagcucacaupaaauacuuucugagaguccuggaccuccugugcaagaac\n", + "aaaggagucagagcuccuuuccucucuggucucugccuccuuccugccaggcucuuucucuugccugcuucucuggaugcuccagcaaac\n", + "cggcgaggcpapccccggacuccgacggcggcucggacgccgacucggaggupuccpagcccgacucggaccgcggag\n", + "ggacuccgacggcggcucggacgccgacucggaggupuccpagcccgacucggaccgcggag\n", + "cucggaccgcggaggugagcpagcugaggcugaggagapagcuuppcgccugcugccaagg\n", + "aaucgcgccgcugagaggcacgcgcagccggugccuagccgguuggucccugcgccccugccccgccggccaccgcccccccacaccgucccggccccggcagccuggccccacc\n", + "ggcccpugacuccagcggaggagcucupacacccuugucuapaagaggucuuacuggcugcccucaccugacuuuguguccccaggcccccagcc\n", + "cugcagccucaggcccpugacuccagcggaggagcucupacacccuugucuapaagaggucuuacuggcugcccucaccugacuuuguguccccaggcccccagcc\n", + "gaugauuacggagcuguguggacugugcccugacaggagaaauagcagugcugcccaggaucaca\n", + "gcucaccccgagguggcugaggcuggaauupugccccuuugcaggugucggcugcuccuucaag\n", + "ggaagcccacagucugugcaagagcaugaggucaccucccagaccucccaccuaaaccugcuguupuuc\n", + "gcggcgcpauccupaaggcugcagagcuagagcagcgccgcccgapcggcapcugaccacagagagcgcpccuccagccgagaggaapapcagcucpccg\n", + "aagucguuggcuucguaagagcapucuaupaagccuccucagcgupuucuuggaagagguggag\n", + "gaaauccuuuuguacuauugcucauucauacuuguucaucaaagccuggaguccuuaaggacagaauuuaccucuaaacagaaag\n", + "agagagcgcpccuccagccgagaggaapapcagcucpccgguagupacccuupacagag\n", + "gaaauccuuuuguacuauugcucauucauacuuguucaucaaagccuggaguccuuaaggacagaauuuaccucuaaacagaaagauggaaacuaaaguacauuuauucugccag\n", + "auuugaaacaucaauaaucuuuuguggagaagaaaaguccucugauuuuucaggagaaaaaaaaguupagaaagaguuuacaaguacaacagcacaguaaaagaacugag\n", + "ccaguuccuccupaaugcaacccaucuccgaaaaggauuaagcaucacuapcuccaagugaguucugaucagaggcuguucggaagacagcapcc\n", + "guugaucgccgcgcucgccccggccacggcgccgccccuguucucccggccccgcuccaccpcugacggacugacggccagcacagccggcuccpaugagcgcacggacgg\n", + "uauucugaagucucaggaaacuggaccauuuaaaugugcauggcccaugagaaaggcuuauaagaagcc\n", + "gcuggagugccguggcaagaucucggcucacugcaaccucugccucccagauucaagcgauucuccuaccucagccucccag\n", + "gaucaaacagagcauacugaaucagcaggacuggcugguggugcagcagacaucaugaguaagcaccgagaagucuguuccuuaucacguguguaapaaaaag\n", + "accauuuugcucgapcauggccuaagccggucagcuaaggccauguuaauacpcugucccaucucucugcpcgcgacagcuggaagagccgaacggauaagagaagaggag\n", + "aguucugccgagaucgcagaauacacacaagcuaccuuupcaccagagcagacagaaccgcggagcuucapuggaagauucguggaaacuuugccaa\n", + "acuuggupagucgcucaagagagcaagauguucucguguugcuuccccacuucgagagguugcugcuucaggaauggapagugagagccuuuuccgacg\n", + "aguccuggcugaaguagccupacaggacagcagcpaacagaaggacpcaggaggacagag\n", + "cugcugacaagcucuguggcuccccaggagaacugucccaaggcccapcucuggucugcugaggu\n", + "gupuccgauggcucccggcucuaugacugcguguggagguacaacucaagcgugaaugagupcggagguggcgccc\n", + "cpccucpagccgaccccgguccgappccuaaaacuccucgagagcaaccggagccapcpcggcggcucggaccgcguccccpcpaaaga\n", + "acuagcgcggcggccgccggcccgcaauggugcuacccugguugcugcucgagacugcgcgcapcgguccucpuccgcggaggcugcgcucugcg\n", + "aggccagaccaggagcugaccpagcupccacpccuaggagcacccuggucapcuaaggcc\n", + "agaucaccccugaccugcuaccucggccgccccgguugcuucuauuggucaaucccuuupucpccuggccuggcagugguguaagaaccacgugcuuccc\n", + "paacaaaggugagcgaaaggaggaggcagaauccpcagapcapagapccugupaapaccucaguccugcucccacccgcucccuggagagcaggcggccagacacccag\n", + "agcugaaggucaggccaggacagugagaccugacuccuugcuccuaccagccuacuauggcuuaagacccapccapucccguugauguaacagagcagaggaccagcag\n", + "guagcuagcacgaugcgucgcgcggugacgcucuggcccgacgccgacggccucucaguggcucccggaggacccggcpcccaguguuggag\n", + "gagcggaugcacacccuccccccaccccuaggucugaupcuguuggugcugacuugcpaccgccuggaggaggacccggcgugugaggagg\n", + "agcuagcacgaugcgucgcgcggugacgcucuggcccgacgccgacggccucucaguggcucccggaggacccggcpcccaguguuggag\n", + "guucggccpagcgcapcggcagugcgcgccuagcagugucccagccpuucgugucgcc\n", + "puucggccpagcgcapcggcagugcgcgccuagcagugucccagccpuucgugucgcc\n", + "gcpuucggccpagcgcapcggcagugcgcgccuagcagugucccagccpuucgugucgcc\n", + "cugcugcugcugcgccccauccccccgcggccggccaguuccagcccgcaccccgcgucggugcccgcgccccuccccpccccgcc\n", + "gccuccuccugcugcugcugcgccccauccccccgcggccggccaguuccagcccgcaccccgcgucggugcccgcgccccuccccpccccgcc\n", + "gcauaugaugcugagcuggcugcuccagaaugaaccacagcucugagaapaaguagaaacagcuggcgcccugcc\n", + "aauacgaugguguccccgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccugaupagagcaugaacaggug\n", + "cccucaaaacupuugaggugagcaaggaggcagcucapacaaauuucuacucccaucucaucucucuuccuuagaagcccuuggagaccagcucuuccaaagucaaag\n", + "aagaugcagagguugaugaaggcacagcccauggagauguggaaguagaapaagaguuugcucugcacuaguccgaag\n", + "pcggaacuaaaaugccggccacaccccucucugugacucagucucugagcguuuuaauacgaugguguccccgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccug\n", + "cgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccugaupagagcaugaacaggugguaugug\n", + "aauacgaugguguccccgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccug\n", + "gacucagucucugagcguuuuaauacgaugguguccccgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccug\n", + "gcguuuuaauacgaugguguccccgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccugaupagagcaugaacag\n", + "acaccccucucugugacucagucucugagcguuuuaauacgaugguguccccgcpaucaaacuucagcgucacagcugaggacuggcuucguggucccug\n", + "gagcuggaggaucuucagaagaagccucccccauaccugcggaaccuguccagcgaugaugccaauguccugguguggcacgcucuccuccuaccc\n", + "gaccaaccucccuaccaccugaaagccuucaaccugcgcaucagcuucccgccggaguauccguucaagccuccc\n", + "cggacuuggagucagagagaccuggcugcgaaucccggcuccgccacuuucuagcgcugugaccuugg\n", + "uuuucagguggcgaaacugacuggucugguuagagcgcguccaagccaagccgcagugcuguuuggauuuuuaaauuucuccuucugagugagaaaauagcaaucgag\n", + "gcaccgcugagcugccgagaggaagcucgcucugcccggcugcccucuuguaguccgccggcgapcaguucucggugaggaggaagagagcagcggacggcacagcacccgcgcpcccucc\n", + "gagucccugcuucgcagagcaccggacuuggagucagagagaccuggcugcgaaucccggcuccgccacuuucuagcgcugugaccuugg\n", + "cacaacagcuccagcuggcagcaucacuucccgccaauuuauccaacuucugccaaggcucugaa\n", + "agcaccggacuuggagucagagagaccuggcugcgaaucccggcuccgccacuuucuagcgcugugaccuugg\n", + "uguuugagaggapuagcupapcagcaggagaugccaggaacagcuuccccuagcacagcacagacuacagacapagccucupcugcagacacugcagacggacggacagacag\n", + "gcagaaguagagcagaagaagaagcggaccuuccgcaaguucaccuaccgcggcguggaccucgaccagcugcuggacauguccu\n", + "gcagaaguagagcagaagaagaagcggaccuuccgcaaguucaccuaccgcggcguggaccucgaccagcugcuggacauguccua\n", + "aggccuuuggcccgagcuguacgcugcagcaccuugucugaggcuguggucuccpccgcuuguucucucugaaucucugcagucacacgguggcucuugcaugugap\n", + "caugccggcagucucgcgauaacugcgcaggcgcggaccaaagcgaucucuucugaggauccggcaagaug\n", + "aaguagagcagaagaagaagcggaccuuccgcaaguucaccuaccgcggcguggaccucgaccagcugcuggac\n", + "aauaaaugauucccacugauccacccacuuuugccaccccaggaugcaauuuucuggagagaagauuagug\n", + "agcuuacaauugagacugcuaaccccuaccuuugaapaucaacggauuguuguugaaacaacauuuaguucagaauccagucagacucuggcaacuuuuag\n", + "gugguacuuucuauuuuaacaccucaagguugaagcagaagaauaaggagaaggauaagucgaapaaggcgccugaagaggacgaag\n", + "gccaaagccugguagaagaugucccuguagagcagccccapaapauucaagaagcuauaaaugccucupcucaccugaauguguuugacug\n", + "aguacuggaugugacagcaggcagaggagcacuuagcagcuuauucaguguccgauucugauuccggcaaggauccaagc\n", + "auuuaaucuggccaaagccugguagaagaugucccuguagagcagccccapaapauucaagaagcuauaaaugccucupcucaccugaauguguuugacug\n", + "guuagcaccaguacuggaugugacagcaggcagaggagcacuuagcagcuuauucaguguccgauucugauuccggcaaggauccaagc\n", + "gcgcggcccagacggcagaggucucugcggcgcgguccucggagacacgcggcgguguccuguguuggcc\n", + "ggcccagacggcagaggucucugcggcgcgguccucggagacacgcggcgguguccuguguuggcc\n", + "auauuggcgcggcccagacggcagaggucucugcggcgcgguccucggagacacgcggcgguguccuguguuggcc\n", + "gccguuucuccgcgccgcuguuggugcugccgcugccuccuccuccuccgccgccgccgccgccgccgccgccuccuccggcucuucgcucggccccucuccgccucc\n", + "gcgucuguagaggcuucuggugaaaucgcauuaugcaagacuggauuuccugaagauguuuacagugcagucuuaucgaaggaugugcaugaaggacagccucuucucaaug\n", + "ugaaguuuagcaacugcaauggaaaaagaaaaguacaauaugagagcagugagccugcagauuuuaagguggaugaagauggc\n", + "pagagcggcggcggcucgcccaggucgcgcagcggaggccgagcpugcgcggucggcgacggapcggcgcgcgcga\n", + "aggcgccuagguuccuccccuuaucccugcapauupccuugcagcaccgcccaggcucggauugguccgag\n", + "cpugccggugccguugccgccgcugccgucgcappagucpuucccagaaaguagcuug\n", + "auuacaagcacuuucaaaaugccaacauuuccagaauaaauuaucugaaaguguuacuucccaacccccacccuucagcaguuguucuaa\n", + "ccugcccuggaucuccgccgccaccucggucucgcugcuccupcppugaggacgaguccggaguaucugg\n", + "aucuccgccgccaccucggucucgcugcuccupcppugaggacgaguccggaguaucugg\n", + "gccuuuuccugcccuggaucuccgccgccaccucggucucgcugcuccupcppugaggacgaguccggaguaucugg\n", + "aacpagguccugccucugaagauugucaccuaugccgcuguguccuugucacuggcagcccugcugguggccuucguccuccugagccugguccgc\n", + "ggcucaucagcacaugguaauuaacaaugauggacauggcuuccuggcacucucugcaugccaggcacuguucgcagugcuuuaauccacaaaacagcuuu\n", + "aacugucuccgucccuaccgcccggcuaacaugcucaagcapcgcgguggcccuugcuuguaacaugaaugcuaggaauguuapaagag\n", + "guagguuucucuggcaccgauucpccugcccggacuucgccgcacgcugcagaaccucgcccagcgcccacc\n", + "acagguagguuucucuggcaccgauucpccugcccggacuucgccgcacgcugcagaaccucgcccagcgcccacc\n", + "cupcucagcucuccgcucccgccguuaccaggacgaccgucuccccgcagcccaggcugcccggacuggcgcc\n", + "caucuucagauaauaagaaacagauaccuaaugaagcuucugcuagaagugaaagagacacaucagaccuagagcaaaacuggucauugcaagaucauuauaga\n", + "gacaagccpaagcuuggapucuauugcguacgcccaaggcgcupccuggagcaggagaaapaguggaggcgcgucggagacu\n", + "uugagaacaugaacugacaaggaacaaggugaaggaguuugacuggacuuuapauaauauaacucccuuaaaagaaguguuaaaaugaaggagagauuuuacaaaug\n", + "ugguugguuuuguuuuguuuuguuuuugaggacccaaagcaucagaauuguacaaacuauucucuuuccuauugcauuuucccuugagaacaugaacugacaaggaacaag\n", + "gccccugccucggccagagguuucauuuuuaacugaauauuuacgaaagcuggaagcgugcgappupupuggaaauagcggcugcuucuuuuccapauuuauuua\n", + "auaaaagugauppapcgcggagapaaggcupagccccapagucuucacgaccgcucagcucccggcgcgaguggag\n", + "uuuuuaacugaauauuuacgaaagcuggaagcgugcgappupupuggaaauagcggcugcuucuuuuccapauuuauuua\n", + "aagccaaacagguuuccaucuuuuaggaagacccuggaacgugccaguugauucugaccauuucucaugaacagaaacaccuaggaapagaacug\n", + "auaauacauaugugucaaguucagagaaugaugaagaugugcuaguuacuacagagccaauaccaguaauuuuucauagaauagcaacag\n", + "aauuaagaaaaacaaaugacauuaacuguugcuuauccauaaaauccaaauuacaaaaggaaaaupag\n", + "gaaucaagacagaauaguacaguggaggaagauucugaaggugacaaugauuccgaagaauuuuauuacggapcag\n", + "gugaacuaugaupaacugcacaagcacccacaacuggaagcugauuugucagcaguuagagagauauaupccacaugcaguuucucucag\n", + "gaggagauugcuguggcuupaaguaauucgaacagaaccuauaauuguucgacuacacuguucacuuacacaguauuuaaauggcccag\n", + "ugcccacuguugaugucuuucagauuuccacaaaagagcgauuuggauupacaucagcugaaaaa\n", + "cccugccucggccagagguuucauuuuuaacugaauauuuacgaaagcuggaagcgugcgappupupuggaaauagcggcugcuucuuuuccapauuuauuua\n", + "aucuuuuaggaagacccuggaacgugccaguugauucugaccauuucucaugaacagaaacaccuaggaapagaacug\n", + "cccgcagcpccuugcaccccaaauuccugagccucauuppuccuccccccacpccpcaugcugccccccggaaggaaccccucuccucgcu\n", + "guguugaauguuuguuuucuaaaggagacaaugauucauaauuugugacacuguaaauccugagguuuauagaaaggauucaugacuuuguaauggag\n", + "ggugcuggaaauguaaacaagaauagacuguucauuccugauggcuuuuagucuauacuaacauauuguuuguc\n", + "guguugaauguuuguuuucuaaaggagacaaugauucauaauuugugacacuguaaauccugagguuuauagaaaggauucaugacuuugua\n", + "cucuauggcuccgaccgapcggagccgcugcucgagcugcugcuggauugaacucagagaagccp\n", + "gaaucagcugaucccgcggacccacupuugccaagcucgcgccggaugcggagcgcggugcugccgguggagcuucag\n", + "agcugaucccgcggacccacupuugccaagcucgcgccggaugcggagcgcggugcugccgguggagcuucag\n", + "gauggagaaggaacugacugcuguacccaagugaagaucuuuacucaguuacccuuauauuuggcuauauggaauaaaauugugugauauguuuauucugagcag\n", + "acuuccgcuuuggaggcgaggacccgagcgaguguapugcggcgucuggucagccapugaauucucaggacuggucggcagucaag\n", + "aggaacucgauugaggaccagagguccagucacaaguaacaagccacuagccaggugcuucaggaagaccgcccucuugccucuguggaauccagugagg\n", + "aguuguucucagguguuupcuuguuguuccguauacucagupuucgcggccgccggcccagugaggcupuucgaggagcuggagcpaaacuggagcuuaaauucuggcggcgag\n", + "auuugaaagaagccaacacuaaaccacaaauauacaacaaggccauuuucucaaacgagagucagccuuuaacg\n", + "pccuuaaccucugcuggugaccagaagccugcauuucugcauucugcuuaauucccuuuccuuag\n", + "gugcaaucaaaguggagccugcaucuccaccuuauuauucugagaagacucagcucuacaauaagccucaugaagagccuuccaacucccuc\n", + "aguuacccaguuuuccugcugcugacagaauguugcacuuauaaauagcagcugaugcagaugcacagaaag\n", + "acuucaagucuuuuucuuuuaacggauugaucuuuugcuagauagagacaaaauaucagugugaauuacagcaaaccccuauuccaugcuguu\n", + "gccuuaaccucugcuggugaccagaagccugcauuucugcauucugcuuaauucccuuuccuuag\n", + "accauucugcaguuuaaaucuugaaccaaaaugucauuuaaccauccuucugaacgauaacuccauaauuaacucaagcaccaaauaagucaucuagcucuugaug\n", + "acgcugauuuauuuaaaucaucucuaauucucacaacuccgaaaagauaagaaaacagagaugugacaaggcuugaaugcaaacccag\n", + "acucaupuguauucacaaauucuguuacuucaagucuuuuucuuuuaacggauugaucuuuugcuagauagagacaaaauaucagugugaauuacagcaaaccccuauuccaugcuguu\n", + "gagccgcagccgccgccupcgcuupucggccucgaggacaccggagapcgccacgccgccguggccgcag\n", + "gaagccaacacuaaaccacaaauauacaacaaggccauuuucucaaacgagagucagccuuuaacg\n", + "auauacggagucaccucuccccagagaggucacagccaacauucagaggccucccapcccccucucc\n", + "guuaugaggcugguucuupuuugacucupaaucaugcucauugaucugcuuuuccuaaucaugucagugaauaccuacacgugaagaaaacucaagcugcaccauaaagcuaaaggaagaag\n", + "gagcuuuuaagugaauaagaccauuuucccaaugagcagugucauaaacauugaggacucucuuaaaucagaagaugaauga\n", + "cucugcauguggcuggcggccgcagagcaguucaguucgcucacuccucgccggccgccucuccuucpcucuccucgcgucacuggagcc\n", + "aguuuggcacauucuaggaacagaaaugucauugaaaccagcacacagugagagaaaaagugguagaaguuaag\n", + "pucuucucuacagcugacaggccaacucaaccuacugccaaccaagaccugacuggcacgaggaaag\n", + "gacggagupccgucgccgccgcgccgagccgugagcgccgagccaccgccgccgcuaccucagcccuucgcgaagcgccpcagcucpaac\n", + "gagcgaccgucpccggcupccggagcucpcucggupccuacagcggcuccggacggacccccpcupagucpaggccugccccggcccccugcccgcggccgcc\n", + "uccccgcccaccggcaagucacaugagccaccaaaauggugguguucpuaugaggcupacuaagccaapauucagguguggugccggupaacugaggaagcgcccaag\n", + "gccacagugaacuccggcguggcugaggaaggaggaggcacccacaggcugcupaggagagcauaag\n", + "gaaucuacuugaaaauggaucgguuuauguuggauuaaaugcugcucuuuguggccucauagcaaacagucuuuuucgacgcaucuugaaugugacaaaggcucgcauagcugcuggcuuacca\n", + "acgccgcgucacgagucagccaaagauggcugcgcccagguaauuugagcaaaggccacagugaacuccggcguggcugaggaaggaggaggcacccacaggcugcupaggagagcauaag\n", + "caaagauggcugcgcccagguaauuugagcaaaggccacagugaacuccggcguggcugaggaaggaggaggcacccacaggcugcupaggagagcauaag\n", + "acgagucagccaaagauggcugcgcccagguaauuugagcaaaggccacagugaacuccggcguggcugaggaaggaggaggcacccacaggcugcupaggagagcauaag\n", + "accuuuauuugccgucuuucaacuggcaagagucauuuugaccagcagauuaaucaacuguaagacagauccucacacaaag\n", + "aacagaaacaaguugcugugaauuacucaacaagguccuguguacuuagcugacauguggugaupugaaaagaaugaguaugugugauucuucuuaauauuguuauuucacccugauucaag\n", + "cccggcucccgcggccacguugcagcccaggcggaggcgcpaucucgagcupaucgcccucuupcuucggugcgaucggcggcpag\n", + "guucccupaaccagguggucgaapcugagcuguguggccagacaagaggucccugcccucccccagugagcccugcug\n", + "gcpcuccpaggagguggccccapaagguguggccgcpaaguggcggcgaacagccccgacgcgaggacpaaaccaaggcggcagccapagacccugaccgag\n", + "aaauggcucaccaagguugcacagcuggcgacaggcagagaggaucccacaaguuuuucuucupugcagcuuccucgaguucapcaggaggcagg\n", + "agucucagauugguaaacacccgaacuggucaacucucaagagaccaucugguucagguuccugacupccagcgag\n", + "augcacucaagcagagaagaaauccacaaguacucaccagccuccuggucugcagagaagacagaaucaau\n", + "aagaaauccacaaguacucaccagccuccuggucugcagagaagacagaaucaauaugagcacagcaggaaaa\n", + "auggaguaucuuucuauugcccagguuggagugcaauggugaucucggcucacugcaaccucugccucccpuucaagugauucuccugccucagccucacaaguagcugaguuuacag\n", + "guaaucaaaugcaaagcagcugugcuaupaguuaaagaaacccuuuuccauugaggagguagagguugcaccuccuaaggcucaugaaguucgcauuaag\n", + "pucgcugugccuguccccgugugauccgaaaagugcuggcaaaaugcggcugcugcuucgcccppacgug\n", + "gccccccapcccgucaguggccugaggagaugguuggaucauuccaaacauugucucaguguggaaacugaggcagacaguggucaggcaggaccauaugag\n", + "gucccagauupaaccagapucagugagcagcucuuggaaacaucucuapaaugagguguccgacacugagccacugagcccugcgagugcaggccugcgacgcaauccugcccuaccuccug\n", + "gacccuuugcacaaaacuuuuccupaaccaggaaaaucugcccccagcccupaagauugcgaacggaggag\n", + "gaacupcaggcaaggccgaaugcggcuaugaaacugagucacacuugcuagagccgcacgagauaccuuugaacgugaau\n", + "ggugcugcgcaguuuccggagcggaucgcaacccggaguccggauccgaucccgcucugcacauuccaaaggcag\n", + "guucccaagcagugcuggcacugcugguuccugguccapaccacauuuugaaaucacuaauguaag\n", + "agagaggcugagaccaacccagaaaccaccaccucucacgccaaagcucacaccuucagccuccaac\n", + "gcuucauuucggaagugauucauagcacuucugcuuacaacucucugaucaggacucaucccaagaucuuacccaggaucaaggaaaugcaauucu\n", + "ugaguuauuucuguuggccgcauuaggaaccugacauuugauucauucagupuccugccuagguccuuuaaaacagaauggacuguuapaaaggcugcccupcc\n", + "agcccuagagcucccagagacagaagacgagauggcaguauuuuaaggcacuagcagaucacggcacugcaaauccuuuuugucuuggcaaggcacaaggagaccugcuu\n", + "gugauuggaccagacuggauaccuuagagcagugguucucaaagaacagcuccuggagugauuguaggaaugcuucuuuccupaaccacagaccuccugagucaucccaccuggaaag\n", + "gguguacugcgcaggcgccaucuugagugacagcapcuguuggapcugapauuucaag\n", + "aaguuggcauccaccuugugacaagauacauaupcauucaaguggucacaaaauuaauuguaggaaguccuccaucucuuuucugugcucuggaaugguuuuuauaacacg\n", + "guggcgccgccpcgccpcgccaugapugcgcuaggcggcuguucgugcccgaggcugcgcagcacugag\n", + "guuupaggcgcpagauguccacccupcugguggcgccgccpcgccpcgccaugapugcgcuaggcggcuguucgugcccgaggcugcgcagcacugaggugag\n", + "ggauaccuuagagcagugguucucaaagaacagcuccuggagugauuguaggaaugcuucuuuccupaaccacagaccuccugagucaucccaccuggaaag\n", + "ugcpaggagagguuupaggcgcpagauguccacccupcugguggcgccgccpcgccpcgccaugapugcgcuaggcggcuguucgugcccgaggcugcgcagcacugaggugag\n", + "gcacuggccgcggcccgacggagcaaggcacugccugcagccgccgugugcaccpcggccggcuagcuccgaccugcgccuccaccgcagcacccgcagccagagccgcgcucggc\n", + "gguccuaaagaucgcucupaaaapaaggaugccgcucuucuuccggaagcggaaacccagugaggaggcucggaaacgccuggaguaccagauguguuug\n", + "gugcugaucguccacacgaaucaccucacuucccugcuucccaaauccugcagccuccugagucuggcaaccaucaag\n", + "guucuagaucuccacgauaaucagcugacagcccuuccugacgaucupcagcugacugcccuccag\n", + "gucuuaaacguggaaaggaaucaacugaugcagcucccacguuccauupaaccugacccagcuccagacucucaauguuaaag\n", + "acaacaagcugaaggagcuuccagacaccgupagcuucgaagccugcguacccucaacaucaguggaaacgagauccagagauugccgcagaugcuggcucacguucgaacccuggag\n", + "augcugagccuugacgccucggccauggucuacccgccgcpagguguguggugccggcacugcggccaucuugcaguuccucugcaaag\n", + "agucapcuggaauacuaccccccuucucaguacuugcugccaauucuggagcaagauggaaucgagaacucucpacagcccugaupcccacggacagauucucaapaggaguuagagugg\n", + "aucacucpagacuccaaacagugagccuagagcuggagacuagcguuaaccggcpcggccg\n", + "gguuugaauguccucccguagcucagaguaauucgaucgucugaagccuucuucucucagcuugucaaagucauucuccauccaccuuuguuccguugcug\n", + "cggaaapaacucccugaccccuugcgcuucccaggugaggcaaugccucgcccugcuucggcucgcgcacg\n", + "gccgccuugcaguuugaucucagacugcugugcuggcaaucagcgagacuccgupcguaggacccuccgagccag\n", + "aaaccgcccacucccugagacggcuaggucacagaagcagupucagaagccagapacgupagugccacccuggagccuaccggcacaccugcugag\n", + "ggcgccuccgcuggcgacppuggugacuuccpcgcuugaggacgaccccccccgcccccgcgcccacauguucuggcguucggcpupuccgagcagcugacg\n", + "uuccuagguugaaccgcaauccuuuaagaagucucugapaagaggaaauauuuugagaacuauuguuaucaacucuuugauaucugaugauca\n", + "cgagcucapcgccpagcgcggagcucpcuacggacucgcpaguucacugcgccuccpcccuggapcugccccugcccgcaggcccpcgcuuccgccaggaggcgacagcgcc\n", + "gaauaauguauuuguggccuuggacaugaggcagucaguccucuguugcuguuaacauaaggucapacugaugaggaaagc\n", + "cuggcaauauagcaacuaugaagagaaaagcuacuaauaaaauuaacccaacgcauagaagacuuuuuuuucucuucuaaaaacaacuaaguaaagacuuaaauuuaaac\n", + "acggacaccacauuaccuuacucagaaggcucaggaaagcaaaggcgcgacgccaccuggugugcccag\n", + "cacuaggaaaaguguagugapaugagaccgccauggagucaucgcugccupagagauguacucuggcauuugucpaugucgauggcugccccupacaacapaucccucaugccucug\n", + "gcuggucccugcagacggcuucccauuuuuaugaccggaugcupaagccugcugguccacagguccauacaugaagucaccauaag\n", + "auuuccgugapuggaagaaaaucauaccauaucagaugccucgcagagcaccaggcccaccgugaaag\n", + "ggccaagcucccugcguugcuucucacuuucacucuggaaucagaggugcgugccuggaggacuuagcucugcauggacagcug\n", + "cccuccgucagcagcuaacccuugagcpaugugugcuugugccpugcauugcauuaagagaaugcaacugaauagagaaggaucaggaccuuuugugcagag\n", + "gagcpaugugugcuugugccpugcauugcauuaagagaaugcaacugaauagagaaggaucaggaccuuuugugcagag\n", + "gacguaccccgcgccgaccguccccacgcccacacaagaccgcccuuacuggaggcggcggcugcacacuacccacccagaagaaguccguccaugucaaagaugag\n", + "cgaccguccguccguagucaaguugccgguggaauuggcccaggaugacagcuggagaauggagucagguacpagcggcuuugaguggaaccgugugaaagagccp\n", + "uuuuauccaaguaugaagaucagauuacuauuuucacugacuaccuagaagaauauccagauacagaugagcugguauggaucuuapaagcagcaucuccuuaaaacag\n", + "aaaaaucuaagcuguugucugauauaagugcucgucuaugguuuacauacagaaggaaauuuucaccaauug\n", + "aauuugagacucagccuaguccaggcaagcuacuggcaccugcugcucucaacuaaccuccacaca\n", + "uacaaauggugaugaucaucaggucaaggauagucuggagcaauugagaugucacuuuacaupaguuauccauugaugacgaugaa\n", + "aacugaaaauccacaagacagaauagccagaucucagaggagccuggcuaagcaaaacccugcagaacggcugccuaauuuacagcaacc\n", + "ggaggacaggaccagcauaaaaggcapcagagucgacuguugcuuacacuuucuucugacauaacaguguucacuagcaaccucaaacagacacc\n", + "gcucuuucucuagguccugcugcccugugaggaaggugcuugcuucuccuccuucagccaugcuuguaguuuccugaggccuucccagccaugcagaacu\n", + "agacaggaucucacucuguuggccaggcuggagugcagugguaugaucauagcucacugcaccucugagcuccuggagucaagcaauccuccuaccucagccuccaaaguagcuaggacugcag\n", + "gucauucuuuaagaaucuuuuccaguaaacauuuguuacuuuuucaaaguaauupagcuguugaguguggaagcgaaaaccaaguuaagaaguccuguuauuugg\n", + "gugacccagcuaapuguucgugucagugcuggacgucaaugacaaugcccccgaauuccccuuuaagaccaaggagauaapuggaggag\n", + "gacacgaaagugaacuccaccgucauccccgagacgcaacugcaggcugaggaccgcgacaaggacgacauucuguucuacacccuccaggaa\n", + "acuccacgcuuucugcagccgccacugcagccgcgcggcpcucccuccuugcagccagccggcgguccag\n", + "ccgcggauggccggagcuggcgcccugguucuggagguaaccgguuacugapcgagaagcgccacccggaggcucuagccugacaaaugcuugcugaccupccagagcucuucccuuacgcaa\n", + "gucucagccggucgucgcgacguucgcccgcucgcucugaggcuccugaagccgaaaccagcuagacuuuccuccuucccgccugccuguagcggcguuguugccacuccgccacc\n", + "gguucuguacauuggccuggccugcaauacggcucgcuauauuuauauuuccuaccuggagaaugccuggacuguucucccc\n", + "acaggaucucucucaguuacccaggccggagugcaguggcgugauccuagcucacugcagccuugaaccccupcucaagugauucuccugccuuggccuccugaauagcuagaacuacag\n", + "augaugaaauggaauuggagccgcugagcuggauaggugaaggcacuaaugaugaaggaaaaauag\n", + "aguuuuccgaaaccccgucaggcgaaggcugcccagagagguggagucgguagcpccpaac\n", + "ggcggaucccguccucccccgaugugagcaguuuuccgaaaccccgucaggcgaaggcugcccagagagguggagucgguagcpccpaac\n", + "gcguugcaggucacuguagcpacuucuuuugguuuucuuucucuuupcaccucuggacucacuccccagc\n", + "gcgcpcucccacccugcpaaacagccgcpcccucggccpaagcaacpuggagcagcgacaguggaguccapucuccguuccgcappaccg\n", + "gcaaaauacauaucucagugcauugaugagaucaagcaggagcugaagcaggacaacauagcggugaaggcgaacgcggucugcaagcugacguau\n", + "ggcgcgcpcucccacccugcpaaacagccgcpcccucggccpaagcaacpuggagcagcgacaguggaguccapucuccguuccgcappaccg\n", + "gauuuuaaaguuggaaaucugcuugguaaaggaucauuugcuggugucuacagagcugaguccauucacacugguuuggaaguugcaaucaaa\n", + "gupaguuugaccuccgccgccgccaaccgccgccucagcuugcgccgccgccgccgccgccgccgccgcgcacgccaupagccgugacugacg\n", + "ggaagaaaggcaauucagacaaagcagacugaauauuuaguaguagauuguaaauauucaggcaaagaaagagagagagaggcaguaggaguuacaucaguuuuaccauccuug\n", + "acgaaguuauacggaagcgucuccucauugauggagauggugcuggagaugaucggagaauuaaucugcuagugaagaguuucauuaaauggugcaacucupucccaggaagap\n", + "aaugcaccagccgccuccagccuccugcagcagcagcagcagcagcagcagcagcagcugcgagugcgcgcgugupugugagg\n", + "gcucggaccauggugcagucccacuggcuccccugccccccucuccugugagacuggcugcpapaucauggauacuugucugccggcuucugguucccacgcaaguaagccugcuguca\n", + "gaauupacacucacccaggacacacuauggugcuucagccaagugaaaggcacuaucgagauuggaaccacagaag\n", + "gaaacucaucuuuucuugaaauuggcccuauuuacacacagaaugagcugaaaagacuucgcuguuauuaaaccuucaagaauguucuc\n", + "aggccuugcugauccguaguuacggucucugcuggacaaucaguauuaccupagcugacugag\n", + "cagccuuugcupcgccagacccggcuuugccguccggcuauuagccuacuguggcuagucacccccpucccggccuucucpcupccgccgccaccgcggcaggacpaggcpcc\n", + "gaccgccgccggccpuugcaggcpcaccucpcaggaccucccuggucggaaguggccgugagcccaagccgcggucccgg\n", + "auuuccguccgccgaggaaccgaccgccgccggccpuugcaggcpcaccucpcaggaccucccuggucggaaguggccgugagcccaagccgcggucccgg\n", + "apacgagucauuuccguccgccgaggaaccgaccgccgccggccpuugcaggcpcaccucpcaggaccucccuggucggaagug\n", + "ggaggaggcpacuuccugcagcaaauupcugugcgccgcucaagcccguuuaccugcuccccaggccggcacccagg\n", + "ggcpcaccucpcaggaccucccuggucggaaguggccgugagcccaagccgcggucccgg\n", + "gagccuccupuguccacgugagcgcgcgugaguccgcccccccagucacgugaccgcugacucpcguucuccacuaucgcuuaccuaccucccucugcaggaacccggcgau\n", + "gagaaggaagccaggacagcgcaguccccagucccgaacggccapagaggagguggccuagcgcuggcpcucaccccaauccgucugccuuuugaugccguacu\n", + "aaaagcugaauauucuucuggagcccuuggapcuccaaacugagapapaagaccgcapaaaggcggaccucagugucugaaaagccagcuuagagupapccupaguagaag\n", + "aaugugagaaggaagccaggacagcgcaguccccagucccgaacggccapagaggagguggccuagcgcuggcpcucaccccaauccgucugccuuuugaugccguacu\n", + "gagacpuuucgccauguugcccaggcuggucuugaguuccuggacucaagcgauccucccacgucagccucccaaagugcupauuacag\n", + "cccaguuuauugucgupcccacugaucccaucuuggccacgguuggagaaaacacuacguuacgcugccaucugucacccgagaaaaaugcugaggac\n", + "cugacucucuuuucggacucagcccgccugcacccaggugaaauaaacagcuuuauugcucacacaaagccuguuugguggucucuucacacggacgcgc\n", + "gauccgaauacuaagcagagcgagugccpcugaguguaagacacugaagacacugcagagcaaggugcuuauuccagaggcguuacaaaac\n", + "agagcuaccugauccgaauacuaagcagagcgagugccpcugaguguaagacacugaagacacugcagagcaaggugcuuauuccagaggcguuacaaaac\n", + "gcgcpaaguggaaccuggcucupagaagccgcgugagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "gagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "gcpaaguggaaccuggcucupagaagccgcgugagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "gccgcgugagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "paaguggaaccuggcucupagaagccgcgugagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "pagaagccgcgugagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "gaaguggaaccuggcucupagaagccgcgugagauccgcgcpugcuagcuaguccuuucucgucgcugcucggcucgcggcccgupucggccccgccaccguugccgcc\n", + "gcuggcugcpcgaagupapuggccpcpugaggaugcugcugcgcccugcccuggccpaccguggaggagcpcacugccgupupagccgcuguccgagcpag\n", + "aguggccgagcggcgucgupuuaccccgcccgcgccagcgcugcaucccuggccgcuacccpagagccggaggaugaauugaaccucgcagccgcugcuaucuccagugcucaucacag\n", + "guuuccacagcuggauuguuuacuapccaauugucaccaauggcaguaaaacucauuuucupaauagg\n", + "ugcupauuacaggcgugagccaccgcgucuggccucagccaagguuuuuaaguaacauauuucagcauuggcucuacagcguugcag\n", + "gaggccggcgcggagaaucugcugucgccugcagcugcucgccugucuccgucggaapagcccaagcuuugcagag\n", + "gauuccucaguuapaaacugcagaggaaaugaucuguuacacapcuuggcaggaccauugccagugauugauaaupaccaaaucauuucag\n", + "gugauuuggauuauuacugguuggauccugccacguggcacagccpagacaucaccuauuaguucg\n", + "cauccuguaacguggcaaccaucuaaagapaccgauuaauuggacguguuauucuuaacaagagaacaacc\n", + "aggagagcugguugcgugagucuccucagcucugcuuaccggugcgacuagcggcagcgacgcggcuaaaagcgaapcgagugcgaguccccugagcuguacgaacgcggucgcc\n", + "ccgcucccgccgccgccgccgccgccgccgccagaggagcagcagcgcuugugcaaaccpaag\n", + "guuauccauuguuauauucuugcaaauauaacccaaauuauguauugcccuauuuuacaguggucugaaauagcaaacccauuuaaacacugcaauau\n", + "ccuagaucuguugaucuuaguaacaaugaagcauccucuagcaauggcuucuupaacaagcaggaucucaaccaacg\n", + "cuccucucuguuacgaaguagugcguuaucuuuucucucaaguuugagucuuuccaagguuucuucuaacaguuuucuccuucuapaucuugucugaguaagauauuaac\n", + "aaccuguccacuggccuucuccaggcaguuccuucuagaccupaccugugcccgaggaccuuagacug\n", + "ggccuucuccaggcaguuccuucuagaccupaccugugcccgaggaccuuagacugaupugcccagcucugcuucgaggcca\n", + "pagagaggauaaauagcagcguggcuucccuggcuccucucugcauccuucccgaccuucccagcaau\n", + "aauuucgguucucacagacucuuacuuggaugucuguaaauccggcuggacuuucagcuucuaagaacaguccguuucucgaggauccaggcgcaggaggacagagca\n", + "ggugaucauauuuggccugagagugaugccuuuucucuggauuuguccucuagaguuuucccuugcagauucaucaag\n", + "gugcgucacagaauggccucggacacccaggcagucccugacgugucpaggagccpcgcggag\n", + "acgcugaguggagcucpcugcguapagcugagccgagcggcupcpccuggccpccggcggapagacgucgguugagcggcggcgaacaugcgcuuuugacacauuggag\n", + "ugugucagcaaguucagcgupccccguaugcugccguggaucugaucagcugaggccugagacacaggaccag\n", + "agacaccgagucucgccuucugagauuggcpuaaccuagcaacgcapaccgcggcgguaacuguggcuapaaaccuggagcggucagagcag\n", + "gauggccagagacaauaaaagcacgagacccaaguagucuaccgaagucuccaucucuguggaccuacagaggcacagapcugcucacaag\n", + "ggcggcuuucuucccgapcggcacgapcupcggupugcpugcccpugapcggagcupc\n", + "cuucccgapcggcacgapcupcggupugcpugcccpugapcggagcupc\n", + "gcgccaucgucuucaaugcuucucugaacagccuuuaggaagagugcgagagaaagagagagagcgcgcgccapagaggagaaaagaag\n", + "cgccaucgucuucaaugcuucucugaacagccuuuaggaagagugcgagagaaagagagagagcgcgcgccapagaggagaaaagaag\n", + "aguuacgcagcugucuuccaggugacuggauguguugaucagcgcucgcupauuuggcugacguggccccagccccgccucccuccccaccccaca\n", + "ggagucgccggaggagccaguaucugugucgccgccgcccgcggcguccccgguuugguguugcggcgcccaccuucpaggaucag\n", + "uacucaagaccaacuucugaaguccucuguuucagaccuguguauguagauacaguuucuauagaguuacuguaaauguugcauagugaaaaga\n", + "caaagcccguggccaccgagcgccggcuggcapcagugaccggcggccggcccguucgucccupcuccgcaagcggcgcgguggcacgaag\n", + "aapuggcccaccagcccccuacucagcccccuacugaggaggupaggcaucccccaaccugccaggcugaagagacccccaguggag\n", + "cccagcacggccccacccaagcccaagccgccuccgcugaccaaggagacagugguguucupac\n", + "gcauuuuuuuuuuuuuuuggaaguccuaggacugaucuccaggaccagcacucuucucccagcccuuapuccugcucggccaag\n", + "gaaguccuaggacugaucuccaggaccagcacucuucucccagcccuuapuccugcucggccaag\n", + "uuuuuuuuuuuuuuuggaaguccuaggacugaucuccaggaccagcacucuucucccagcccuuapuccugcucggccaag\n", + "cccpcuucugaggcgucuaccuucccagguapcuguacaaggaguucuccagcaucuccapcagaaagcuuag\n", + "cuccuccugugcucgupagcuggccgaguggaaaacguccacauugacccaaccgcagugaapagagcgccuccagugguguggugcguggagaaaupaaggagagaguucug\n", + "aauauugccuguucuacagaguucccuaauuccauauugaugauaccuauupaaacuuuaguuuuuuua\n", + "apccucugaggacugcugcagacacagcugaggcagcccggcuccaggcucgcuggapcugugucupagaugcuucucuauaaaaagcuuagag\n", + "auacggacgccagcugcpcaaggccaagaccccaccccaacucacgguuacccaaagupuggagcucccagcucucagccccgcccauugaacgcaaucccagccg\n", + "cuacuguccgccugcucgcguccupugccgccucugaguapcpcgaggaggcagccaaggcggagcug\n", + "ucggccugugccgccgccgacgccgcuugupcccgacuccgcucugucugcuucgccaccuucuccccgagcacugcccggccggccgcc\n", + "gcugucucccucggccugugccgccgccgacgccgcuugupcccgacuccgcucugucugcuucgccaccuucuccccgagcacugcccggccggccgcc\n", + "cccuaaugcaugaggcuccugaccaccauaaagauagaacupcuuaacccucaucacuucugaagcugauggaaug\n", + "acaauugcagcaugacuuucccapcccugauuuucagcacggaugauuuuuucuucapaagauggugccuaugaguucaauccugacuuccuggaggaagcucaugaauggaaccaaaaaagag\n", + "aucacauggccggagagucacaaaaacaacagcuuuggccaagaccgugacuucaguaaapaacccpcucucgcagccagcccuccugccc\n", + "gccgcccaggacccgcagcagagacgacgccugcagcaaggagaccaggaapugagacaaggaagag\n", + "aacggugcgcuggagcgagugagcagcgauaccuapcggaagugcucucggcggaagugaucgcugugugaaucgupup\n", + "agacgccgcugucagccggcgcuppucggugupuagaauggccgcugccgccgucacccgcpaccccpag\n", + "acggcagcacggccupaggaggucguccaggcupagagcccacgaggccaucugucuggcpaupcaggugccccuguaugugagcgugagaccucccccauccccagucagcu\n", + "aacccagcccuugcugacaucuacacagagcacgcccaucagguggugguggccaaguaugcgcccagcggauucuacauugccuccggag\n", + "gaccacagccgcuuugucaacugugugcgauucucuccugaupaacagauuugccacagccagugcugacggccag\n", + "auauacaucuaugacpaagacupagaaggugugcgcgcupcggaagcaaggcccacgacggupauuuacgca\n", + "auuaguuggagucccgacagcacccauuugcuuucugcuucupacaaaacuuccaagauuupacgucagcgugaacuccguggucagcacauuuccc\n", + "agucaacaggugaccggccgagaccgguccpcuccuucucccuucuguccccgccguccccgcccugcccugac\n", + "gcuuccaggagccaggaucuccggugacuggagccguaggacaaaauggcgcucgcauaggcuuccgaggccaggcccagucgugcgcucugag\n", + "acuuccuccucugccgucucccagaucaguacacaaaggcugcugcugccgccagaggaaggacugcucugcacgcaccu\n", + "auguggaaacuaaagcccagagagaaagucugacuugccccacagccagugagugacugcagcagcaccagaaucuggucuguuuccuguuuggcucuucuaccacuacggcuupaucucg\n", + "cacuuccuccucugccgucucccagaucaguacacaaaggcugcugcugccgccagaggaaggacugcucugcacgcaccu\n", + "auguggaaacuaaagcccagagagaaagucugacuugccccacagccagugagugacugcagcagcaccagaaucug\n", + "cgcccucucuccguguggcccccugagcggccccccuccccugcccpapaggcppcaccupcccgcc\n", + "auagccacuuccucuugaacugapaggcapcuugucuucucuccucagagcagagccugacaucuccccaccacagacguuugaacagagcaggcuccugaggucuccagg\n", + "acaacugcccaggacugcuccugagcagccgcupagacagacggcaaccagguugccccucuuugcuccag\n", + "gagupacaagagcucuacapcaggccacacugcgaaggaaggaggcaacacpcaapcugccugcugcccgcuggagaccgcacc\n", + "cugguguuuagcaacuccgaccaccugccugcugapcuagagcccucagcccagacccugugcccccggccpcucucaugcguggaauggugcugugccccuugccagcaggccaggcucacc\n", + "guuaccccaccccaggaggagagaagcuccapagcccgccgcuguccccccgcggucauugccccccugccccagccaagcca\n", + "uccgugcuccaguaccgaguaccuggcupcccupcacgcacapccguagccccacugugugupagcc\n", + "aucuggagguggaggcaguacccuggacucuauucugcugccccuucapuuuggaggagccggag\n", + "cgcccgucguggucaacpccagccgagucuggagugguugcgaacccuucuggcugcagaucuggagguggaggcaguacccuggacucuauucugcugccccuucapuuuggaggagccggag\n", + "caucccucgcguccugucacuuccagcgaggcacacaaaacugaccguapauggccaccapuccggacagcuucuauuugg\n", + "cggccgccauuguuccgcgccgauggcgagauccuuguuccucagauagcguucaucgcccgucguggucaacpccagccgagucuggagugguugcgaacccuucuggcugcagaucuggag\n", + "aguggacuuggcggcagaggcagugcggauccggcguucuccacugaucuuuuccaaggcuguacagac\n", + "pcpacuuauugcccgcgcggugapagcguggucucgcgcaagccggcgugcggucccgcggcgcugcaguuguguccagccggucacpcggcu\n", + "gucucgcgcaagccggcgugcggucccgcggcgcugcaguuguguccagccggucacpcggcu\n", + "cucucacggccacgucuccgccggagcauccpccpcggccuccpcugccagagcagcagg\n", + "gcaguauaccuuaaauggcaagaaggaaauaaaucaucugacaucacucagauugaagaggagcuuuuuuucccccgauugccuuaagaaguagcauacuuucccaa\n", + "agacupuguguugcuguauugcccaggcugguguggaacuccuggccucaagcgauccucccaccccagccucccaaagugcugguguuacag\n", + "gaugacagugguccucugcgucuucaucuuggucaccacgccagagaggauccgcccucgaauggagacaucaccagugaapcauuucuugucaau\n", + "gccggaagcucgguucagcuuccugaaagaguugguccugcaguuccggaaguugcguuucuacuapaaagguccgcaaacucuuaaggucacuuucugaaggcggccucaucacagucggag\n", + "gcguagcgugccuccugugauuguugaagagcuguggugugcugcugaguggcguguguauuccaugugapaapuccaacaguccuggucauucagacugcaguuccccag\n", + "gauggcuggaggcgccggcggagcgcpucccucuccugagcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "gagcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "cggacccgccggacgcaaccgccucgccagccggagccagcgcgagcucggcacgguggacacccgguccgaggccggcaagccggcuggugcccgagucggccaagc\n", + "cuggagcggacccgccggacgcaaccgccucgccagccggagccagcgcgagcucggcacgguggacacccgguccgaggccggcaagccggcuggugcccgagucggccaagc\n", + "pucccucuccugagcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "agcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "guggaaaaggauuauucauaccugaaggagauaugugaucaccaagccgaacagcugagcagaaccagccuaaagcugcaagaaaaagcaucagagagugaugcagagaucaaagac\n", + "ggucccucuccugagcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "gcpucccucuccugagcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "ucuccugagcaucagugagcgcccggagccguggccgcupuugcggcggcgcugagccagcpccg\n", + "cgccaaccuugcccuagccggagcccgcugcggcccagcgcacggcccucaccccgcaucgcgaccccgcgccccgccggccgagc\n", + "agcucupagaggagccccagccgugagauucccaggaguuuccacuuggugaucagcacugaacacagaccaccaacc\n", + "agcucucagagaggugccuuagcccuggauuccaaggcauuuccacuuggugaucagcacugaacacagaggacucacc\n", + "guuupcgaagauuuauucucagaugguguuugcuccagcuugccauuacugacaccugcgcugccuucgcucccaccuucccuguuuacuguguacuacgcuucuuggcagguuuuucuucc\n", + "uuuauugucaacagcuagaaguaucucuaugaaauaaugaucucuaugacuacaaaauaacaucuaccuccugauagcaaaagaacugaggaagcucuuuccacuacggcuguauugcacug\n", + "gcgcacgcgcagcaccccauuuaaguuucucgucuuugcaguggcuuugcuuagauccggugccgccuugaaggcpcupucccagccguagcca\n", + "auagauucuguugcuguuaacauuucaaacuuggugcuugagaaucagccaccucggauaucaaaagcacaaaagagacgg\n", + "gugccuggauagaaggagcucucuguguuguccuuggucccugcucugcucuuaccagcuguauggccuuuggaaaucuuucugcgugcuguuuccucagaagaggaaaaugapuuuuggauuag\n", + "acuuugccuucuuccaugauuggaagcuuccugaggccaccccagagucagaagccgcuaugcuuccuggacagcuugcagaacc\n", + "ccuuucacgcugucgcugcccguaggugguuguggccacugugcccggapaggcggcgguggccagua\n", + "aaggccpcggccgccuugcccccgcuuccuuucacgcugucgcugcccguaggugguuguggccacugugcccggapaggcggcgguggccagua\n", + "uuucacgcugucgcugcccguaggugguuguggccacugugcccggapaggcggcgguggccagua\n", + "cugaacggacgccguagccaagagguupcggauguugugagccpucgcugcggccgaggcuccgg\n", + "gacagguugaapcggcuuggcccauccacugugguccuggaccacacaggcggcuuugapcuucuccugguggaugaugaccugcup\n", + "agaggcaacauggcggccuuagcaagcuauagcugcgagauuugaauuacuccacucguagcuauugcauuccugacg\n", + "auggcggccuuagcaagcuauagcugcgagauuugaauuacuccacucguagcuauugcauuccugacg\n", + "aggcggcggcgcgagccgagcupagauggcggcggcagcggcggcgccgagagugugagcaccgcccpagccgccggcccpcgcagcgcgaccccgaccccgcccgcccgccugcccgcc\n", + "ucucguaggcccuucuacccuccccgaagccpcucccpuuccgcuuccacapccgcccccucuccuccgagauccaacgccucgccccucg\n", + "auacagcacccacuguggccupagcuccgapcuccagcugcuugucugcuuccugcugcugaacagcugcccppcugcagcgacacuagugcccacg\n", + "auggucaggaccaaguaggagupcagcuuuggccccuccaaggauuugccaccccagucuuccagcauuuacagguugugcuccagcagauuauaccccaag\n", + "cggcgcucacupcccggcuuucgcccgcugcugccgccgccgccgccggccgcggcugcacucccaag\n", + "gccgucgcgucgcggcgcucacupcccggcuuucgcccgcugcugccgccgccgccgccggccgcggcugcacucccaag\n", + "cpcgcccgguaccucugcccgcgguccucgcucucpcpcggcggcgacgcggaccugcggacuagcgaacccggag\n", + "cccuucccacggcugccuuaguacagaaucuuauaaguccuccuccuucagaggcuacaaaugguguuccgaggccapaguuuaaagcucgauuucacccgcgcagccuccaauccg\n", + "gcauuugcuuccugaaugauggucccacucagccauccaccuauacuuucuacaaagucaauuuauacugauucuucagaucaguuaaucacug\n", + "gacggcggcugagcugugcugcgcggcgcggcgcggugcggcacggcacggupagugucuccggcuggcuugcag\n", + "agcggaagugcgcgcggcggcggccgacggcggcugagcugugcugcgcggcgcggcgcggugcggcacggcacggupagugucuccggcuggcuugcag\n", + "aagcggaagugcgcgcggcggcggccgacggcggcugagcugugcugcgcggcgcggcgcggugcggcacggcacggupagugucuccggcuggcuugcag\n", + "cggccgacggcggcugagcugugcugcgcggcgcggcgcggugcggcacggcacggupagugucuccggcuggcuugcag\n", + "ugcgguucucuugcucgcuuucuguucucuugcuuacuuucaaaugcagacgugcacuacagcgucaccag\n", + "cgcagcuagagagagcucaccaagagaaguuggcgcaaaguagcuagccagagccupacuguguu\n", + "uuaccuuguaguagucagcaaauucucuguaaagaccaaaauauaccucauugucuuuucuguucugcaagucauuugcuaag\n", + "ggaagugcugcuggaugccuggacagcccaucucaugaccaugacgagacagccaacacaaucagagugaagcgaucccagcagccucacauugcugagcugccaga\n", + "agapucugcgcagcuagagagagcucaccaagagaaguuggcgcaaaguagcuagccagagccupacuguguu\n", + "agagagauaccgagaauguuccuagapucugcgcagcuagagagagcucaccaagagaaguuggcgcaaaguagcuagccagagccupacuguguu\n", + "agcupacccacuccpcuupacccggcpcpagaagcpcucccggcgcggccuggaaggagcgagaaagcaaaa\n", + "gcggccgcgcggagcpagccgccagccugcgccccguccgcpucuaupaaguucpacuugacagccgcugccgccgcag\n", + "gcgcuuuacggccgcpacggagcgagccggcgccapccccucpccpaagapaapagcgagguug\n", + "gugugcugcucucugupuccuguagacccagagaggcucagcugcacucgcccggcupagagcupugupaac\n", + "cucucugagcucugagcgccugcggucuccugugugcugcucucugupuccuguagacccagagaggcucagcugcacucgcccggcupagagcupugupaac\n", + "cugugugcugcucucugupuccuguagacccagagaggcucagcugcacucgcccggcupagagcupugupaac\n", + "gcugcuuccuguupcaugaguccggcgcgugucpuuuugagcugccgcggucccpacugag\n", + "auaaggcagcuccagccccuggaaggccagagacuugccagugucccacuagcpcucuucgcaagaauccccccpcccgccgcagccaggcggcggccggcagapcgcugcucpc\n", + "gcuuccuguupcaugaguccggcgcgugucpuuuugagcugccgcggucccpacugag\n", + "uuagcuccuupagcagacagcuguccucacuggcagaggaggagcgcucaguaaaugcucgcuggacgaauaaauggcuagauaag\n", + "acucccacccuaagugcugcagacucuucccugaagcugccggcugaggccggagcugccgccuccaugagaggcuuccuccuacaccccagg\n", + "gccagaggacccuuugccaccagagugagauccuagagaccaucauccugguaaaucccagugcagacagcaucagcucugag\n", + "ggcaaaacagaugaugaapacguuaauuaugagagaaaagguucaauuuauaaaaaccuugucacauuuuuaagagaaaaaucaccaaaauuuucagaaaauaugucuaaauug\n", + "ggcaaaacagaugaugaapacguuaauuaugagagaaaagguucaauuuauaaaaaccuugucacauuuuuaagagaaaaaucaccaaaauuuucagaaaau\n", + "aaugcacuupaaaccagagcuaccagaaucauguucuucagucaucauugugaugaugcagauauugucacu\n", + "agaguagaggagagcggagagaaggaagcucucacuucucugcugaacagcagagugccuuacaugcauauaggag\n", + "agcgcpcgcagagcgucucuggcgcpcauacggugcaacpuccgcpaaucuuggaugcgcggaggucccgagaccagg\n", + "aaaucuccaaauuggacauccagagcagcauucuuguucugucuacgucuugaauuagaaacuaucaagcucuguaaguccugaaaaggaaauaaaag\n", + "gugcgucccuacccaagaggagagguggccaguaaaugucagcugaggcaccgaaggcugcgaugcaccagcccggugcccugugaggacggccacaucaauagugguaacacuca\n", + "caauuuccugcugcagagagcauuuuaagaaaggacagcauuccugugaccucugccuaccauccauaaaauacucauuccccucucag\n", + "aaaagcgaaagcgaaugcgacuggcpcggcaggucccagagcagcgcucgccaccuccccccggccupcagcgcucgcccpaguccagcgguguccuguggagcugccgcc\n", + "gcagguagagaaggacagaagaucaguguggagcagaacauggagaaaaagccucugacacuccagcaccagauagcaccagaggccucaaagccagupcucugcag\n", + "gccggugccggccgcgccauuguupapcggcuguugapcggcggaguapcgagcgaaggcgguggcagagaggagcggaggcuuccc\n", + "gugcccggcucccaccccuucccagccccagcccuggagacagcagccccuagacuacugapacagcgacagc\n", + "gaucucaguuuuaucaugaaugacuucuccauugugauucuugauuuccuucaupuuaauuuagagguu\n", + "agaggcgucugcggugacagcucagucaguugagcucugugugccaggcgcucgcgapuagcucuucuaguagugcucggcgucagac\n", + "agugcugcgcuucgcggcagaggcgucugcggugacagcucagucaguugagcucugugugccaggcgcucgcgapuagcucuucuaguagugcucggcgucagac\n", + "gauucgccaaccaacaagcuccucuacgccaaggagauuccugaguaccggaagaucgugcagcgcuacuacaagcagauccaggac\n", + "uugaagucacgaggaguucuccaagaaaggucugcuggcugauucuucauugaccuaccagucccugcuaucaaggacacuaga\n", + "gapacaaagagcuccuccacucccucauuccccaagaaggcccccagccuacccaguuuccgugaccauuccgcccupaaagcggcuucccag\n", + "gapacaaggucccugacuccaauccugagcccuuugccccauguupugguggagcaacagaacugcuagaggcccpacuggcauccagagugag\n", + "gguucaucaccagcagccagucggcagcuuaugcuaucagcaaguuugucagupugcugucugaccag\n", + "agacccuggcuucgcapccccggcupcagaggcgapccuppcgcuggcuuuggccccgccupcagg\n", + "acucgcacccgcugcccccgaggcccuccugcacucuccccggcgccgcucuccggcccucgcccuguccgccgccaccgccgccgccgccagagucgcc\n", + "gaaaggcucguguguaccgaaguauapaccugucugcagcaggapacucgaaggacacggaggauuauaucacugaaggcauaagauucagag\n", + "augauaucaucaaguugaaucgaaaggaapaagaagcagaauuuuccaagacuaaauagaagacuccuccagcaaaguggugcccagcaauucagg\n", + "cccucggugcggcpcugcgugcgcgagupagguggcaggccugcgacuccggccuuguccgcgcccgcucucggcgcgacgucuccagcc\n", + "ggugcggcpcugcgugcgcgagupagguggcaggccugcgacuccggccuuguccgcgcccgcucucggcgcgacgucuccagcc\n", + "gcguauccuuauucacccccgugacauuacacgcupaccgaacucaguccgagauguagacuaggcaauaacgcuaaucuaaucccg\n", + "uuuugccggauguuguuguauguccgagagacacgugagguucugcuacgucauuaccaggcacgcgcaggaaacauggcggcggcpuguugugagcpaag\n", + "auuauauaugaacaagaaggaguauauauucacucaucuuguggaaagaccaaugaccaagacggcuugauuucaggaauauuacguguuuuagaaaag\n", + "gaugccgaaguaauaguggacuggagaccauuggaugaugcauuagauuccucuaguauucucuaugcuagaaag\n", + "gacuccaguucaguuguagaauggacucaggccccaaaagaaagaggucaucgaggaucagaacaucugaacaguuacgaagcagaaupac\n", + "auucgcuuggugacagguggugcuacuuccucaaaucuuugaucuguucuucccuuucuuuuucucaag\n", + "acauuaccagaaacaucuuuaccaaauuaugccacaaauuugaaagacaagaguucuuuaguuucaucucucuauaaaguuauccaggagccacaaagugag\n", + "gaaauaguugacaaacapacauaccaaaguauugaguuuuacgauuccaucuuuauccaaaccaucuguauaccaugaa\n", + "guugaagguuuagaacagauguggaaaaauguuuacuucagagaaapuuguggaggaaugguugucagaguuuaag\n", + "gauguucuagugacuggauccuuuccagcuggugccupaaauggcagccacuacuaauucagccuugaagacaguaccgugccuacucagcaccauuacguagaagacagaacucaagag\n", + "cguuccpcpcuuacuucgcagcgacuacuugccgcacuuccpcugccaggcagcugcuguggcuccagg\n", + "gucaucguugugagcccgcuaucagcggccagcgcpcgcggccggagaccgupcccccgguugccgcccccucgg\n", + "gagcccgcuaucagcggccagcgcpcgcggccggagaccgupcccccgguugccgcccccucgg\n", + "aucguugugagcccgcuaucagcggccagcgcpcgcggccggagaccgupcccccgguugccgcccccucgg\n", + "agccaaagacaagaguaggcagaccugaapupuupuacaguguggacggcgugugaaccccpugguaacaguggagaaagaugucuupcccugccccugaacuaggagccacc\n", + "cccgcuaucagcggccagcgcpcgcggccggagaccgupcccccgguugccgcccccucgg\n", + "gcuagccguccgagccgagccguccgagccpaagccpcgcgugcugccgcucguggcpccgag\n", + "acagucuugcacuguuuccuaggcuggagugcaguggcacaaucacagcucacugcagccuugacuuccccaggcucaagccauucuccuaccucagccucccaagcaguupaccacag\n", + "gccugagccgcgccuugcugcupucuccacuugupaagagagaacuggaccaggacagcgcpaaacugacaaugccacugcuugcuagcuuupauuuuggacaaauag\n", + "gucuugcacuguuuccuaggcuggagugcaguggcacaaucacagcucacugcagccuugacuuccccaggcucaagccauucuccuaccucagccucccaagcaguupaccacag\n", + "aagugcgcaugugcgcgaggagucgcucpcacuuauugagcgccgacugucuacpcggccp\n", + "gugagucagcauuggcggcggccccagcgcguggcagccgugcgccgccaaggugcpucucguuacucggcggucaggagcpcccucccuuaggugcgccccccgccag\n", + "guucugcguuagaccugcaucuuagcaaugugaauauugcaucccuagagaaggaccuggaagagcaagacggccacgaccupagcagcag\n", + "gaauccccggcggcggcgcpcggccgcggaccgugagucagcauuggcggcggccccagcgcguggcagccgugcgccgccaag\n", + "ccacaucccaggaggccgaggcggcuugccccgcaucucagaagccpcaggcccugagccuucugaccucacauccucugccacaccacaguggagaaaccagaa\n", + "agcugaccupagucgcgauucgugccggccgguccugguucuccggucccgccgcucccgcagcagcc\n", + "gacgcagcgucagcugaccupagucgcgauucgugccggccgguccugguucuccggucccgccgcucccgcagcagcc\n", + "acagcccgcugaggacgcagcgucagcugaccupagucgcgauucgugccggccgguccugguucuccggucccgccgcucccgcagcagcc\n", + "agcacacuagaggaagucgugcuacccccgcggaguugucguguguucuggauucauuccggcaccacc\n", + "agcacacuagaggaagucgugcuacccccgcggaguugucguguguucuggauucauuccggcaccaccau\n", + "gucgaagguuuccuuuaagaucacgcugacgucggacccacggcugccguacaaagugugaguagcucggccgagaupccuuuupccggacaagacpcupuup\n", + "aucaccuagcaguucaugcagcuagcaagugguuuguucuuapuaacagaggaggaaauuguuccucgucugauaagacaacaguggaga\n", + "gacaucaucaccuagcaguucaugcagcuagcaagugguuuguucuuapuaacagaggaggaaauuguuccucgucugauaagacaacaguggaga\n", + "augccuaccuuaaugccucugaaacaaccacucugagcccuucuggaagcgcugucauuucaaccacaacaauag\n", + "acauuuuugauucguuuuuacagagaaaaacuucuacagagauaacaauuauuuugcuuuucagaaggacgcaugcuguuucuuapacacggcugacuuccagau\n", + "gaaguuaguaaaaccgaaucugacaucaucaccuagcaguucaugcagcuagcaagugguuuguucuuapuaacagaggaggaaauuguuccucgucugauaagacaacaguggaga\n", + "cgcggaccccggcgcucggcucccggcgccaugugapcucpccgcppccpcgcuccccgccggag\n", + "gucugguggcugguucpucuacugaaggcugucuugaucaggaaacugaagacucucugcuuuugccacagcaguuccugcagcuuccuugag\n", + "gccugaggagcgcggaccccggcgcucggcucccggcgccaugugapcucpccgcppccpcgcuccccgccggag\n", + "ggagagcccugagcuggcgaagcaaggagcaggcuggcagcggagccacagcacggagcgaggagcucucaacaggugucaggcagag\n", + "caguucuggccacacagaugcauaucuguaaauugaucuaauaaauaaauacugacacauggaagguuuuuaucugcgcagaucacacgaacuacaap\n", + "uaccugcacccuaagcaguucagaguuggcuucuguuuuccguuagcgcuuugcugcacggacaaaugcauacaa\n", + "gcuccacuuaacacuccuguaacagaagacagauuuggaauuuuaacagagaaauacagaauuccugugccaauucuuccag\n", + "guccuuuuucaugaugaugguaguguaaaaggaauugccacuaacgauguapauacaaaaggauggugcaccaaag\n", + "agaguucuugcuuuccggcaggugauggcgccccccgcggccuagagguccagcgcccgccgcgagcagcggacaguccuccuguuguguccgaccgagaguccuggugacuuugaac\n", + "ggccuagagguccagcgcccgccgcgagcagcggacaguccuccuguuguguccgaccgagaguccuggugacuuugaac\n", + "gucuccccucgccgcauccacucuccggccggccgccugcccgccgccuccuccgugcgcccgccagccucgcccgcgccgucacc\n", + "gacuggaggcggcggcagcggaggcgcgagcugcccgauaauggcggccugcagagcccaugagapagaagcggcagcgucuacccugag\n", + "ggcagcggaggcgcgagcugcccgauaauggcggccugcagagcccaugagapagaagcggcagcgucuacccugag\n", + "uggucgguucugugccagugcaaugucuuugccaaggucuggagcuugacugugaugaaaccaauuuacgagcuguuccaucgguuucuucaaaugugacugca\n", + "gacauaucuagaaggagucaucuuugaagcagagagaaagcccucuccagauaccaaaucugcuggcaccuugauccuggauucccagccuccagaacu\n", + "aucaucuaaccuauacugacugauaagccuucuaaaagcaaaaggaagaaaacagcuuuguuaaucgaggccucuucugcaaaguucaccauag\n", + "gagacaacaauggauggucucugcaauuugacaaauauuuugccaguuacuacaaaaugacuucccaauauccuuuugaggcagaaacaccugaauguu\n", + "uggucgguucugugccagugcaaugucuuugccaaggucuggagcuugacugugaugaaaccaauuuacgagcuguuccaucgguuucuucaaaugugacugcaau\n", + "gucacuucaguggaacuuaauaagaaagcuuccuccugauugcuucaagaauuaucaugaucuucagaagcu\n", + "agaaauagcacacaaccacugugagcuguaugcgauucagaaaccaagaccaaauuuugcucacuuucauuaaucaguugcucagauagaaggaa\n", + "cggaggcggcggagcgcaccgcccaccapcucapuccuccgaccpugaagcuucgcuggcugccaggauccccggcap\n", + "acucggcccgcggcgcpcagcgcucagcuugguggcpcggcggcggcggcccgcpuc\n", + "aauuaaapaaagauaaacggagacggaggaaagguggcagccagauuacuuagagaggcacagaggagagagaucpugagucgcc\n", + "cggagacggaggaaagguggcagccagauuacuuagagaggcacagaggagagagaucpugagucgcc\n", + "ggaggcugcuggaaggagaaagaagapugaggaggcgacagapagaggaggaagaagagguagaaggagagagaaapagagaaaggagagaggapuuggaggugc\n", + "gccggugccaacccagcaacugccgccggugcccpccuaucpcacugapcuucgaagcuuu\n", + "acaggucccaccuccuggcucccaggacpucugcaccaaccucaguuucpcugcggcucacagaagucuaaccugcccpacgcccgcaccaacuccugcgcgcg\n", + "cuccuggcucccaggacpucugcaccaaccucaguuucpcugcggcucacagaagucuaaccugcccpacgcccgcaccaacuccugcgcgcg\n", + "cugucgcaggcugcgaggaaaggccccuaggcupucupugcuuggcggcggcggcuuccuccccgcucguccuccccpcccagaggcaccucggcuucagucaugcugagcagagu\n", + "agaucucuuaaaaagauggacccucagcggcgcuuccucguagcgagccuaguggcpuguuugcauugaaac\n", + "gcugcgaggaaaggccccuaggcupucupugcuuggcggcggcggcuuccuccccgcucguccuccccpcccagaggcaccucggcuucagucaugcugagcagagu\n", + "guuucugucgcaggcugcgaggaaaggccccuaggcupucupugcuuggcggcggcggcuuccuccccgcucguccuccccpcccagaggcaccucggcuucagucaugcugagcagagu\n", + "guupucuccpucugagagccugcggagucugccuuagucugauaaucpaaggaupuuugcuucucaaacupuugapcaaacucagcugacguugg\n", + "gucgcaggcugcgaggaaaggccccuaggcupucupugcuuggcggcggcggcuuccuccccgcucguccuccccpcccagaggcaccucggcuucagucaugcugagcagagu\n", + "aggcaaagagugaucauuugccucucaagcagccucuggucaucuaucugccuuugagccaucaag\n", + "gcuuuaugagccugcaggcaaagagugaucauuugccucucaagcagccucuggucaucuaucugccuuugagccaucaag\n", + "ggagaaaguccaupagccggagcgccpacgccaagcacuuccugccgcpcggcgcgccgcagcugcccaggccggaccpccpcgcccgcag\n", + "cccucuucacuuuguaccuuucucuccucgacugugaagcpccpaccugccaggccagaccaaaccggaccucpcg\n", + "cuucccucuucacuuuguaccuuucucuccucgacugugaagcpccpaccugccaggccagaccaaaccggaccucpcg\n", + "guucuacaagcauuuuugcuucugguucagagcuucauaguucucuaacaucagaaauucauuucuugaggaagcagaaccaggcccucaaugca\n", + "agagaagagaaaugaacuguggcaucgcuccugccuucugaacagcucuacuccgauuaaaaaaaaaaaaucucacuguguucuuuguaaa\n", + "cgacaccaaaacaaccccugagaaaauccacaaaucuguaccugagacacgucaagucagcggcccapuucuguuacagacucaagaucucuuuuauuua\n", + "guuaccuugaggauaguuuuguaaaaucuggagucuucaauguaucagaacuuguaagaguauccagaa\n", + "cgcccauaacccapaacuggagucaacuucccaauuggagaaaucccaagccaaccauacuaucaugac\n", + "cuucaapccggcuggapacggcugugagcagcaggccuuggcuccuggcugcaccuggccccgucgcpaagcag\n", + "acuaacgaauuapacacuucaapccggcuggapacggcugugagcagcaggccuuggcuccuggcugcaccuggccccgucgcpaagcag\n", + "aacugaapuuaagagauucggcgucugagccucgcpccucagugguggcggacagagguuugcpa\n", + "gaucuaauccaggaucauaugcugccuuuaggugacacaucccuuuagucuccuuuaaucaggagcaguuucucaguguucaucuuccaugaagucgacauuuuugaagaguauag\n", + "aggacgaccaauuucagauucapcgcggaugcagcauaaaupaaggcacgguuugagaaacg\n", + "ggcacggucucugaagaagauggauupagugugupaaucaauaaaugcgaguucugugaaaugucuugauuuucapugcaup\n", + "gcauucuguaucucuccucuuuccaguauaaagaugaguuaugaggacacucucucuccuuuaaacu\n", + "aggaggcgcugcggcagcgacggcggcgucggcggcggccpcugucgcpuupcgguupcuggcagcugaggcucguggcc\n", + "cuuucacccuggugagacuguccagaucuagucuguaaacccagcuuagaagcacuguuguaaaa\n", + "ccuugcuguuagaggcucuuucccagaaguuggacgaagaggcucaggcguugcuguuucuugucuuccaagucaagugguuacucugguaauggauugccucucuccgag\n", + "ggaaaagcucgauaauuacccagccuaaccauuucucaggugcuugcgaggugaucagaaggcaaag\n", + "aaauacuacccgccggacuuugacccaucaaagauccccaaacucaagcuccccaaagaccggcaguacguggugcggcug\n", + "aaaguuggaaauaauaccuaaaccuacuucuugacauggugucaaaacagagcuuuugcugagaguuugauuuauaaagaaauu\n", + "ggcuguacuuugcauuuugaagagucuaagaauacauuccauaucuucaaauauuuuauugupcaauuuauaauaacauagccupuaaugccaaugu\n", + "agaupauggagaupucpacacagcccccguaucaaaccaaggccuccaggacgcgauuccagacacaaucccuaccucucccugccuaapucucagcacaacaacugccuag\n", + "ggcggaccccggaggccugagcggcaccugcccccagcccccugupccccpcccccagaaaccugcaggacggagccag\n", + "agaagcaacucuuucggacgcggagcuggapaucugaggucaggugucacggapaaapagcccaggccaggacggaccpaaaggacucggcgauguucauag\n", + "accgcagcagcagcagucpagccaggcccagccapccgcpaggcpcgcccpcccuggaugucccgcagcgcggcggccagc\n", + "aaaccaaggccuccaggacgcgauuccagacacaaucccuaccucucccugccuaapucucagcacaacaacugccuag\n", + "uggauccucuauccuucagagacucuggaaccccuguggucuucucuucaucuaaugacccugap\n", + "guugugagaupcucaaauaggaaaaagucuapugaaggagupcaaaguguaauuupaaccaagcagg\n", + "gauagcaaaaccugaucucauaaaaccuaggucacaaaggacagcccugcaaaacagacccuauuuggaucaagugagccaguuccuggaaccugaaua\n", + "cucuccgccgccgguacccacggcccagucuccaccupaaacccccuuggcguggcuuguuucguuacaaguuauccugguagagupcaugaaggccucggaggca\n", + "guguccaucaccuucaaggacuuggccgugcgguucucggaggaggaguggcggcuccuggaggapcagapaguucuaccgagacgug\n", + "gccuucuccugcgcggaccupccgccgccgacgapucgcgugcgcccgcgccapcccgcgccggaaaccgaggaguggcpaggcugagcccp\n", + "acugugccugcagguguccaucaccuucaaggacuuggccgugcgguucucggaggaggaguggcggcuccuggaggapcagapaguucuaccgagacgug\n", + "gccggagguccgugcgccccggccgcggccccggcccpcccagccccgugccccucgccaupccuggcccgcgcccgccggcccugagc\n", + "ggcauagupaaccugucuagcpaagucagcccuggugcaccgcuaucugacpaccuauguccaggaggaguccccugaag\n", + "pcgguuuaagaaggagauugugguggauggccagaguuaccugcugcugauccgagaugaaggaggccccccugagcuccag\n", + "uuugcugccupuggaugcagugguguuuguguucagccuggaggaugaaaucaguuuccagacgguguacaacuacuuccugcgucucugcagcuuccgcaacgccagcgaggugccc\n", + "gauucggccggagcugccagcpaggcugcagccgcpuuguuacagcugcuggagcagcagcggcccccgcucccpaaccguucccpccguugaucuucggccccacacg\n", + "cugcccuugaguaugugcggagucaccccuuggaccccaucgacacuguggacuucgagcpaauguggcgupugucauugugaccccagagcagauugaggaggcu\n", + "guggaggcugcuauuaacaggcaccggccccagcuccugguggaacguuaccauuucaacaupcugcugaugg\n", + "acucgcauuugcccccgaggacaauuacuauauugagauggaguuaccapcugaaguagaaaagucagagcaaaaccacgccugugucuuccuccugccucapacgaacaccuuccuuccag\n", + "agaaaagucagagcaaaaccacgccugugucuuccuccugccucapacgaacaccuuccuuccag\n", + "ccucggccugagcgagcagaaggcccgcgagacgcucaagaacucggcucugagcgcgcagcugcgcgaggccgcuacucag\n", + "acgapcucagccuucccggucagcgguggugacgguaucccagagugccagagaaccguugcuuuuccgaguugcucuucuuccaggcuccguugguggucggc\n", + "cgcccccgcgcgcccggcgccucccucacgcccgcccuccuugccgcccagccgguccaggccucuggcgaac\n", + "gcccccgcgcgcccggcgccucccucacgcccgcccuccuugccgcccagccgguccaggccucuggcgaac\n", + "guuauccaggcugucuuuuuuggcaucugugugcugacugaucuuuccagucuucugacucgaggaagupaaccaggagcaagagaggcagcucaagaagcucaucucucuccpacugg\n", + "guuuugcugauuupaaaauaaagacuauggaucaacuaggaguauuguucguauuauupaaa\n", + "agcucpcugcgcagcpaaggcucgccuagucgguccgcauccgugucgaccaccugucuggacaccacgaag\n", + "acuguccguccgccacugcgcgccagcagguccuggucuccgcucuccaacagcugaaaggccggcgcagugaacacag\n", + "accucuacapcauuuuauggcuuaaggaugacggccuagaapaapagagacuuacuuuggauuaaauuuaca\n", + "acaugcagcuugagcauucagucuucugaccuguuccaccucuacapcauuuuauggcuuaaggaugacggccuagaapaapagagacuuacuuuggauuaaauuuaca\n", + "cacaugcagcuugagcauucagucuucugaccuguuccaccucuacapcauuuuauggcuuaaggaugacggccuagaapaapagagacuuacuuuggauuaaauuuaca\n", + "auguuaacuccacaugcagcuugagcauucagucuucugaccuguuccaccucuacapcauuuuauggcuuaaggaugacggccuagaapaapagagacuuacuuuggauuaaauuuaca\n", + "ccagcccpccgcgcccpaccucauuucggaccucgguuucccuuugcgupcucgcagcugccaccgcuuccccgcggagc\n", + "ucgucuggcaccagcccpccgcgcccpaccucauuucggaccucgguuucccuuugcgupcucgcagcugccaccgcuuccccgcggagc\n", + "acucgucuggcaccagcccpccgcgcccpaccucauuucggaccucgguuucccuuugcgupcucgcagcugccaccgcuuccccgcggagc\n", + "cccpccgcgcccpaccucauuucggaccucgguuucccuuugcgupcucgcagcugccaccgcuuccccgcggagc\n", + "auuauuaugguguggcccugagacupcuuguggaagaacugacugaagauguuuccuuggccapagagagagagagagcuguaaaacacccuugugaaag\n", + "puuggagcgccpaapuccpaccpagucpacupucgcccagccaacg\n", + "aaaaagcugaccuaaugaaacuguggcaacgucagcgcuugaggcuugaagapagacaagcuaaaagag\n", + "gapacuggapagucggagaaaaagcugaccuaaugaaacuguggcaacgucagcgcuugaggcuugaagapagacaagcuaaaagag\n", + "gacgcgcpccacacugcccgcccccuagccuggcgcupccuccpacaaguuggcupuccpcuupacugcaacgcgg\n", + "gcggccgcgcugagccccuagcccgccpagcgccaggccggccaggccugcgccgccgccgccgccgccgucgccgccgcgccgacc\n", + "agcucugagcucuucacccugaccuauggugcccuggucacccagcuauguaaggacuaugaaaaugaugaagaugugaauaaacagcuggacaaa\n", + "gcagugagucagugccggucggucuugupcugapcagcggcuuaggcuccggcgucugcapucgccgagcuaacccguggcuaggcgagupcpcggccggcacc\n", + "agugccggucggucuugupcugapcagcggcuuaggcuccggcgucugcapucgccgagcuaacccguggcuaggcgagupcpcggccggcacc\n", + "cucuucugcccauugagcagucaaagaacugaaaguccuuauaagccugugcaccupccupcccuacagauaagguagcugcuauug\n", + "aaaaaaaaaaaagaaaaaagaaaagaaaaagccaaaacaaaapagaaccuucucccgguagcagcggcaggaacugcaaac\n", + "guacuacugagcgagugugcuugauccapaacgguugaagcacugaaugcaguucauggauucauugcagaaaaaauucgagaa\n", + "uaauupaapaggacagacaauuguucaguugcaaaaagaaacuggagccaccaucaagcugucuaaguccaaagauuuuuacccag\n", + "aaugguuguuuugcggacuuuaaguaggauauaggcaauggcuaauuguaguccuuaugugucugcuaaugacaaauaaauauagcucaucacuauuuacaguccupcuuuucuucuuuuuuaau\n", + "auaagcggaaccuguacuauuucuccuacccgcuguuuguaggcuucgcgcugcugcguuuggucgccuuccaccupcuccucuucguguggcucugccagcgcuucucccgcgcccuc\n", + "aagcggaaccuguacuauuucuccuacccgcuguuuguaggcuucgcgcugcugcguuuggucgccuuccaccupcuccucuucguguggcucugccagcgcuucucccgcgcccuc\n", + "ggaggcgguggugucccggcugcpuaggaguccgcggcagccuccpuaagccaagcgccgcgcagugcugaguucccgcacgccgcagagcc\n", + "cgugugcgcggccpcggaacggaggaggaggcgguggugucccggcugcpuaggaguccgcggcagccuccpuaagccaagcgccgcgcagugcugaguucccgcacgccgcagagcc\n", + "uuuuccuagagccgccuuucucacaugcacguuugcucuuuuucucucagagugccauuaapaaauuacaagaauuaggagcuuauguug\n", + "gugugcgcggccpcggaacggaggaggaggcgguggugucccggcugcpuaggaguccgcggcagccuccpuaagccaagcgccgcgcagugcugaguucccgcacgccgcagagcc\n", + "gaggcgguggugucccggcugcpuaggaguccgcggcagccuccpuaagccaagcgccgcgcagugcugaguucccgcacgccgcagagcc\n", + "cggagcguggcugcggcugaaguagccgccpaaauggaaggacaggcgcaggcccggcuggagccaccaccgcggcgcacggcgccgcuuuggauccgcugcpag\n", + "gugcgcggccpcggaacggaggaggaggcgguggugucccggcugcpuaggaguccgcggcagccuccpuaagccaagcgccgcgcagugcugaguucccgcacgccgcagagcc\n", + "guuuauacuaggucgcgcuapcagcgugaccagccapcggagagaggaugcuuaacuccuuaggcucgaacuccucccuuccuacccaccucucucccuucucguucgg\n", + "aggccagcccupcgccuuaaaaaccggagcuggcgcuuggcaucgccacucupcaggauccaacgucgcuccagcugcucuugacgacuccacagauaccccgaagcc\n", + "acuaaggacccugucaugcccauggccagcacccaccagugcuggugccugccuguccagagcugaccapag\n", + "gguucccaccuccpacuuugcuccugcapccuuggcupuucucucccugcuucagccgcuagcacccuccuugugccugaagcccgcacupaugcuccupcucuugag\n", + "aaaccaucccgcugcagacccugcgcugcuacaacgacuacaccagccacaucaccugcaggupcagacacccaggaugcccagcggcucgucaacgugacccucauucgccpugaauga\n", + "guaggcguuccgagcggcggcggaggugagcgcacggacgagcpapacccuucuccggccugaugcgacccg\n", + "aggcguuccgagcggcggcggaggugagcgcacggacgagcpapacccuucuccggccugaugcgacccg\n", + "ggcpcaggupcuaugguugcuuggagagugcauccggcccgguacuugugaucggaggagagccggaucguccuuccuugaacccucugg\n", + "gccagcccapcccgaagcccacccacucgcgucucuagcagccgcucuuguccucupuacggcucgcpaguguugguuacc\n", + "gagacccagcagupcaagaccgcccuggcacagaucuuccgcagugauggagcccauuuccagaaaagcuacacccug\n", + "cauggaggcpaggagguggaaugaugacupcaguggcupuggccucaagcccaggcaguggaggaaapcpaagcuggcagugcuggcucuuggcugagaupcaccuuugc\n", + "agugcagaggaugcugcgugccugccgcgagccggugccuaacaccugccgcguuuccuucaguccugcucccggagaggupuucugucuugaccucauucugcag\n", + "pauuuuccuuuuccuccgaagcugcugauucauccccaggcuggagucaggcucagcugupcupagc\n", + "gguupcaapcagcagaagcaaaugccuacapaguccacguggccuuccugagccucagagcpugcaggagcugg\n", + "ugacuuugaacagcuuccggaugauguugccaucucggccaacauugcugacaucgaggagaagagaggcuucaccagccacuuu\n", + "cugcgccgcgaggcccgccugcgccgcgaguaccuguaccgcaaggcccpaggaggcgcagcgcucagcccaggagaggaaggagcggcugcggcgcgcgcuggaag\n", + "aaaaccgccugauucccacugaguuacgccgagaggcucuggccuuacapucccuggaguuugaugaugcuggaggugaag\n", + "aaaaccgccugauucccacugaguuacgccgagaggcucuggccuuacapucccuggaguuug\n", + "ucuggaagccaggcpcapcagagaccccggcuccugcgccccuccuagcucccagagagcguggaucgcpcpcucaccgagcgag\n", + "ccaagaugguggcgcccagagcuucgcucuugcugcuccccugaggugaacugaagccagcagccccgcauc\n", + "gugaggacccuugaccucuggcccaagaugguggcgcccagagcuucgcucuugcugcuccccugaggugaacugaagccagcagccccgcauc\n", + "ccucuggcccaagaugguggcgcccagagcuucgcucuugcugcuccccugaggugaacugaagccagcagccccgcauc\n", + "gucagguugccgucuagguagcgguugugcuugcugaggcugcacuugcugacacugcagcugcgacgcggcuaagaggcgcagagcgaggagucpauuuggucgcgagcggcgacg\n", + "ugagguuuggucucuguugucacaacauucaguacaaucugcugcccaggaccuggacauugacagauaaa\n", + "gugcuugcugaggcugcacuugcugacacugcagcugcgacgcggcuaagaggcgcagagcgaggagucpauuuggucgcgagcggcgacg\n", + "cugucagguugccgucuagguagcgguugugcuugcugaggcugcacuugcugacacugcagcugcgacgcggcuaagaggcgcagagcgaggagucpauuuggucgcgagcggcgacg\n", + "gaaauaacucugaaguaagagaaacugcaauagaaguuggaaaaggaugugauuuccauauuucaagucauucaaagacagaug\n", + "ugucagguugccgucuagguagcgguugugcuugcugaggcugcacuugcugacacugcagcugcgacgcggcuaagaggcgcagagcgaggagucpauuuggucgcgagcggcgacg\n", + "agcauuugugcagaaugucaucagaugaggagaaauacucacuuccaguugugcaaaaugacuccagucgaggcaguucugucucuucgaaucuucag\n", + "acagcpcgucaccucggacauacgaacagcpcgguguucccggcuccgupccgucuucccggcgaguccgcgacggucgccgcccacggcgag\n", + "gaacccuuaacauucapauguggccauagaauucucuccagaagaguggaaaugccuggacccugcccagcagaauuuguauagagaugug\n", + "ucgcucuguaaccugcpuauuggaugauucguagcuaagacuucgcgacacccuugaagcugagaa\n", + "ggcacacugauaauucuuguaucuugagaguggaccaaguuuupugacauggcccapaauaauuaupcagaccagcaacpuggccgaugaaucacccaacaugcugguguacagaaag\n", + "agucucauucuguagcgcaagcuggagugcaguggcaggaccacagcucacugcagccuugaccuuccaggcucaagagauccucucacuucagccuccupuagcupaucacag\n", + "caapaucagagcugauuaugaauaaagaugaaagacuaugugcuacuuuaaccugcacuaaaucaaaacuuuucauccguguagcccagaaucauuaaaag\n", + "augacaugaccuuauauguagaagaucccagagacuucacaaaaauuguuagaacuuggagcaggaaaauca\n", + "caucuuugccggcugaauuauaaaagaaaaaggauccguaucuuccuaguacaacgaugaaggaagaaaauuauguugaugaugaugaugaugaugguguuggugguggcaucaua\n", + "agucucacccugucgcccaggcuggagugcaauggcacgaucucggcucacugcaaccuccaccucccgaguucaagugauuccccugccucagccucccgaguagcugagacuacag\n", + "gugcuacuuuuacugacugguuuaccucuuaugucaaaaauguuguaucagguggcuuccccaucaucagagaccaaauuuucag\n", + "auauguucacgauccagaauguguagcaacaacupauauuacugugucaguuuccacaucguuucugccagaacuuagcucuguacauccaccccacuauuucuucacauaccgaaucag\n", + "gauuuccuaaucuccaggaggaaagaaacuagucuuupaguuaaaccgacuaauuuaacggagaauuaccaauguggag\n", + "ucauuccaucaucucugagccagcagagcaaucccccaaagugcuguuaguuccccaaacagcuccagccgaccccucuuuaggucagaacauagcuaaucccuuaaucccauuuucugaugaa\n", + "aguguucggcupcaggcacgcuguggcuggcuacuucccuuccucccaucccccuupccaaacpaucggugcuucug\n", + "ggccuuccugcugucccugguggcaccaguggcauugaugguggccaggupcagagccupacccagagaaguuagcccaggaacuggcagcaucgcucaccag\n", + "gacacuggaccugcaggagcagcugcagucucugcgcapagcuggaacagguggcucagaapcgagccagacggucucagagugccgagcugaacapauuuaugcaaagcccacag\n", + "gcggagucccggcccpacacaagauggcggcagcggcgcupapcgaggcggaggcggcaaaacpcggucgagcagaacguguagccgcguccccuccaguccgcuccpcag\n", + "ucauuugcugauuguguupaugagcugccgupaupaagcapuuugacccucagauuggugucuacuacaucgaucacaucaaca\n", + "aguguggccupcugacuaauguacacucucuacaccccuaagaaapuuguggaacucugagupcuguggaaguauuuucag\n", + "auaaauugugcaapugcuauagacgcacaaacgaccgcgagccacaaaucaagcacacauaucaaaaaacaa\n", + "agacuaagcugcaacacuggcagagccucccaaggaapaggapaggacagaggccaaggcggcuccuggccacccucgcagcuuccucccucccuggccacaaggacccaaagcucagap\n", + "gcuggacugcgccgccggagcgacpcuucpucggugcaaggcaggcgcacpaapcgcgccgcgcggccgccaccccacc\n", + "ggapuuuugcucuuugugupugugugaguggcuaugauccuaguuguccagcugcugcguggagaauaaguaaagcag\n", + "gcaguccgccuugcgcaugcgcaggcggcgguggcaaggcuacgguucgcgccagcggccggcgcu\n", + "cugauuaccgccaugcuccaagacccgcacugacaguccccacgugapaccgcggupaguccuaa\n", + "acucugauuaccgccaugcuccaagacccgcacugacaguccccacgugapaccgcggupaguccuaa\n", + "gcpaaguuaauccucuuccaaucagcuccccaucucgcccucuggcggcuccggaccacaggccgaguuacucugauuaccgccaugcuccaagacccgcacugacaguccccac\n", + "acaggccgaguuacucugauuaccgccaugcuccaagacccgcacugacaguccccacgugapaccgcggupaguccuaa\n", + "cucuuccaaucagcuccccaucucgcccucuggcggcuccggaccacaggccgaguuacucugauuaccgccaugcuccaagacccgcacugacaguccccac\n", + "cucccguucucugucaucgguucccucaauggaguccacauguuupcagaaucuggaggugcagcugagcucugcgaggaccgagaacacgacugug\n", + "caucacccucauuguucugucaucugaggupcaucucugagcugaggcuggagagacuacuccaa\n", + "gugcaucuuagagacugguguuugcaaguauauggagcaggaaacuucaucccgaagauggagaccccpcugucagcaggcguuag\n", + "gccagaauccagcacuccaagcacugcugucuucucacagagucuugaagccagagcagcgccagg\n", + "uagaugucagagcuggcucccgguupauaugagugacuuuguggaggauggcgccuaaaugag\n", + "gcuuuauaagucaguggagccugcggaaguggccagaauccagcacuccaagcacugcugucuucucacagagucuugaagccagagcagcgccagg\n", + "cggagauccagcacuguuuggucaacgcuggcgaugupuguggcguguuugaauguuucgagaacaacucuugugagauucpcuuacaupauuugc\n", + "cucuapcgcugccccgagacupupapaaagaagguggugcgaaaacgcguuugaacuupuccugccgcugcccguagccggcguccccaac\n", + "gucacgcggucagcuauugacacuuccuggupauccgagugaggcgacpuapuuggcgcucaggcggcgacc\n", + "gcacacgcuggucacgcggucagcuauugacacuuccuggupauccgagugaggcgacpuapuuggcgcucaggcggcgacc\n", + "gguaagaagguggauggcucuguaaaugccuaugccauaaaugucucucagaagaggaaguacag\n", + "gcagcguccggagcagccgcagccuucuggaagcuccaggcggucuuucugccgagccucggucccggcccccauccuccccgccccaucgguuguugucupcgg\n", + "ggccagaaacggcaguggcagcagcguccggagcagccgcagccuucuggaagcuccaggcggucuuucugccgagccucggucccggcccccauccuccccgccccaucgguuguugucupcgg\n", + "gaagaggcagaaaaacaagagauaacaaaggcuccguuuccuuucugugagagaaggcuuuugucuuuccuccugcuacg\n", + "guuaguucuacagaagaggcagaaaaacaagagauaacaaaggcuccguuuccuuucugugagagaaggcuuuugucuuuccuccugcuacg\n", + "ucuuugacaaugacuaucuggaugacacaggaaggaugcaauucuggccuuggagagaaaacuugcaaggaaaggaacauguuugaauuucagauguguuccucaaugaaucac\n", + "gaucuucapaauguuucagguggaggaapcucuuggucaaugagccugaagacugcauggcaaccuuugccagcuuuuggccugaaaacucaacuucuucauuugag\n", + "auuagcaaaagacuguugaaguagagagcauuuugcccagcucacucggauucuuugcuggcaugccuucaguuucaguugucauccagagaagucaaaggaaaugcugcuupaugagcau\n", + "cacgucuccuuccugccaucuugugaagaagugccuugcuucccuuucaccuucugccaugauuguaaguuuccugaggccucuccagccauccugaacu\n", + "gcaaaagacuguugaaguagagagcauuuugcccagcucacucggauucuuugcuggcaugccuucaguuucaguugucauccagagaagucaaaggaaaugcugcuupaugagcau\n", + "acuuguuacauuuacugacucucauggugguggagauggauuuuuuccuagugugccugugugugg\n", + "ggcaguuucaugucauugaguagaauugugcggaaugcuuuuauggagugaggcuucugcguuaaacuugugcugauuccag\n", + "gagaaucugagcaupaauaaagucaggaaggaucgcaagugaggauuauauuaauaugauaauuagcacg\n", + "acacauuuuagguaugugauuagaaaacauacuugucagaauugucuggcuggauuaauuugcuaauuugaccuucuucaucauuugaugug\n", + "gaguaggaaggagccpcuguagccggaguggagcggcugccagccgaggagcaggcgcggccgcggcgccauauugcggcccucagcggccgcgaccgaguc\n", + "cggcugagccpuupcccpuupccgcccpacucuggagcauupauuuguagcgcgcccucupuaggcggcuguagcggagaggcgugcpaucp\n", + "cccpuupccgcccpacucuggagcauupauuuguagcgcgcccucupuaggcggcuguagcggagaggcgugcpaucp\n", + "accauugcccucuugaacauuuaccguaacccucaaaacucuucccagucugcugacgguuugcgcu\n", + "gacgucucccgapcgucggcapucggcggcgucggcagcagugucgacggcagcggcggcggcpupaa\n", + "cucccgapcgucggcapucggcggcgucggcagcagugucgacggcagcggcggcggcpupaa\n", + "acacguaagcagcacagugaggccaccaacagcagcaaccgagucuucguguacugcgccuuccuggacuucag\n", + "cuccggagaapucuggucgaaccacggcugugcgcucacgagaggaaaccucaccuacuccgucugccgcugcacucaccucaccaacuuugccauccuc\n", + "agguuaagaggucccguucucacagacccucaggaauuucacuuggcuccgagcuuugaccuccgagagagcc\n", + "ucugcaccagccauggacugcuacacggcgaacuggaacccacucpacucugccuuuuaccg\n", + "gaaauaugagcuguacagcauggacupaccugaaggaggaacucapauugccugguggcugcugcacccu\n", + "ggaagugccggccuggagcccgcucuaggupuguccccucggugcuucccagcugccgucugcaccagcc\n", + "ccgucugcaccagccauggacugcuacacggcgaacuggaacccacucpacucugccuuuuaccg\n", + "gauugucaguggcuucgccccgaggagagcugacugcccupcugcugccuccggcagagcugagccaaa\n", + "uucuuggcgcuucuccpuugugcucuuccguacucggaucgcuucuuaggaguauccuaacugccg\n", + "ggccccucaaccuggagcggauaaauucuuggcgcuucuccpuugugcucuuccguacucggaucgcuucuuaggaguauccuaacugccg\n", + "uugucaguggcuucgccccgaggagagcugacugcccupcugcugccuccggcagagcugagccaaa\n", + "gcgucucugcugaucugagucuaacugcagcauggaccupuuuucccugaagcaucuccapcuggapacgaccgccaug\n", + "ccgaguguccacacccugugcgucucucuguccugccagcacugapcucauccauccgcagagcapcagupaggagacgcc\n", + "cuccgaguguccacacccugugcgucucucuguccugccagcacugapcucauccauccgcagagcapcagupaggagacgcc\n", + "ggaggccpuggcgccggccpcpagcccaaaagaccggcugccgccugcuccccggaaaapcacucgucuccgupuguggcggagcgcgcggugcaug\n", + "caaaagaccggcugccgccugcuccccggaaaapcacucgucuccgupuguggcggagcgcgcggugc\n", + "ccaaaagaccggcugccgccugcuccccggaaaapcacucgucuccgupuguggcggagcgcgcggugcaug\n", + "cccgcuuuugcggacccgcccccagucugcgucapacagaccccuccgcccuggaugagcccggcpaagcuucgcguagcaguuucupaaacag\n", + "cgugcauggcaggcauuugcauucaugacccuuccguguacuugaacugaaaaccugaagaaacuggccaacagauuaggcagccaucaauccacaucagauggccccuguauuuccaagag\n", + "gugcpcppcucguccaccpcccgcuaucccugguucugcgcugcgcgguccugcuggugaccuucacggcggcgcgugcccugcaccag\n", + "pacuacpaauucgucaucaaagacccugaugagguggcccggcugupcguucgcaagugcaagccccag\n", + "cucucuugccugccgccaugugccuuucgccuucugccgugauugugaggccuccccagccauauggaagu\n", + "gaguugcugguagugcccguggugcuugguucgagguggccguuaguugacuccgcggaguucaucucccugguuuucccguccuaacgucgcucgccuuucagucagg\n", + "gcggcucupcucggcuuugccgcgcucgcugcacuupcgagagcuggaacguggaccagagcucggaucccaucgcagcuaccgcg\n", + "cucgccgcucgcggcucupcucggcuuugccgcgcucgcugcacuupcgagagcuggaacguggaccagagcucggaucccaucgcagcuaccgcg\n", + "pcgcupaggapcugcugcucgccgcucgcggcucupcucggcuuugccgcgcucgcugcacuupcgagagcuggaacguggaccagagcucggaucccaucgcagcuaccgcg\n", + "gucuccacacaagucccggcapcuucuupcggaggccacgccgaccaauaggaacccacuguguuccuacagguuacgaagcag\n", + "cgcgcucgcugcacuupcgagagcuggaacguggaccagagcucggaucccaucgcagcuaccgcg\n", + "uuugccgcgcucgcugcacuupcgagagcuggaacguggaccagagcucggaucccaucgcagcuaccgcg\n", + "gugcccaggaugguapagauggaaacacauuuagcuguuaguuugucccuguguuuaaupugguaaauauaaguagaaaauaaauagagaacuuaaguaaauacaguuugaaaagcugcuc\n", + "acaaacgaaagugauuuaagaaaauuuuuuucccaguaupucugugaaagaagugaagauuguaa\n", + "agcugcgcacgaggccagcggcpucgcugccguugaggcuucccgccacugcugcuggcggauuugupc\n", + "aagcaaacaacuucaacuuuccaugagugcuagccagcccupaggcuccgcugccagaaggaacgucaagg\n", + "gccucuccccugguucccgcacccuggccggcggcugcgagcgcapcccagcccpagccgcuggagcag\n", + "gccgcccapcugagucucccaucucgccccucgguccgcapccugcgauggagccugcagccccpucgcgucccucccugagcgcccccgucggcggcc\n", + "guaaagcaaaggauaauguuaaacuguuagucucucuuggcuuuacagaaaagauuugcugagauauauuacucuaaaacuuuuaugaaaagcuaucuuucaa\n", + "agacuaacuucaugagugcaauuuaacauaucucuaagaaguauccauuuguguauauggagaucaaaacauuucugcuucugucauguauuuucugauuaaauuuag\n", + "cgguuaagaagauugucuaccaaauauagaacagaaaagauauaucccacagccacuggagaaaaagaagaaaauguuaaaaagaacagauacaaggacauacugccau\n", + "uugaucacagccgaguuaaauugacauuaaagacuccuucacaagauucagacuauaucaaugcaaauuuuauaaag\n", + "gucgaggcaagguaucuggcugugaccpaggagugcagaucguggcugacagaggaacpuauugag\n", + "ggcgucuaupccaaaagcauauguagcaacucaaggaccuuuagcaaauacaguaauagauuuuuggagg\n", + "aggapucgaggcaagguaucuggcugugaccpaggagugcagaucguggcugacagaggaacpuauugag\n", + "gguuguuucccggcuuaggaggcggugguugcggcugcugcuccuacggauauugcgcaagacupcguuggaaacccu\n", + "gucuuaggapaaugauuccccaguaauauucccugcccugacccaaagugcugguuggccucccucccapaagacugcuucuugcguaacgccggccacagaaagagacuccg\n", + "gacuuccupcccugaagcuccaaggacaaaagacuccugucccuuuucccuuccucuccauucupucucccaccaccaccaaguccu\n", + "caucaggupcugagucgauggaucacpagccccccagcccggccugcaucccugapcagugccccucgcagucaggugucucggcggcccccacaacacag\n", + "agaccgcccucagcacaggaccugcccuggcuggucagcccugccupcacccacagccccagcuguccag\n", + "aagaaaaguugcuauauuuugcaaaagacauaaaucuacagauucaagaaacugagugaaccccacagaag\n", + "agagcaggcuggaacccagcupuuccgccucccpaagguggucuccauucgucgcucugcaucugguuugucagauccgagag\n", + "acucugcucucggccucccpcugcpacpacggcugccggcgcggacuuugcpccpagccgaguccaggacagagccggaaccgccgapaggcgagapcagugcgcggag\n", + "cucugcucucggccucccpcugcpacpacggcugccggcgcggacuuugcpccpagccgaguccaggacagagccggaaccgccgapaggcgagapcagugcgcggag\n", + "gcacucugcucucggccucccpcugcpacpacggcugccggcgcggacuuugcpccpagccgaguccaggacagagccggaaccgccgapaggcgagapcagugcgcggag\n", + "aggagacggcguuccguuagcggcguupuuuggcugcaguggcagugcuuucucuucugcucacpacccgcucaggcuggaggccagccag\n", + "gacggcguuccguuagcggcguupuuuggcugcaguggcagugcuuucucuucugcucacpacccgcucaggcuggaggccagccag\n", + "aguucaaggcagccuucgacaucuucgugcupcgcugaggauggcugcaucagcaccaaggagcupcaaggug\n", + "uugcugguugagaagacaacugacuccccggcggcugaguucucgcugguggaggacguggcgcugcacuuugccugcuug\n", + "gugaagcuggaggagaagcagcaccauccaugccagaagugcccacgaguuuucaacaaccgcugguaccuggagaaacac\n", + "aaucucuccagcuccccugagcucpaggcacggagccucuucuuupcacaguguugucgcuupauuguccugugcagcacucpaggucacuuguuaaaa\n", + "gacuggcagccacccuuugcuguggaaguggacaacuucagguuuaccccccgaauccagaggcugaaugagcuagag\n", + "gcccagacgagagugaaacugaacuacuuggaccagauugccaaauucupaaauccapcuccuccuuaaagauucccaauguagaacggcggaucuuggaccucuacagucucagcaaa\n", + "aagaugccucuaauggaggaguuucugagcagcaccccuggcccaguggcuuugaaapagcucaaaccagagacuauuucaagcccuggauaucauauccugapccacaggagaagagaac\n", + "gagcuggcgcagcugcccugguggcaguggcugaaguggcggcggcuucggcggcugcggcggcugcaacagcuucpcucpuuuuggcggcggcgccggcpcuaggcugcgcg\n", + "cgagacucggugucugacugaccuuucuuuucaccauucaauuuauuguuccgcucaguuguccccaccuccugaagucugaccaaucagaagcaccgccauuuugaccuuucacca\n", + "cccuuuccuccuuuggcuuaagccuuuggcaggacagauuuupcuggaggccagcaauucaacupapcucugugccaguucuugccuuucugaag\n", + "auggcggcagcuaugccauccacgacucccaggcccccagucucagcucupugagaguucccccuccagccccgcacacaacupag\n", + "agaaggcgagacucggugucugacugaccuuucuuuucaccauucaauuuauuguuccgcucaguuguccccaccuccugaagucugaccaaucagaagcaccgccauuuugaccuuucacca\n", + "caagcaccaaagcagapcaggcagcacaccacccagcagccagagcaccagcccagccaugguccuugag\n", + "pucccupccgaupaucacgcagaagaaugcgagagaagcagccuuugagaapaagucacuaucccagagcccaggcugagcgg\n", + "uuucucggcgucuaccgaggagccgccccuuucucagccuugcucggcucuuccccgcucuggucgccpcugcgccguccccagcucag\n", + "apcccccuagacucagagaagcuggccgccpcpccpagaacagcccgcpcguccagcgugccgaccacaaagcucuucgcggugcccgcgcgcaccacucuccagccgccccgcgcc\n", + "gaaucugugccauccaaauugcuugauccagugaaucugcuaggaaaggucucugaggcccccgucugcugacugcaugacaaacccuaaaggaa\n", + "guaguaaccpaagcagccgucggcggcugcccugagccuuccupaaggaggapagguaggcgcagagcgcgguccacgccugcucgccccgaaccaupaagaugagacag\n", + "paagcagccgucggcggcugcccugagccuuccupaaggaggapagguaggcgcagagcgcgguccacgccugcucgccccgaaccaupaagaugagacag\n", + "gaaaaaccucgupcucagcccpagaaapccapaaguupugguucugugcuuggucuguca\n", + "agaucaaaguuuuacgaapugaaggaggagaaugaucggcgagguggauuuauucgcauauuuccuacaucugagacaupaaauauaugg\n", + "guucaagcgauucuccugcuucagccuccggaguagcupauuacaggcacgugccaacacacccag\n", + "auuguucuacaagcuaaauuauuccuucaaaggagaggagaauuguauaaggucacagacguggauccaaagccggagccugagcagagguggccacgcuggapucuugaccuaaagugug\n", + "cauuguucuacaagcuaaauuauuccuucaaaggagaggagaauuguauaaggucacagacguggauccaaagccggagccugagcagagguggccacgcuggapucuugaccuaaagugug\n", + "accccgaccuucuccuuuggcauccucaccuacugcuccuggccucapcaacaguuggaaccagagcugcgugaccuucaguucccuggaggauauuccugacuuugccuggaag\n", + "pcugaggcacugagagaccggaaagccuggcauuccagapapaaacgcagcggcauccccaggcuccag\n", + "guccggugcagacucugcuggaagucuuggacgccupuuapucuccacuucupcup\n", + "agacupcupcaggucugagaguuapaaaguccguucccacugcccucpagagaagaaaggapcaapagaagcugcuggucggacucaca\n", + "aucauucggcccucagacupcupcaggucugagaguuapaaaguccguucccacugcccucpagagaagaaaggapcaapagaagcugcuggucggacucaca\n", + "auucuaguugccaagccucuaaagcagaagcaggagucauuucuccagaccuagcuggccuguucagupuuaucuccaccaccucaggaaagcuauucugaucaaauuucuuc\n", + "aggacgccgcccggcgcggaguggcugcccugcgcpacacuuagagcccggupcpaggaaggcggc\n", + "cuuaaaugcagcuccapuugcgaggcacccaccagcaucauuccccaugcgagguggcaaaugcaac\n", + "caguccacuuaaaugcagcuccapuugcgaggcacccaccagcaucauuccccaugcgagguggcaaaugcaac\n", + "aagugcagccgcccgccucugucacupagacaguccacuuaaaugcagcuccapuugcgaggcacccaccagcaucauuccccaugcgagguggcaaaugcaac\n", + "acagapaaacggcucucgcagcccgaggapucaggcgcggagcuugucgcaccucccgcgcauucuguccagcccpcuccggag\n", + "gcaggacugagcagcuaggcgcgagcgaaaacaaacagcupcugcgagcgcccccgccccggccccgagagcacgccggcccagucccccaccupcgcccgucugcccacc\n", + "auuccacgcggcucgagcccgcgugcpccucuuucaggccgcuccuaguggacgcagaggcpccgaggacg\n", + "gugccagcccccaggccccaagaggagcugguccccaggacagaggapagaggagcaagaggcuccccupccccuuccaggccccaccuccag\n", + "gupaggcgccacaacuucacugccauuuugugaggugccgccgucucuccuccagcaaggucaggacuucaggacu\n", + "gcugcucgcugcgccaccgccucccgccaccccugcccgcccgacagcgccgccgccugccccgcc\n", + "aggcauuuccgcccacgupaagcuaugagguauagacccggcuagaaucugaagugcpagagugcuggacccugagug\n", + "ggaguuaggcauuuccgcccacgupaagcuaugagguauagacccggcuagaaucugaagugcpagagugcuggacccugagug\n", + "auuaggaagaaacagcaagaaguagupuuuuuuggaagcgaauaaaaucgacuuuaaggaauuagauauugcuggagaugaagacaacaggaggugg\n", + "caggagccgcggcpapcgucuupccuggaggucaguguggccucgcguuugucuucggugacpaa\n", + "gaagaaacagcaagaaguagupuuuuuuggaagcgaauaaaaucgacuuuaaggaauuagauauugcuggagaugaagacaacaggaggugg\n", + "aguggaccccupcugcugccagccccgaccuggcacuugcuugccugugucacugucaggauuugucuagcggcgcauucccugacapuguguuppaguccucuuuccaacugucgaa\n", + "ggaggccccgucuggccccuccccagaaugugacgcugcucucccagaacuucagcguguaccugacauggcucccapcuuggcaacccccaggaugugaccuauuuuguggccuaucagag\n", + "cucucccacccguagacgguggcgcgaaguggaagagugugcpaaccaaggagcugcuauguucu\n", + "uuuaccacaguaguuugagucauuuccacaucuugcgaguccuuccgaacgagucuccuuuccuupcucgcaaccaccca\n", + "gcuacggcpcggapccgaaaguccaguaugupuccapucacucuucuagagcuuccgcaacggaaagugugag\n", + "gcggucgaagcucacgcgguaagccgcugcacgugugcuacggcpcggapccgaaaguccagu\n", + "gcucuaaucgccugcacgaagaaccccgcgcugucuggcccacccuucacaguauccgaccpcguccugaaccgccgccagcucuaucugaccaccucggcgcpacuuucgguucuaucccaa\n", + "gcauccacgccaggccagaaggaccapcuggaaacucgccuucapcuccuaagcugcugcggagcuagacggcpcugugg\n", + "aauuacupacaugcgcguuccggccgaappuaaauuucccaacuccaggaauuuguggcggagapcaaauaacugcggcucucccggcgccccgaugcucgcacc\n", + "aacuccaggaauuuguggcggagapcaaauaacugcggcucucccggcgccccgaugcucgcacc\n", + "augcgcguuccggccgaappuaaauuucccaacuccaggaauuuguggcggagapcaaauaacugcggcucucccggcgccccgaugcucgcacc\n", + "gguuacucugguuacupccgcgccgcgcuggcgagagccgccgcccgcgapaugcuggugaggaagccgucpagccgccgccgccaucugapag\n", + "agcuggcugagacgcguggagccuggcggcgagupcgugcgacgguuacucugguuacupccgcgccgcgcuggcgagagccgccgcccgcgap\n", + "auacaaaagauguaguapaaaaggagcgacagcuggcuaaapccccccacaacccuccccgacacccuaggaaagcagccucucuccgcugucccapugcc\n", + "ccucaauugacuuggauuuccuugaguucggugucuapagccaaguguupcuguggaagguagaugaaugcuccapauagagaccuguaucag\n", + "augaaacagcagagcugaaaagagagaucaccaaggaaagugccugaaapauuauucccacgccuccaaaggauccuggcaggcugugccugaggagaupuuccaauuuuag\n", + "ggcpuguccccuucuucccucaacgcuccacgugcgucccuccugaagcugcgugcucagucaaagaggacgaccauccccaauaaaggaggaccagucuucagucaagg\n", + "cuccauugucupaauugcagccgcpcpcggcggcggcggcggcggcggccpacccagcpccag\n", + "ggagcgcggcgacuaucacgccgcguggcggacggacggacugacggacgcgcagccuuacccgaaaggcc\n", + "ggcggagcuapcpccccugcgucucupcgcuggagcgcggcgacuaucacgccgcguggcggacggacggacugacggacgcgcagccuuacccgaaaggcc\n", + "gucucupcgcuggagcgcggcgacuaucacgccgcguggcggacggacggacugacggacgcgcagccuuacccgaaaggcc\n", + "augcugcagapagaggacaacagcuccaguaaacaaaaaggucapcagacaggaguauuauggaacugcuccaggacucuugauuuucaagcuu\n", + "auggugucaggaaupaucuaaaguggagcuucuagcgacccccaggagcacugagugaacaugcaagguaccugcaggauccacuugugucuauugaucucucacagcagcupaucacag\n", + "gucuaugccacuguuagaaucaggcuaacucuucagaacuucccccuguagcaaagcucacuuuggccagaguuggaacuacuuucugcag\n", + "aggaaguugcccauccuccucgcccggcggcagcuguccccgaggcpaggagcccgapcgcgagccccgcau\n", + "gaaucauuguagucaaucauuuuccaguucucagccgcucaguugugaucaapacacgugguuuccgaacugccagcucagaauaggaaaauaacuug\n", + "gugaaucagcucccggccgacuuuaggauucuucuggauuuuaaauuuuuucuuuuuaaaaaaacuuggacggauaaaag\n", + "ucaguggagaccaaauaaugcaggugaauuaccuucguggccauuacugccuccaacgaaguguguuuauuaagaacaguucuuaugucauucuuaag\n", + "aauucaaggaagccuucucccuauuugauaaagauggcgauggcaccaucacaacaaaggaacuuggaacuguc\n", + "gcauccuucuuuaaaagagaaauccacguuagcucuccuugaggucucgaguucccucggcuggaggcacagguucaguggagaccaaauaaugcag\n", + "gccgugccguuacucguagucaggcggcggcgcaggcggcggcggcggcauagcgcacagcgcgccuuagcagcagcagcagcagcagcggcaucggag\n", + "aaagupcguggccggacauguuucucuugaccuaucuuccacaucaucaagcuguuacpcgaaaccuuggucugaaacaugcggccagagaaauaaaucucaggauccggcaggugucaaa\n", + "caggcuuugcagaguuuagagcauauucuacccaacuggccccagauggaaaauacugucuugaaauuggauggcuuuuuaaguguagcucuccacagccugcucaaagaaaaaaaaaaa\n", + "guucaucgugaagaauaaaugagauaagcuaccucaagugccuguaccaaaauagacucacaauacau\n", + "ggcuguucucacauuucaaugcacucaccuggapcuuaccacaacaaagauggccggaccccugcccagaguuucagauucu\n", + "agcuccgcggcapacagcuuccuccggacgcuuggcpcuucgcucucgccuuacgacagcccggucggauc\n", + "gcugcggaaacpacugcggccacuacuuccggcguguaccgagagacuggcguccggcguguaccgagagacuggcguccggugugcagguggccac\n", + "uuuuucguugaagcaacgacuuuggccggaugacuccccapucggcaucagcgupacupaacag\n", + "gacuuuggccggaugacuccccapucggcaucagcgupacupaacaggugaapaaacagaagagagccugagaagaccgcucuccuccgauccuaauugacugagcca\n", + "acuacuuccggcguguaccgagagacuggcguccggcguguaccgagagacuggcguccggugugcagguggccac\n", + "cugagcpugcgcpcaacuuccggugupugacgagugguggccgaagcapacagcaapacgcucaggcpacc\n", + "guucugapacaggcugacguggaggaacagaggcccccggaggagcacugaaggagaagaucu\n", + "aaaggaucacgcgccccagucgacgcugagcuccucugcuacucagaguugcaaccucagccucgcu\n", + "ccggagcaacccgcgagcuuacaccggcuucucucuguccucagcccgcgcgccgccaucgccguc\n", + "gcuccggagcaacccgcgagcuuacaccggcuucucucuguccucagcccgcgcgccgccaucgccguc\n", + "cugcccgccgccucgaguaguggaggaccugaaagcgcgcccccpccuccccccgcgcaacuuccuggcugugccaccgcggacag\n", + "cuauccagucaguucgcugcuauucccaupucacaggagacagaugaggaguuugaugcucgcupuaacauacuucaacaagccagauauagaugccupaauugcguaaag\n", + "ggaaauagcaccpcgccgccacaguagcuguaacugccaccgcgaugccgaaggcgcccaagcagcagccgccggagcccgaguggaucpacggagagagcacgagcccaucag\n", + "uucuuugaagagcuggcaguagaagauaaacaggcupaagaagagaaagugcucaaggagaaggagcagcagcagcagcaacagcaacagcag\n", + "caaaaaaaaaagcgagauacccgaaaaggcaggcggaagaaggauguggaugaugauggagaagagaaagagcuc\n", + "gcgccagcuuggagagccagccccaucpuuccccgccgccggaagcggaaauagcaccpcgccgccacaguagcuguaacugccaccgcg\n", + "agaauccccgcgugccccuuccucacuacccuccaaaucccgcugcagccauugccgcagacacg\n", + "ggccggcgccccgcccccuuuacugacagguugcccaccucccccaacgccaccccgcuucgcaguagacggacagaggagucguagcggucgaggcuuuugcggcuccggcgugccggaaagugc\n", + "gaaaacgucaauuaugacagcagguaauuuuaucggaaguguuuauaacuauaucccaguacguggaacgaaaaaguuaucaagaaauauuuauugaauguaaaaaag\n", + "acugacagguugcccaccucccccaacgccaccccgcuucgcaguagacggacagaggagucguagcggucgaggcuuuugcggcuccggcgugccggaaa\n", + "aacgccaccccgcuucgcaguagacggacagaggagucguagcggucgaggcuuuugcggcuccggcgugccggaaa\n", + "upaggccupccucugcgguuuaauccagcapaupcucauuccgcaauuuaaagagagaaauaaguuggcuccagagg\n", + "gcuucgcaguagacggacagaggagucguagcggucgaggcuuuugcggcuccggcgugccggaaa\n", + "gaaaacgucaauuaugacagcagguaauuuuaucggaaguguuuauaacuauaucccaguacguggaacgaaaaaguuaucaagaaauauuuauugaau\n", + "ccgcuucgcaguagacggacagaggagucguagcggucgaggcuuuugcggcuccggcgugccggaaa\n", + "guaaaccaggugcggupappapuggaggcggapuppaapapapaggaggugacucgagcauuuagacacaagcgagaggauc\n", + "pacuccgcggcgagccccgcgagupuccacguuuggcpcgcggcpcggcgcpaacaaggcaggaaag\n", + "gaaguugcuggcugacupcuugcgaggaaaccgccucggagcugcagccgaaggccaaggaaucacugaagaucggcgapaggacapuucauc\n", + "guggaaguugcuggcugacupcuugcgaggaaaccgccucggagcugcagccgaaggccaaggaaucacugaagaucggcgapaggacapuucaucaugg\n", + "cccgcccccgccuggaguccgacguggaaguugcuggcugacupcuugcgaggaaaccgccucggagcugcagccgaaggccaaggaaucacugaagaucggcgapaggacapuucauc\n", + "guucuccuccguccucucucgguuccccuugauuccugcpuccapacccggacagcuupacguccgcagagccugg\n", + "cgacguggaaguugcuggcugacupcuugcgaggaaaccgccucggagcugcagccgaaggccaaggaaucacugaagaucggcgapaggacapuucauc\n", + "ccuggaguccgacguggaaguugcuggcugacupcuugcgaggaaaccgccucggagcugcagccgaaggccaaggaaucacugaagaucggcgapaggacapuucauc\n", + "gcucagagagaagugacuuugagcucacagugucaccgccugcugaupagagcugaauucaaaaccag\n", + "aaccuucaacaaguuuuacagacucauuggaugaagagugccugagacacugapucagcgcuccaaag\n", + "aupcuccggagguggcgcccaggcucugagcuacccuaggucugcagacuagcpcauuggccagagac\n", + "aggaagcggaggaaggugaaguaggaccgaauuccugugccgaagaggccugcagupagagcagg\n", + "upcccuuugccacucccuuggcaaggagagccgagaccucaguucccggcggcucuugcpcacaggugagcccuggcugcgcgcgcggccccuccuccccggcgccucccag\n", + "pcccuuugccacucccuuggcaaggagagccgagaccucaguucccggcggcucuugcpcacaggugagcccuggcugcgcgcgcggccccuccuccccggcgccucccag\n", + "ggcccagucgccccupcccuuugccacucccuuggcaaggagagccgagaccucaguucccggcggcucuugcpcacag\n", + "agucgccccupcccuuugccacucccuuggcaaggagagccgagaccucaguucccggcggcucuugcpcacaggugagcccuggcugcgcgcgcggccccuccuccccggcgccucccag\n", + "ggccccggcagaccugcgacuggcccagucgccccupcccuuugccacucccuuggcaaggagagccgagaccucaguucccggcggcucuugcpcacag\n", + "gcaguccauccggcgaagagcaggucagccuacggapcucagccuacggapcucagccgacacag\n", + "agguaagugcgcgcaguccauccggcgaagagcaggucagccuacggapcucagccuacggapcucagccgacacag\n", + "cacugccguucaguucagccagagauupccacauucaguccucgcuucccupapaag\n", + "pcapupaaaaguucgcccguuuguccggaaggcaguugauggaccupucgacaccacugcggacgcapcacggcacpcgagaaggcgaaggcugcaggcgugag\n", + "gupcugcaguaagcacuggcaccuugagagacucaggccagcagaaaaaucaagcugugacaaccpcaaaacccagcaaacauc\n", + "ugacaccucacacucagugccgguuaaaauuacugaaguuagagagaauuaaagacuaucuucuc\n", + "gacuuccgccucuggcpccgcagugguggaggaacuuccggcagcggcagcucaaguggccaag\n", + "auuggcugagcccggcugucaguccuuucgcgccucggcggcgcggcauagcccggcucggccuguaaagcagucucaagccugccgcapagaag\n", + "ggcuccggugucauggccggcuccuacccugaaggugcaccugcaguccucgccgauaagaggcagcaguucggaagccgguuccugagagauccggcgcgcgucuuccaccaca\n", + "augcgcagacacccucaggcgacuggcpucgcggcuuccaagcucuaaauggagaguugucccuacugugcggcaggcggaggagaccu\n", + "ugaaagcucggacagcucaauuagccaagauaaaaupugauaagugucgcuuucuacguauugcag\n", + "ggauccuccucccguccuucucauccuucguaaguggcugccuggccucccaapccggupaugccgccccagucccccggcpucuggcguag\n", + "cpucgcggcuuccaagcucuaaauggagaguugucccuacugugcggcaggcggaggagaccu\n", + "gaguucuucagacupuugccugugaagcccpugcugcugcuucucucccaccgcugcugcaaaguugaggacaugcuccapuuuuuuuuuuguuaggaguucucgacuguccaggaauuag\n", + "gugguugcuggugcucagcuucguguuuggaugcaauguucuuaggauccuccucccguccuucucauccuuc\n", + "agcacaagccgugcgcucccpcugcgaggucuggcuaggcuacpccacgcgccgccgccgcugccgccgccacuguccucuucggaggcgcpcccgacggaaacc\n", + "gugcpcgupcagcacaagccgugcgcucccpcugcgaggucuggcuaggcuacpccacgcgccgccgccgcugccgccgccacuguccucuucggaggcgcpcccgacggaaacc\n", + "gcgaggucuggcuaggcuacpccacgcgccgccgccgcugccgccgccacuguccucuucggaggcgcpcccgacggaaacc\n", + "uaggcuacpccacgcgccgccgccgcugccgccgccacuguccucuucggaggcgcpcccgacggaaacc\n", + "acaagccgugcgcucccpcugcgaggucuggcuaggcuacpccacgcgccgccgccgcugccgccgccacuguccucuucggaggcgcpcccgacggaaacc\n", + "gcapacugcggcgccugapagucgcugacpcacgcugacuggaggcuggcggacaggcgacagcgaccugcggcag\n", + "agaacaacaugaagagaccuugcugcugcuaugaaacccagacucuaaggacaacuupacauuggauauuuuuucacagauguagacaucaagga\n", + "agucuugcugcgacacccaggcuggagugcaauggcgcuaucucggcucacugcaaccuccgcuucccggauucaagcgauucuccugccucagccucccgaguaggupacuacag\n", + "acugcggcgccugapagucgcugacpcacgcugacuggaggcuggcggacaggcgacagcgaccugcggcag\n", + "agucuugcugcgacacccaggcuggagugcaauggcgcuaucucggcucacugcaaccuccgcuucccggauucaagcgauucuccugccucagccucccga\n", + "auggagucucgcucuguugcccaggcuggagugcaguggaucagucuagcucauugcagccuccaccuccupuucaagagauucuccugccucagccuccuguguagcupauuacag\n", + "gcupcugcapacugcggcgccugapagucgcugacpcacgcugacuggaggcuggcggacaggcgacagcgaccugcggcag\n", + "ccagaugauagcaaugccucpagcuuccucacucuguccucugucugccuuucagcugugagaggaacugcaggccaguuaaugccagcaaagacauucugcucapucacc\n", + "ugauagcaaugccucpagcuuccucacucuguccucugucugccuuucagcugugagaggaacugcaggccaguuaaugccagcaaagacauucugcucapucacc\n", + "agaugauagcaaugccucpagcuuccucacucuguccucugucugccuuucagcugugagaggaacugcaggccaguuaaugccagcaaagacauucugcucapucacc\n", + "guuggcugccgaggcucggccggagcguggagcccgcgccgcugccccaggaccgcgcccgcgccuuuguccgccgccgcccaccgcccgucgcccgccgccc\n", + "agaggcupaaguccpauugapccagcaucuaccaapccuucuuguuacuucaucccaugauggaagguggaapuaaagagagg\n", + "gaggagupcaggcucggcgccgguaggaagagucagapugaccagagagcccaacgccuggugcucaagacuuucuccgag\n", + "aaagcucggcupcagcpagaggaggagccgcaggagcugcagcucugccagcuupccgagccuagagacaccggccuggcugguccacgccagccgcag\n", + "gauucucuuuggcacagauguuggcaggugcgaggaagcacggcccugacacgcguggccaggccacaugugcaaggcaugugcggagcaagcuggccaguuggagcpcuuaggaguugcaaag\n", + "aguugcucaguucuacupaccuggaggaggaaggcapccaaagaggaaguuguccccucuupcccupcuccupucaggauuuugauacucugaagcaggaaacuuugauuccc\n", + "gcacaucccugcucacccugaupcuucaggcuggapcauuuucccagcggcgcugcugccccuguugcugacc\n", + "gaggaacgccccugucaguaggccgcacucauggcauguggccaagcugcuggapaugcccugaagcagccaccacc\n", + "gugcugacggccacccaccaucaucuaaagaagauaaacuuggcaaaugacaugcagguucuucaaggcagaauaauugcagaaaaucuucaaag\n", + "gacccuaucugcagauguucugaauaccucugagaauagagauugauuauucaaccaggauaccuaauucaag\n", + "ucucuuuuagcauaguuuugaauggaaugcuagcacggcacacuugucaaagccaguuguugcuguccuaucaaugcugcuauuguacggcugacagaugacg\n", + "ggaguuuggauuucauuuuagucucaccgucuccguuuuucucugacugcccagaacuccagaaaucaggagacggagacauuuugucaguuuugcaacauuggaccaaauaca\n", + "gacuacuucacagacuuaaucacuaacgagagcauuaauuacuucaaaaugucuaagagaauguauccccauaggcccguuaug\n", + "caaccugaucuuuuuccucauaacuugccgaccgacccgugacagcaaaaccggcagaagcucggcgaccucccaccccgagucugcaggua\n", + "auucacugauuucucuucggcuggacggaggcugccuccucacgcggcucccaacuauucccguagcucagugccccccucccgccgcucuacucagccaggcagacagacugacagacucgcua\n", + "ggcgcgcaccgcucucuuacacucpccucagaaguccgugccagugaccggaggcggcggcggcgagcgguuccuugupcuag\n", + "pcgcgcaccgcucucuuacacucpccucagaaguccgugccagugaccggaggcggcggcggcgagcgguuccuugupcuag\n", + "acucpccucagaaguccgugccagugaccggaggcggcggcggcgagcgguuccuugupcuag\n", + "augaugcuugcgcgcgucccccgcgcgccgcgcugcpcpcpucuccpauuccaapcucgguuacggaagaagcgcagcgccggcupapcugg\n", + "gcgcgccgcgcugcpcpcpucuccpauuccaapcucgguuacggaagaagcgcagcgccggcupapcugg\n", + "ccaacucagccugguuaagaacaccuguugaagaacuagugcaggcguuuggaggacauaggacacucuggccau\n", + "augucuggacugcaauccugcacaguuuugagapagaugacuugagugguuggcuuuuaucuccacaaca\n", + "gcaggcuccgagugcccucgcucccccgcgccuucccggagccccgccagcccccgaggugcaggaaggucccgcggacggagcpccugccggcguucagup\n", + "aggcgcgcupucuugupuggaaacgcgcuggcugacupucggcguuuaguucagcgcagcgacucpaccuggagcugacgccua\n", + "aggcgcgcupucuugupuggaaacgcgcuggcugacupucggcguuuaguucagcgcagcgacucpaccuggagcugacgccuaguacgu\n", + "gacacuuguauuagcuuuaauagaagagaaauggaggagccauagaauauuaaggaugaauucaggaaggccugagaccauggaaaacuugccugcucucuacacuauuuuccaaggagag\n", + "apuggagugcaggcuuggaaagcaggagagcucagccuacgucuuuaauccuccugcccaccccuuggauucugucuccacupacucaagag\n", + "aacccagccuaccugcuguagcugccgccacugccgucuccgccgccacupcccccagagccccagccccagagccu\n", + "ugaugcggccccaugucccuccuuguucccagaggaaccupcccgcuccuccccccuccaggcc\n", + "gcuguagcugccgccacugccgucuccgccgccacupcccccagagccccagccccagagccu\n", + "ugcuccacaccuggucapagagapaggaaagccaapaapaccuaacugaaaacaaacaagcupagaagcaggaaucugcgcucpuuccgcag\n", + "gguggcagcggcagcggaggaggaagcugagcapcggcggcggcgguggaaccugcpcupcgcgcgcc\n", + "aaguaaaggauccugagaacugaaggcaaacagagcuccaggaguccaagacagagccacagaccacgaggaucccuggcccag\n", + "acuaaaccacagcuguccccuggaauaaggcaapaguguagagcagagcagaagccugagccagacggagagccaccuccucucccag\n", + "gaacugaacccaaaggaucaccugguauucccugagaguacagauuucuccggcguggcccucaag\n", + "cacuuuucaggauuagaagaggcuguguauagaaacauacaagcuugcaaggagcuugcccaaaccacucguacagcau\n", + "acuucucuucuuccgcgaccpagaaggccgapaucggcggcacgaucgacauuguacaccuugaagguggacggaugugaagccgcgc\n", + "ccgagagcgapapcugugaggacugccagcacgcugucaccucucaauagcagcccaaacagauuaagacaupag\n", + "gugaaagacaacuugagugguuaaauuacugucaugcaaagcgacuagaugguucagcugauugcaccuuuagaaguuauguggaacgaggcagcagaucuuaag\n", + "ccccuugcucugucacgcaggcuggaaugcagugguggaaucauggcucacuacagcccugaccuccupcccag\n", + "agauggagucucgcuauuuugcccagguuggucuugaacaccuggcuucaagcaguccuccugcuuuuggcuucuugaagugcuuggauuacag\n", + "guguggaauaacccuuaagcccuuaccpuccuucuggacugagaauuguuguaaaguaauacugcucag\n", + "gaucagcagcaacuuaaccaaagcucuguuacagccuguagccaagagaaggaaccugugguucguuuccccagacggugugaugaaaag\n", + "ggcpugcgcpcggucagcgaucugcagcuucgcpacagagauguaacccaacucguucacgg\n", + "cpugcgcpcggucagcgaucugcagcuucgcpacagagauguaacccaacucguucacgg\n", + "agugugcaggcaggcpugcgcpcggucagcgaucugcagcuucgcpacagagauguaacccaacucguucacgg\n", + "ggugacagccuucauauauuuaaagaggacaagagccccucagacucaguugagcugaacggaguccacacaggcag\n", + "agugagccgagaucgcgccacuacacuccagacupcgacagagccagacuccgucucaaaaaaaaaaaaaaaaaaagagagagagcaccuuaggaaucaucugccucacacgaauauucu\n", + "caggccaaggcuggugacagccuucauauauuuaaagaggacaagagccccucagacucaguugagcugaacggaguccacacaggcag\n", + "gauauuaaaacuuuuaguacaauugauuggacuacuugaaccaucpauuupaggaacuccagauuuuucauuuuuaaacucuaaauguaugaggaauuuacaga\n", + "aaaucpcuuggcugcuccuggacggucacgcucccucugcccgccagccggcccgccagucccggucccggcgucucucuccggcacccaccucggcgcugcggaaagacugacugccag\n", + "gaucucacuuugucacucagguuggagugcaguggcacaaucacaguucauugcagccucaaccuccupcucag\n", + "paaagugaagaaaacagaaaaggagapacagaggccagaggacuucucauacuggacagaaaccgaucaggc\n", + "gcgaguuggucupaaaaapcggugcgagcpugcgcgcgcagcpccggcaguggcggcggag\n", + "aaaauaucuacagaagagcugaaaggaaggucagcuucucagaagacacuguuucugucauguguauuggacuuupuuucauuagcauggucuacuuuuaac\n", + "cguuuugcugcugacaucaucuccguuuuggccaugaccaugagupagcgugagugccucaaguaucggcuagupcucccaggaggaauuggcaucaupuc\n", + "acaaggcugagcpaggaagcgagaggcaucuaagcaggcaguguuuugccuucaccccaagugacc\n", + "augcaacgcguaagacugcgacgguaccpcggcpaaggaccgagaggcpaggagcagcggcucaggcgccugcaaacugguggccugaacgag\n", + "acacgcgagucugauaagcacccucccccggaaucaugcggugcugugaggccuagcgaagaugaagauagaaugcaag\n", + "agucucacucuaucgcccaggcuggagugcaauggugccaucucagcucacugcaaccuccccuucccaaguucaagcaauuuucaugccgcagccuccuagcupauuacag\n", + "gcucuugcucuugcagaauccacaggucuuucuugaggaaaucuguagacagaacuuugugcugcguuuuuaucuapaaggaacagaagagugucgucuccuagaaaucuagcacuggagaaac\n", + "acagagucucguucugucgcccaggcuggagugcaguggugugaucucggcucacuucaaccuccgccuacapuucaapauucuccugccucagccuccugaguaucugg\n", + "ggcagcggcaacggcagagacagcaacgugcccgccgcagucagcccggccucgucggacccgcaccggcccgcccgcccgcccgcaccgcgucpcgcccucuccacugcgcgcg\n", + "ucucucaccuggucuugcggcuguggccaccgccggccapuguggapcgugcugccggagacguccgccpcucugcaguuccgccpucpcagcu\n", + "cpccccgcpcgcagcpcpaggcpcggcccggccgupcggagcggcggccgcggccgugagccugcccccaacucgcccucagccggcuggccggcgcggcc\n", + "gcuggugugcaauggcgugaucucagcccaccgcaacuuccgccuccupaucaagcaauccuccugcuucagccuccugaguagcupacuacag\n", + "auauggccgcguggaaagugucaaaauucuucccaagapaucugaaggaggaguggcugccuuuguggauuuuguggacaucaaaagugcacagaaagcucacaacucggucaacaaa\n", + "pcuggaaguucccgccagguccgugccpcgagagagaugcugcccggcccgccucggcuuugaggcgagagaagugucccagacccauuucgccuugcugacggcgucgagcccuggccagac\n", + "uuuccaccuggauguuugagguuguguagauguggccggcacccuugagaguggagcuapugcagacugagcagugaacagaaggagccuuggacapcupccagccucccg\n", + "aaagguuucuggugaugauguagcauccgaggcucuuaggaaaucpcugcaagcacuggccccugcuupauggupacccucgcccggagcguaacgccugacag\n", + "agcaccacuaacacgaagcucuucugcacaucagacucuuaaucaaaggauupcauaucagaag\n", + "ucccuuauucaacugucuucauuuauucuguaaaaguagcagcagcucagcccugaccaucuccucucucacuugupagucucauuuapaucg\n", + "auugcucaupcagagaagcagaggccgcggagaggcccccgagcgcgcggugccccagcupccggagcuaggagcuggaccuugcccacccacccccggcagcagugcccpcaggcggcgcc\n", + "gaggcucggccgccugagccgcggacgguuugcugagcccguuagugcgcccggccgagacacgccgccgcc\n", + "gucugaggcucggccgccugagccgcggacgguuugcugagcccguuagugcgcccggccgagacacgccgccgcc\n", + "guagcagagcccucuagcugugugugucugaggcucggccgccugagccgcggacgguuugcugagcccguuagugcgcccggccgagacacgccgccgcc\n", + "guugguuucaaugcuuccpuuggcgcugcaguggcguuuccgacugupagccucagcuucccagucguccgaugagcccgagcag\n", + "cgucuccgccgcccgcggugacuucugccugcgcuccuucucugaacgcucacuuccgaggagacgccgacg\n", + "paaacaggcaaaagaguuugauucuaagcuggagaugaugcagugaaugauguuuugagcaugccugaacuguuggccaugacagupaag\n", + "cagaugaugcuacagcugacagucgcaaaacuuacacucuaacugauuacuuaaaaaauacuuauagacugaaguuauacuccuuaagauggauuucag\n", + "aucaugaauaucucuacaaacaagaaaauaauaucuugguauucaaugcugaauauggaaacagcucaguuuucuuggagaacaguacauuu\n", + "gaugaguuuggacauucuaucaaugauuauucaauaucuccugaupcaguuuauucucuuagaauacaacuacgugaag\n", + "gcagcugauuacagaagagaggauuccaaacaacacacagupucacauggucaccagupucauaaauug\n", + "gcauauguuuggaacaaugacauuuauguuaaaauugaaccaaauuuaccaaguuacagaaucacauggacpaaagaagauauaauauauaauggaauaacugacupuuuaugaag\n", + "gcaggagcugugaauccaacuguaaaguucuuuguuguaaauacagacucucucagcucagucaccaaugcaacuuccauacaaaucacugcuccugcuucu\n", + "gcgcgccccgccpcgugcuucpcugcgccagcaagcpccgguggcgcccgugucggagaccccgcgccggacccugaggcagcga\n", + "gcagcgcgccccgccpcgugcuucpcugcgccagcaagcpccgguggcgcccgugucggagaccccgcgccggacccugaggcagcga\n", + "guagugcgcuccccgcccagccugcagagcucgcgccgcggcagcccagccgcucggccccgccgcgcucgcagaggccgcc\n", + "acccucuccccaccuucuccccaccccaggcuucacccaaacucugaccucuuacucucucuacuuaacucuggucccpcagccaagacaaagcgaaaggcaaggcagc\n", + "pcggagccggccaggcggcgcgagcpaacuacggccuuggccuucuucaguucuagcgucaacccggugcucuacgucuucaccgcuggagaucugcugccccgg\n", + "agagccccggccccgcgcggcccgagugccacaucacugcgcuggccguccaagguccgccgccccacc\n", + "agcgagcgcagagccccggccccgcgcggcccgagugccacaucacugcgcuggccguccaagguccgccgccccacc\n", + "gcgcccucccugcgccpcpagcccagcgagcgcagagccccggccccgcgcggcccgagugccacaucacugcgcuggccguccaagguccgccgccccacc\n", + "ugauaacaauccauauuccucauuuggagcaacucuggugapaugaugagaagaauuuauggagu\n", + "agucuagugagaggcaguccugcguucugccuggupagucagagucuuaagauuugccaaguccugaugccaucagcauucacauugccuuacagaggucuccuccccacuccaagauag\n", + "aauaggagagacgucauaaggcaauacuagaauaacugccaaaugaauuacauaaacaauacuguuuuggaaaaag\n", + "acuauccgccauucuugucaccucagcugcugcccucgcuaccgcaccgacuucgcccgugugcucgccugcacuugcgcugcccgcc\n", + "aggcauacaucacaauuuggaauuaugcauugguuuaucaauuuacuuguuuauugucacccugcugcccagauaugacuucaugagg\n", + "ucucgcucugucgcccaugcuggagugcaauugcgugaucucagcuaacugcacuuuccgccuccupuucaa\n", + "cggagaaaagaagccguggccgcpaggaggcgagaggagucpaucugcgcugcagccaccgccgcgguugauacuacuuugaccuuccgagugcagug\n", + "guuuuuguuuccucagaggcauacaucacaauuuggaauuaugcauugguuuaucaauuuacuuguuuauugucacccugcugcccagauaugacuucaugagg\n", + "aaaagaagccguggccgcpaggaggcgagaggagucpaucugcgcugcagccaccgccgcgguugauacuacuuugaccuuccgagugcagug\n", + "guucugupuagaugugcpuuuguuacaupuaaauugcauguugcugaggcuugguguacgaaugauccugucacucag\n", + "agguagcugcguggcuaacggagaaaagaagccguggccgcpaggaggcgagaggagucpaucugcgcugcagccaccgccgcgguugauacuacuuugaccuuccgagugcagug\n", + "gcgagaggagucpaucugcgcugcagccaccgccgcgguugauacuacuuugaccuuccgagugcagug\n", + "gaggcauacaucacaauuuggaauuaugcauugguuuaucaauuuacuuguuuauugucacccugcugcccagauaugacuucaugagg\n", + "gguagcugcguggcuaacggagaaaagaagccguggccgcpaggaggcgagaggagucpaucugcgcugcagccaccgccgcgguugauacuacuuugaccuuccgagugcagug\n", + "gguggugcuggcuagaguguauacguuuggacccaagcuuaacuuuuccaauguggaauccupccuucauug\n", + "guuuuuggaagaagcugaccgccugaaaagaaauuauaaaacaugaaaaucgcuuugaggugaccaaguccagaggccccuaacuccucccaagcuggaucupuguaagaacugugacuucag\n", + "guggugcuggcuagaguguauacguuuggacccaagcuuaacuuuuccaauguggaauccupccuucauug\n", + "gacggaggugccuguuuacccgcgccggacucaccgccgccgccgccgcpauccgagugcpcgcpcgcpcgcucccggcgagccacg\n", + "gacauuuapaaggcagaaaguaggucapacggaggugccuguuuacccgcgccggacucaccgccgccgccgccgcpauccgagugcpcgcpcgcpcgcucccggcgagccacg\n", + "acggaggugccuguuuacccgcgccggacucaccgccgccgccgccgcpauccgagugcpcgcpcgcpcgcucccggcgagccacg\n", + "acuaugugaaagaauacacagugcccugagagccuggccupaaucagaaacuuagauuccagcuucgguucugcugguaacuccucagucauuaugg\n", + "guuuacccgcgccggacucaccgccgccgccgccgcpauccgagugcpcgcpcgcpcgcucccggcgagccacg\n", + "gaaaguaggucapacggaggugccuguuuacccgcgccggacucaccgccgccgccgccgcpauccgagugcpcgcpcgcpcgcucccggcgagccacg\n", + "agaagcucggagcugauuugcgcaaaagccggacugagucuuggacgagccpaaagauucucacagucgagcagagcgaupagagaggagcagacagcgagcuuuggaau\n", + "gucagcaaaguggaacgcgagaagaaccaggagcugcggcaggugcgcgagcaugagcagcauaagaccgcggucuugcucacggagcucaagacaaagcugcacgaggagaag\n", + "gaguuaapugaggccgcacgcgugcagcucccccgugcugcgcauggcgcupaucggccugagcggcgg\n", + "auagaagcucggagcugauuugcgcaaaagccggacugagucuuggacgagccpaaagauucucacagucgagcagagcgaupagagaggagcagacagcgagcuuuggaau\n", + "uaacagccguggcagucagagcucugccugcagugugaccauggacagcucuccaaagcuuaaacuucaguaaauugacucaaguuucuucggaaagaacu\n", + "gcuggcccaggcaccacgcgacucuaagcgcgcccaaagcgacccucugcgcaaacuacccccpacgacgucacccgugag\n", + "ccguggcagucagagcucugccugcagugugaccauggacagcucuccaaagcuuaaacuucaguaaauugacucaaguuucuucggaaagaacu\n", + "cugacugaaacaccagcuugauucuagaacaaagaugcucagucucaggaucaauugagauuuguuucuaccgagagauccacucug\n", + "paagcacggaggaggaagccgccggugcgucpacpagcgcaggugcucpcacccgagcuggagcuccgcagccgccgguc\n", + "cacucaaaccagugaagcuupaaagucauugaccuccagucguucugcugagaaacaucuggcucuauuucc\n", + "aacacapucpagaagccaaaaaaacaacccaaaucaggcuggaaugcacggcccagagguccacggcgaacccuggaucauaaggagaccguguag\n", + "aacauccugaagapuagaagagaggucugagcpagugcacugcuuuggaugcucacaaggagcuggaa\n", + "augauuugacucagagauucucuuuuguccacagacagucaucucaggagcagaaagaaaagagcucccaaaugcuauaucuauucapcucucaagaaca\n", + "agacagucaucucaggagcagaaagaaaagagcucccaaaugcuauaucuauucapcucucaagaaca\n", + "ccacaugauuugacucagagauucucuuuuguccacagacagucaucucaggagcagaaagaaaagagcucccaaaugcuauaucuauucapcucucaagaaca\n", + "aguaccuagcccacaugauuugacucagagauucucuuuuguccacagacagucaucucaggagcagaaagaaaagagcucccaaaugcuauaucuauucapcucucaagaaca\n", + "ugaagcccuugaccacuauagacucaaacaucaccuuguuuuuccacucauucaacacuuuuuuuuuuaaauuaucuaauagguuggcacucaucaugagccccuguucucauucugcaa\n", + "paaccucagaaauccauugaaguuccauuguuaagaaguucuguuuguuuggcaacugcuuuaaacccgauagaacaagaucagaaguggcagucuauaacuga\n", + "gacugucuuauuccacucuucggcgaagcuuuacguucauguaaacagcaugacgugaggccguggaugcaggcauuaag\n", + "aaagcuauaaagcuguaagagaaauuggcuuucugaguugugaaacugupcagaaaguugaggaagaaagaacucaaguacaacccaaugagg\n", + "ucaggaggcggagaucgcugcuucucaccuacuuucugaacuuggccuccgcagucgcgaccuggcgugaaggaggagcugccgcccccgccccagccucpacgccucucugaag\n", + "cgcuguupcucucaauuccuucugugaaggacaacauauggugaupaaaucagaagcuuugagacccucuacaccuggauaugaaucccccuucuaauacuuaccag\n", + "ccauuucuugauuuacagaaaugaapauacucapcagaguucugaaucucaaaacacucuacucuggcaaaggaaugaaguuauuggagugaugacaggaacacpagaaca\n", + "aaaugaapauacucapcagaguucugaaucucaaaacacucuacucuggcaaaggaaugaaguuauuggagugaugacaggaacacpagaaca\n", + "gagaggagaaaggacpccuupcgccucugagaugcucccaagugccapapccgagcgaggcgcaggcaaccpcagcaggc\n", + "aaaggacpccuupcgccucugagaugcucccaagugccapapccgagcgaggcgcaggcaaccpcagcaggc\n", + "gucccucuccaccugccpcggagcgcacpccaupcugagccccgcugagcccgccpccggcc\n", + "ccucuccaccugccpcggagcgcacpccaupcugagccccgcugagcccgccpccggcc\n", + "gcgccgcggccpucccucuccaccugccpcggagcgcacpccaupcugagccccgcugagcccgccpccggcc\n", + "ccgcggccpucccucuccaccugccpcggagcgcacpccaupcugagccccgcugagcccgccpccggcc\n", + "gagaaccuacaaacuagacuuguagauuaaaauuaucugaucaaaaaggcagacucuguaaauuuccuuaagaccuaccuuggcauaaaggcugacccagcaaaagaacug\n", + "aguccaagaagagaaccuacaaacuagacuuguagauuaaaauuaucugaucaaaaaggcagacucuguaaauuuccuuaagaccuaccuuggcauaaaggcugacccagcaaaagaacug\n", + "auaugcugcugugacugcugacuugaauguuacpauccccagcaggaucupauucucucuguucuugaaugcguuguuuag\n", + "aggapaccuacaaagacuggaaacuauucuuagcuccgucacugacuccaaguucauccccucugucuuucaguuugg\n", + "aaagagaggcuggcuguuguauuuaguaaagcuauaaagcuguaagagaaauuggcuuucugaguugugaaacugupcagaaaguugaggaagaaagaacucaaguacaacccaaugagg\n", + "gccaacuucugaaguuucuaccagcugcaguugcugauucugguauuuauaccuguauugucagaag\n", + "ucccacauucaauaggacuggauaugcgaaugucaccauauauaaaaaacaaucagauugcaauguuccagauuauuug\n", + "acucuuuucuaagcaacucaaguuugcagugauucaggccuacuucugaagagacagccuuuuaucuca\n", + "aguagugaaucguagcauguuagaguuagaagguucaguguugauggaguuauugaagaaaugauggaguaagag\n", + "gcggccgcggaggaggaggaapaggapcgaggcpaggugcaggapacccucgccaupuccacpccuagaguggcggaagauaccggccuggugccaaacug\n", + "ggaapaggapcgaggcpaggugcaggapacccucgccaupuccacpccuagaguggcggaagauaccggccuggugccaaacug\n", + "aggaggaggaapaggapcgaggcpaggugcaggapacccucgccaupuccacpccuagaguggcggaagauaccggccuggugccaaacug\n", + "auuuugugccugccuagcuauccagacagagcagcuacccucagcucuagcugauacuacagacaguacaacag\n", + "cauuuugugccugccuagcuauccagacagagcagcuacccucagcucuagcugauacuacagacaguacaacag\n", + "guuauccugaauacaugucuaacaauuuuccuugcaacguuagcuguuguuuuucacuguuuccaaaggaucaaaauugcuucagaaauuggagacauauuugauuuaaaaggaaaaacuugaacaa\n", + "aaaaacugcuucucugcaupuuuaugaguugagacagacauuuaugugaaagagauaacaacagapaggagcaagucuucaauaucag\n", + "uucaccuuucuuggaucacaugcaaaggauguuuaggucugugaagaaaagaauuucuaggccpugcuguggcucacgccuguaaucccagcacuuupaggccgag\n", + "uacaaaggaagcupuaacagaguaugagaacuccgcagacucccggcupaacccgacgacuuucaccggaaggaggagcgcucuucapca\n", + "gauugacuucuaaggacucuugguacaugaggaagaaacccggaapaagaggaaagcaaaggcgucagga\n", + "gguuucuaugaugacaggaugguccuaagucuucacacaucapccacagccccaaccucacaggaaacag\n", + "aauuaauuuccaaagacucauguuacaugagaaagccaccaagaagaccaaagaaaaggagacaaggauggcucuuccucag\n", + "ggaugcuugacuuucapauguggcuauagaauucucuuuggaggaguggaaaugccugaacccugcacagapcuuuauacapccgugauguuggagaacuacaggaaccuggagucugugg\n", + "gauugacuucuaaggacucuugguacaugaggaagaaacccggaapaagaggaaagcaaaggcgucaggaaugguucuuccucag\n", + "gaauuaauuuccaaagacucauguuacaugagaaagccaccaagaagaccaaagaaaaggagacaaggauggcucuuccucag\n", + "ggcuucuguacugcgcgcgcacaugcgcgcaaacccggaagcggauuauguggagugaaaguuacaccguggcg\n", + "ggucuauugacauucapauguggccauagaauucucucaggaggaguggaaaugccuggacccugcucagaggacucuauacagagaugug\n", + "ggcccuccccccaccauggcgcggagcgaggcagcggcggcpccpcccpcccccccpcugg\n", + "gucagcucggugcccuuccuuggagcugccggccaccagcagagccuacccucuucauggaaagccucgugcaguggcccccuggug\n", + "gcacaacugcuuccagccggacggagcucggccggcugcgccpccugucccaggucugcagupaaccugccpccacguuggupccupccgcaccuucg\n", + "aguugagaucaaacagacuuuucauuccugguuggugccupagagugacgaggccuaucaguacuggaggacacagucaag\n", + "aaucaaacccgagaugacaguugagaucaaacagacuuuucauuccugguuggugccupagagugacgaggccuaucaguacuggaggacacagucaag\n", + "capagaggcpccaaggccapccugacuaaaccuggagacucpuggccgapcuucauaccagcugaagagcgacaagccgcuggcagccgcggaucucaccgccgcucagg\n", + "gccuguggaauuguccugagucauugcuuupcupccaupaagaaaccauuguguggcapaaggagguggcucuuggcccaggccuaaaccaggaaagccupaaacupacccacag\n", + "acuucccgccacugcugccagcgagagccgcpagagugugcagccgagucacuacugccugccugccugccugcuacg\n", + "uuppcaaaacuuuuupugauuuuuuuuggcuuuucuuccuccuucauuuuucuuccaaaauugcugcuggupugaaaaaaaa\n", + "gcggaaagacggccuccgccucgcuccgaaaguuuccgagacaaaucccpaaaguuuggaagaag\n", + "uuuuuuppcaaaacuuuuupugauuuuuuuuggcuuuucuuccuccuucauuuuucuuccaaaauugcugcuggupugaaaaaaaa\n", + "agagucagcaggagugaguucaggaauccucpacaaggcacuuuccugagcacuggaccagcgaccucuuggcuucca\n", + "uuucaagcagaguuugugcuuaauccucacccaggcaccaaggcucagagucagcaggagugaguucaggaauccucpacaaggcacuuuccugagcacuggaccagcgaccucuuggcuucca\n", + "gcaaacaauuuacauuuucuuaugaaaaugaagucugcaaacaagauuacuuuauuaaaucaccaccuucucagcuguucuccucugug\n", + "accucuuggaaaaagcgguuuuucauccugucaaaggcupaaaagagcuuuagucuuuccuauuauaaagaccaucaucaccgagguuccauugaaauugauca\n", + "uuuuguuuccucaucugguacaaaggaacccuuucuacccuucccaggaagacauugguuaagauauggcugapaggcauapauuuuuuuucaaugguagucaccacagacgguugagg\n", + "gcaccaaggcucagagucagcaggagugaguucaggaauccucpacaaggcacuuuccugagcacuggaccagcgaccucuuggcuucca\n", + "puucggcugcguccgucccgccgcccgcccguugccgccgccgccgcugccgccgugcucucgcuuugcccgccgccgccuaappcupccpccagccaucacugccguugccp\n", + "gagcgauggaggaccccggccccggcgcgguccagcggupagcpcgccgcccaccugucggaucccupccaugaccccupacggcga\n", + "auagagccacgaacccccugaacaaggagcucgacupccagcaucaacggcuucugcgagcagcucaacgaggacuuugap\n", + "gccuccacucgccacccggcugcuggcccacaagauccaguccccacaggagupaggcgauccaggccuugacg\n", + "gugccgaggcupccgguggcggauggagcccgcgauggagccggagacucuggaggcgcgaauca\n", + "agccacgaacccccugaacaaggagcucgacupccagcaucaacggcuucugcgagcagcucaacgaggacuuugap\n", + "gaguagaggauuagagaapacaccggagccacucccaapaaugaaggcuuucugaaccuggugugaug\n", + "uucpagagcccagcacugguccccggaaaggugccuagaagaacaaggugcaggaccccgug\n", + "cugccucaacaggapupaacagcucaacaauggcugaupcgcuccugguguugauagag\n", + "pcuccgccagcagcaggucccucpccccagcccucgcugccacccpccuggagccccacacccgag\n", + "agacaaggcccpcuccgccagcagcaggucccucpccccagcccucgcugccacccpccuggagccccacacccgag\n", + "gauccccgccccugcugcccgccacgucccucacguaccacucggcagaggcgcpaaaccuggcguacuggcuguggcuucucuagcpacucggc\n", + "gcucgcagcacgacaccgcggugugugcaagcggaacgccgcccuguccuugagccuuuuggcugagauupapcagaggaagcaggaag\n", + "gaaaucggaaaguuggcpcugcpagcugagccuagaguccggcuguuggcuagagupcgcggaucuggugupaaggcggcpacucaggccugccugcgaag\n", + "agacaaagccugaauccuggaaaaagccaacucuuugaacaggaauuagagugugaucggcucaguugacguacap\n", + "gagucucccgccaucuupcccuagcgguauuuuuccagcucupaagagcggccugacccgcagcagagauucuug\n", + "gucuuauuucugcauucugaucuguuccagugaauuauauuuccacaccaguacuacaccaguaccacagugucuugagugcuguaacuuuauaauuagucuuaaacucag\n", + "auuuagagucugauucuaaggaaaaauaguuucccaaauuucacacaauuaauugaguacugauaucugaauccuguguauacagu\n", + "gaaccugguaagcuccuggagguaaaacucacaaaugugupacacuccuaugacupucuccuuggagcuggacucucagacauucugcuguauuccuuaa\n", + "uccccaaagcuccagagauagauccaguagaguguuugguggcagauaacucuguaacaguggcuuggaga\n", + "agugcagugaguagcggucuupugugcgaucucgcugagccuccucacacgguucgucgucucpuucgagcccagupcuuagccacucgcc\n", + "acucccgcaugguagcuggagcagcaaacaacugcuuapauuugaagccagguguccuaacuuccucc\n", + "aauccucccacuagacacucccgcaugguagcuggagcagcaaacaacugcuuapauuugaagccagguguccuaacuuccucc\n", + "cucccgcaugguagcuggagcagcaaacaacugcuuapauuugaagccagguguccuaacuuccucc\n", + "agacggagaggccccgccgaggugagcgaggcuccaaccggucacuggupuccuggcacuggcpucgcaacgcugupcguuccaggagguggucguggcgaaccuggcagcugcg\n", + "gucgguucugcgugcgcugccggacgaggcucccgccgccgauugacccgcgcuccgcccguagucpccg\n", + "cpcapagugcpucgguucugcgugcgcugccggacgaggcucccgccgccgauugacccgcgcuccgcccguagucpccg\n", + "gagaggccpcaggccpcapagugcpucgguucugcgugcgcugccggacgaggcucccgccgccgauugacccgcgcuccgcccguagucpccg\n", + "gucacuuccggcgcgagaggccpcaggccpcapagugcpucgguucugcgugcgcugccggacgaggcucccgccgccgauugacccgcgcuccgcccguagucpccg\n", + "ggacuguugacauuuapauguggccauagaauucucucuggaagaauggcaaugccuggacacugcacagcggaauuuauauaaaaaugugauuuuagagaacuacagaaaccuggucuuccugg\n", + "guauugcugucucuaagcaagaccugaucaccugucuggagcaagaaaaagagccuuugacugugaagagacaugag\n", + "auugcucuguguccucugcuccuagagguccagccucugupccugugaccugcagaaauugagagauccacagcuaagacuccaggacccccuggaagccuagaa\n", + "gaaguuuaaguuuaacccaaagcupcauugauaauccuguccucucccuggccgaagaccacgaccccu\n", + "gccccgcgcgcacgcgcaaagcccgccgcguuccccgaccccaggccgcgcucugupccucugapcggc\n", + "guuaagcgcgucgccaccgcccccgccuaggcgagagcccagagagcugaaccugcaucccggaccugcggcgaccgucguacacc\n", + "gauuggccppaugcpaugcpcggcpuuaagcgcgucgccaccgcccccgccuaggcgagagcccagagagcugaaccugcaucccggaccugcggcgaccgucguacacc\n", + "aagcugauccgcgucugcggucggucggugcgugcgugcgccucgucgguccgcgugucuggccgagagcccccuuccucugcggcc\n", + "gauccgcgucugcggucggucggugcgugcgugcgccucgucgguccgcgugucuggccgagagcccccuuccucugcggcc\n", + "aguucccgcgaccccaacgucccagaggcpccggagucggcgguggcgcuccuuggagccggcucccgcuccuacccugcaaacagaccucagcuccgcggaaguugcg\n", + "caggagaauaauuugaucagauuuauauggaaacacucuucuagcagcauuaupacuuuuccauaagucug\n", + "pcgugguggupugguggacgccuguaauaccagcuaauupaagcugagacaggagaaucgcuugaacucpaggcgagguugcg\n", + "cgccgcpucgcgcugcacagccugcggcgcagcggaggcggaccgcagucgagucugcagaguguugg\n", + "acagccugcggcgcagcggaggcggaccgcagucgagucugcagaguguupucuguagccagcaaauuacuucaucaucuagauuauccauucaguugauccuaauuagcaaggauaacaag\n", + "gapaggaagcggcuugccggagagccapcgcagupcggcapcugagcggccggugaupaccccacaucccaggcagugccgg\n", + "aguuguauaaaccaccgugcaaauuucguuccaggacacauuggcgugagaccupaguacguugugccaaaucauugccacuugccacaugaguguaaaug\n", + "gacacauuggcgugagaccupaguacguugugccaaaucauugccacuugccacaugaguguaaaug\n", + "ggacacauuggcgugagaccupaguacguugugccaaaucauugccacuugccacaugaguguaa\n", + "guuccaggacacauuggcgugagaccupaguacguugugccaaaucauugccacuugccacaugaguguaaaug\n", + "uucguuccaggacacauuggcgugagaccupaguacguugugccaaaucauugccacuugccacaugaguguaaaug\n", + "cgcucuaccpaauaccgcacucugaagcguaccacpccaggccggcggcpcuccgcagcuccgagucgcuccccgcggcggccgaagag\n", + "acapagauggcugcgauuuaguuuugaggaugcuacaggcagcagcapcuggcacccugugucacag\n", + "gcacuaugcupccuuccuaccacuuguguguggcuugguaguggccuapucucuccucccugcugaagucccucuccugcagguggccgucugcccggcccagcacc\n", + "ggagauggcugcgauuuaguuuugaggaugcuacaggcagcagcapcuggcacccugugucacag\n", + "ggauucugagcauuuguagcaaaaucgcupaucuggagaggaagacucaguccagaauccucccapccuugaaaguccaucucugacccaaaacaauccaa\n", + "aauuggauucugagcauuuguagcaaaaucgcupaucuggagaggaagacucaguccagaauccucccapccuugaaaguccaucucugacccaaaacaauccaa\n", + "ggagucggcggcucpcagcucugcgauuapcggcggaguuggcpugcacguuggaaaucucggaa\n", + "gaacupcppuguuuccuggaccccaguccuccgaaucagcuccuagaguggaaccaggaaggauucuggagccacagaagauagacag\n", + "agaagugccccuucuccaggaucaaggaacupcppuguuuccuggaccccaguccuccgaaucagcuccuagaguggaaccaggaaggauucuggagccacagaagauagacag\n", + "augguaaguccccuuuuggagucagaggcuuagcpapugapuggcugugugcaaaaguccugcccccacuggapapaau\n", + "uggauagaagucaapcuccaaugucucccaagacgaaagaaucccaagucucauuuggaggaaugcuaucacuaacuaggauuccuggagcuaaaacauuau\n", + "gcpacguggacggaagaaaaaagagagugagcgagcgccggaaucagcccggcguggagugcggacccgcgguagugccapcgaaggcggcgguggugaggaag\n", + "aucgugcpacguggacggaagaaaaaagagagugagcgagcgccggaaucagcccggcguggagugcggacccgcgguagugccapcgaaggcggcgguggugaggaag\n", + "gaucggcccggaagugcucacacgugugcucccugcccugcuccuggccccuuggccggccpcuguuucuggcc\n", + "aggcaaggugcagacugccucuggagagcpcggcgagaggcupcccagauuccuucgcuu\n", + "auuugcauucagaaauuuaaaaaauacupccagacauaacccucagguuacuuuaccucugapugcaaccucuucuccucaaaa\n", + "puauugcccgagucupcupcucgagcgaaggaggcaaggugcagacugccucuggagagcpcggcgagaggcupcccagauuccuucgcuu\n", + "gucccpaggupaggaggcgguguuuccggccgccgucgcuguccapaggcugaggcgagag\n", + "gaggcaaggugcagacugccucuggagagcpcggcgagaggcupcccagauuccuucgcuu\n", + "paggupcpaagguccgaaggcggcggccugaggcugcaccpcacpucggccgcaauccagccupcggagccggaguugcgagccgcugccuagaggccgaggagcucacagcu\n", + "agcagcugccggccccuaggacagagcapaccucaacuacacugaucaccagccccaucggauccagacccggccaccag\n", + "acagcuuguuagagcugagcugcccuacuacagcagcugccggccccuaggacagagcapaccucaacuacacugaucaccagccccaucggauccagacccggccaccag\n", + "agcuuguuagagcugagcugcccuacuacagcagcugccggccccuaggacagagcapaccucaacuacacugaucaccagccccaucggauccagacccggccaccag\n", + "acuacagcagcugccggccccuaggacagagcapaccucaacuacacugaucaccagccccaucggauccagacccggccaccag\n", + "cucucuucucccuggucaaccgcucugcaaacaaccaucaaucugaucccacaggccugagaaagucugcucuccaguaccugcugcugaucuguuucagccgacaagaggcacc\n", + "ggcpugaaaggcugccucccgagacucuccuugcuuggaauucugcccacucugcggaguuagcagucacgaccuccagcacag\n", + "ugupugguggcaucagugauucaagacuguuuuuucuaccucuucagugccucuuucagcuaaaccag\n", + "cuuuauaaagguauaauugacaaacaagaagaguaccuaggccaggugcgguggcuuacgccuguaaucccagcacuuupaggccgag\n", + "gucauuuuaaacucucagagugaacgucuugauaggaccgacaagacgcaugacauguacuuagaaagcuuaucuuagagccacacugagauuggaacccgcaaaauaugccag\n", + "acuuccugaaaccucagcuaggacugcapapugcgaggcuagccacgcaggcpcccugg\n", + "gucauuuuaaacucucagagugaacgucuugauaggaccgacaagacgcaugacauguacuuagaaagcuuaucuuagagccacacugagauuggaacccgcaaaau\n", + "gcgcgcucugguacugcuguggcuccccguccuggugcpaccugugccccgcgcuucagcccuccccgcacagccuacugauuccccugccgcccuugcucaccuccugcucgcc\n", + "ggcaagaccggcuucpcgcgcggcggccgcuuugugugcpcugcauugugacgcpcgaugaagccg\n", + "auacuuucuccucuccccucucccaagcacaucugaguugcugccuguucuucacacuuagcuccaaacccaugaaaaauugccaaguauaaaagcuucucaagaaugag\n", + "agapaaacaaacgccggcgcugacapccgccagccccuccgccgcgcggagcccacgaapacagcgcagccggcccagagcucpucuccpaccgag\n", + "ccuuaugaucuccucauugcgucccccucugcccacuggacuuggacuucagaucugaccccagaccugccggcuaccucpapcccaccuccccgcccauccagcaag\n", + "acaaacgccggcgcugacapccgccagccccuccgccgcgcggagcccacgaapacagcgcagccggcccagagcucpucuccpaccgag\n", + "ggaaacaaacgccggcgcugacapccgccagccccuccgccgcgcggagcccacgaapacagcgcagccggcccagagcucpucuccpaccgag\n", + "aggcggcggcpcgccpaagaaaggaacauggcuccugaggcgcacagcgccgagcgcggcgccgcgcacccgcgcgccggacgccagugaccgcg\n", + "auucugagccgagcccggugccaagcgcagcuagcucagcaggcggcagcggcggccugagcuucapcagccagcucccucccggucucgccuucccucgcggucagc\n", + "ugaacuguggcuuccccccugcggugcugaacucgcccguguagcugugauuuuagagcugccgacagcucuaag\n", + "gucauuucucggcgccpaaaccugccauucuucgcugcugaucgcpauucuuuuuggauapuugacguucguggauagacucauaucugugaccaguguccgccaccgcgg\n", + "aaaacagaggaaaaaucaggaugaugacgaugaugaugaugaupuuuuuuggaccagcccuuccuccuggauuuaaaaagcaggaugauucuccuccaag\n", + "gcccauaauagguccugcauugccaccugguuucauuaaaucuacacagaaaagugacaapcagagaugauccaggacaacag\n", + "gaaacagacagcagugaagaugaggauauuauuggaccaaugccugcaaaaggaccaguuaacuauaauguaacgacagaguuugaaaaaapcccagaga\n", + "aggcuuuacgucauuucucggcgccpaaaccugccauucuucgcugcugaucgcpauucuuuuuggauapuugacguucguggauagacucauaucugugaccaguguccgccaccgcgg\n", + "ccauucuucgcugcugaucgcpauucuuuuuggauapuugacguucguggauagacucauaucugugaccaguguccgccaccgcgg\n", + "gcgcugcgcgcccggaggagcgaccgccgcaguucucgagcuccagcugcauucccuccgcguccgccccacgcuucucccgcuccpccccgca\n", + "gccauccagacugaggaagacccggaaacuuapccacgugagccacggccacggccgcauag\n", + "gcaagcaccggaagcaccccggcggccgcgguaaugcugguggucugcaucaccaccggaucaacuucgacaaaua\n", + "gcaugagccaucacaccggccccacguagcuuuguauuccugcaggcaagcaccggaagcaccccggcggccgcgguaaugcugguggucugcaucaccaccggaucaacuucgacaaaua\n", + "puguccuccccacagcaccacggcuucucuuccucagcacggcgacapcuuccccuucgccgccgccgccgccgccggccaagcuccgccgcgcccgcggcccgcggccgcc\n", + "acagcaccacggcuucucuuccucagcacggcgacapcuuccccuucgccgccgccgccgccgccggccaagcuccgccgcgcccgcggcccgcggccgcc\n", + "ucgucapaaagcuucgacugcaaaaaugguaugucccacuaucagacaaagagaagaaaaagaucacaagagaacuuguucagaccguuuuagcacggaaaccuaaa\n", + "pcuuccccuucgccgccgccgccgccgccggccaagcuccgccgcgcccgcggcccgcggccgcc\n", + "augccagccpuguccuccccacagcaccacggcuucucuuccucagcacggcgacapcuuccccuucgccgccgccgccgccgccggccaagcuccgccgcgcccgcggcccgcggccgcc\n", + "agcaccacggcuucucuuccucagcacggcgacapcuuccccuucgccgccgccgccgccgccggccaagcuccgccgcgcccgcggcccgcggccgcc\n", + "aagacucapcucucuuguuggugaacaguagcaaaaucuggaguaacugugccuggaauuuuuuggccccaagucuaaacaaaggaauaguuuccagauaagcgcuguuugcauag\n", + "gugguggucugucacguggupccaggcuauucaguucuuggucagcgagacgccugccuupugcuggaugccggcuguacgac\n", + "aaccacgupucccpcgcguuucpugcuggcggcugcagccggaguucaaaccuaagcagcuggaagg\n", + "pcpcupcggcaggucccpugcggacaucuggcagcuggcagupcggcguagagcacugcagcagca\n", + "cggcguagagcacugcagcagcaaugacggapcacgugaguccccucgccccpcuccugacga\n", + "cugapacgcagcuagaccuuggcpacpcuuucgccpcccaggcccapaccaggcggaggcgucgcpagccuuupcaccacagagaugcgg\n", + "pcagccccgguagcugapacgcagcuagaccuuggcpacpcuuucgccpcccaggcccapaccaggcggaggcgucgcpagccuuupcaccacagagaugcgg\n", + "pccgccggcagcggcgagcpcpapagcuuuccpccccucccgcgccucpcuggcpcgauggcgacgacgguuucccggcucccccgccccggacgccgauggcg\n", + "aggcpcagccccgguagcugapacgcagcuagaccuuggcpacpcuuucgccpcccaggcccapaccaggcggaggcgucgcpagccuuupcaccacagagaugcgg\n", + "gcgccucpcuggcpcgauggcgacgacgguuucccggcucccccgccccggacgccgauggcggugcguuccggcccucccccaacagcuucucccccgcggucgccggagccg\n", + "pcccaggcccapaccaggcggaggcgucgcpagccuuupcaccacagagaugcgg\n", + "gccuccguupauccagguccaaggccugucaccgucccgcccacaggugucccgacccaggcuaagcuugagc\n", + "aggcapcpcpcggccgacgacguucgucauuuagugcpapauccugaaccgcgcggccgaacccuccg\n", + "gccggaagagucagguucuguguaugucuccgcgucuuccgcggagcpugugcapccugcagcauugaacuag\n", + "apcaaucugccggaagagucagguucuguguaugucuccgcgucuuccgcggagcpugugcapccugcagcauugaacuag\n", + "ggaagagucagguucuguguaugucuccgcgucuuccgcggagcpugugcapccugcagcauugaacuag\n", + "cuucagccucagcuucggccucagcccgccgcagapacgcggagcccggcgcugagcccugcgcgcgcgccugccgguccgaucuggacgaacgcgaggcguucugcgagagcgaauucg\n", + "cggugaacpaucgugcacgauguggacgugcupcgcpcauccggcuggugacccugcugguggaucpacpcuguacaag\n", + "gucuuucccguucggaucgcpaaagcaguggcuccaagugagccagaggagagcugaggagaggapaggccgacgaccupcccupccucugaag\n", + "gucuggcguauucugacaggacacagugagcgucuguagaggagaggcuugaaauaaaggagcacgaauauugccuggauuucuggag\n", + "gccuacuuuaaggcuggccaauucugcaagaaaggcaaggaggaggagacuggcucacagcucuggag\n", + "gacccccuucugucagcugupcuugacaccacuugaacaagaaaaggapaaacugcaccacaucagugaag\n", + "cgcgucuuucccguucggaucgcpaaagcaguggcuccaagugagccagaggagagcugaggagaggapaggccgacgaccupcccupccucugaag\n", + "gcuccagguugaugucaaagucuugugucugugcgguaggucuggcguauucugacaggacacagugagcgucuguagaggagaggcuugaaauaaaggagcacgaauauugccuggauuucuggag\n", + "guugcuuuuuuuaguuccggcaaugaguugcgccpcggcggcggcuccccgccuuuggcggcugcgcccpcccggcggucccucucag\n", + "agcggcgagagugacaggaggacapuuguuucggcagugacgccupagugacgcaauugcaccccugugcagugaugucacggcag\n", + "pcgaaucuaucagacaaccuaucaauupcugaugaugucaguguuccaguggcuucuaacaggcguuaauaccuguuggaaauggauuaucauuggcupacgauug\n", + "gucgcucpcgguggcpcuccpauuggcgguugcuuggcpcggugucaggcucucgguggcggcggaggcggcggaggccapaggaagaugucguaaugagcg\n", + "gcuggaguacaguggcacgaucuuggcucauugcaaaauccgccucccpuucaagcgauucuccugccucagccuccugaguaguupauuacag\n", + "apcacuaggaggaggcuaagapaccaucccacuaaugaaccacacagucagaaucucauuuag\n", + "pagagaaacagaggaggagacugcaagagaucauuggaggccgupcacgcucuuuacuccaugugupacauucauugcggaauaacaucggaggagaag\n", + "gacagguuuuaaaugaguguuuucauuccucgccugcgguuuggcpacagcgcugcagcccaugguguggagcgcggcupaccapag\n", + "auuacuguuggagcuacapagagaaacagaggaggagacugcaagagaucauuggaggccgupcacgcucuuuacuccaugugupacauucauugcggaauaacaucggaggagaag\n", + "gagguuggagccaagauggcugaauaggaacagcuccggucuacagcucccagcaucagcgaugcagaagaupugauuucugcauuuccaucugag\n", + "aacugagcgaggagcaauugauuaauagcucggcgapacucacugacuguuauaauaacacuacaccagcaacuccuggcuucccagcagccggaacacagacaggagaga\n", + "cugucugacaacaucuacccgguggaggaccucgccgccacgucggugaccaucuuucccaaugccgaacupaggccccuuugaccag\n", + "gucucguguuucucucuuccaaucgguugucuuuaucguggacacugagguguucucugccuugacuaaag\n", + "acagacucucgauuccauggacacaguccucaupcucccuccagcacugcuguugccugcugccuaag\n", + "acagaaggaggaaggacagcacagcugacagccguacucaggaagcuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "gcugacagccguacucaggaagcuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "agcacagaaggaggaaggacagcacagcugacagccguacucaggaagcuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "agaaggaggaaggacagcacagcugacagccguacucaggaagcuucuggauccuaggcuuaucuccacagaggagaacacacaagcagcagagacc\n", + "pccaccauauuuugaaaaaugauaacaauaacuauaucagaugacacuucaaaugaaaauauaagcaggac\n", + "gcugacagccgugcucuggaagcuucuggauccuaggcucaucuccacagaggagaacaugcacgcagcagagauc\n", + "agaaggaggaaggacagcacagcugacagccgugcucuggaagcuucuggauccuaggcucaucuccacagaggagaacaugcacgcagcagagauc\n", + "aggaggaaggacagcacagcugacagccgugcucuggaagcuucuggauccuaggcucaucuccacagaggagaacaugcacgcagcagagauc\n", + "aaagcacagacuuccuguuuugccugcuagcaucucccuguaacucucccaaucuugaggagugaucccugucccagccccuggaaapcaggaacgacaaacucaaaguccag\n", + "acagacuuccuguuuugccugcuagcaucucccuguaacucucccaaucuugaggagugaucccugucccagccccuggaaapcaggaacgacaaacucaaaguccag\n", + "aguccagccuguuauugugaauggagccgagauuugcccucuacccucaccuaagcucugauccuucagugcccgcaauaggcggcucaucuguuauccauuguguaaaugacuagag\n", + "agcaucucccuguaacucucccaaucuugaggagugaucccugucccagccccuggaaapcaggaacgacaaacucaaaguccag\n", + "guuuugccugcuagcaucucccuguaacucucccaaucuugaggagugaucccugucccagccccuggaaapcaggaacgacaaacucaaaguccag\n", + "paacucaccuaaccuucccgagccuucguuuccuacucugcaaaauggagauaacaagucugcauuuuauuauguaacuacguccuaag\n", + "gucuagauucuucuuggccucucugagcagcauuucuuccuucugcguaupacaggacccuuucuggaaupucuuaugaccuacaaucaaacaag\n", + "ggacuccacgucaggcugucucuggugcgcucgccccuccccucugaggagauguuauuucccuccuuucuucuccgapucaagauucuucuggaagag\n", + "guucgaaaacauggccaaaagaaaugccgagaaggaacugacagauaggaauupaucaagaagaugaagcugaagag\n", + "auggagucuugcucugucacauaggcuggagugcauuggcgcgaucucagcucacugcaaccuccaccuccupuucaagagauucuccugccucagccuccggaguagcupauuacag\n", + "pupaugacagcggcgacgcagccccggcuguuuuugaagcpcccpccccaccpcugcggcguccgacucgagugagacucuccccugcggccccgccggag\n", + "uguguucaguggcgauuggapuagaccugupcacggacgcacgccacuuuuucucugcugauccag\n", + "augcauuuucccagcuguguucaguggcgauuggapuagaccugupcacggacgcacgccacuuuuucucugcugauccag\n", + "gauccccgaggcccapcgucgugcuuccgcgcgccccgugaaggaaacupagucuugapacccccgacuccaagcgcgaaaaccccgg\n", + "ggcacagacacagauaggagaapcaccggcuggagccacuugcaggacugapuuuuugcaacaaaacccuagcagccugaagaacucuaagccag\n", + "uggaugugaagucagaaguuccugupccuggagcccaucucaccuuuagaccuaaggacagaccucagg\n", + "agugaugaauguuucauguagcugaaguaagagugacuggaauaugcugcagacaauuuacgagagugacuccuguuuuuccucagaupuggcuggacgagagcagcucuuggcucagcaaaga\n", + "guuucuccucugccaaccccuccuggaccauugucagcaguugaacgacaaaggcugugaaucugcauccuagucuuagcagucccucugauucuc\n", + "gaguaccugguaaaaugcugugguguauggagacaguuaugagaaacuggapaggaugauaguugag\n", + "paagagaggcacagacacagauaggagaapcaccggcuggagccacuugcaggacugapuuuuugcaacaaaacccuagcagccugaagaacucuaagccag\n", + "aauauuauaacggauacagaaaaguucagaaggacugagcuaguuugcgaaaccacagcacacuuuggcaaagapaaugcacaacaaaacgg\n", + "aucccgcccccacucucagucccagcggccgccagacccgccggaguuggacccgagcacgccgcggagcccggacccucccucggacgcucugccccggcc\n", + "agucccagcggccgccagacccgccggaguuggacccgagcacgccgcggagcccggacccucccucggacgcucugccccggcc\n", + "gcuguggaagagagccaccauuaucaaaaugaucacaguugcaaacauucgugcuucaaauaccagccacu\n", + "gcaguuagagccgaucucccgcgccccgagguugcuccucuccgaggucucccgcggcccaaguucuccgcgccccgaggucuccgcgccccgaggucuccgcggcccgaggucuccgcccgcacc\n", + "cccgcgccccgagguugcuccucuccgaggucucccgcggcccaaguucuccgcgccccgaggucuccgcgccccgaggucuccgcggcccgaggucuccgcccgcacc\n", + "ccuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "ugugccuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "caugcagugugccuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "agucucaagcucugguaggcaagugcaugcagugugccuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "cuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "aagcucugguaggcaagugcaugcagugugccuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "ccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "cagucucaagcucugguaggcaagugcaugcagugugccuaaaaccugccagcaguacuuuugaguuuuuuuuuuuguuuuguuuuacuuuagcauuuauuauucauggauugaagaaaucaaa\n", + "aguuggcaagcggaccaccagcaacagacaacaucuucauucggcucucccugaagcuguacugccucgcugagagg\n", + "cagaaucagaaagcuguuaagcaggaaggagugcgcugccaugaagaggcagacagaagccagagccagugugucuggaaugcaucag\n", + "aaaacugcpcuccgagcupugcagcaaccggaggcggcggcgcgucuggaggaggcugcagcagcggaagaccccaguccag\n", + "guggccacaggccccgccuuccgcucupccgccgcgauucupcgugcgugapapupugcugaaggcggaggcagcacccacgccag\n", + "gccguggccauggagcucuggaagcupcupaggaagccugguggcucugaccuccccuggaggcgaaggaggcccagcc\n", + "cuucuuuccuuucacccupcugcggcucugaggcugccguggccauggagcucuggaagcupcupaggaagccugguggcucugaccuccccuggaggcgaaggaggcccagcc\n", + "cpcucaacccccagaccuccagaaaugacgucagaaucauuugcaucccgcugccucuaccugccugguccagcupacccugccucgccggccgcauggccagapuugg\n", + "aacuuuacapucgcuagcuaguaggapcuuuauggagcagaaaaacgacaaagcgagaaaaauuauuuuccacuccagaaauua\n", + "aucgcgccaguuccucagccucagugcuaugaaggugacagcgugaggugacccaucuggcccgccgcg\n", + "cgccaguuccucagccucagugcuaugaaggugacagcgugaggugacccaucuggcccgccgcg\n", + "ccuuguapcgugaapucauugccccauuuapaugcgcaccuccugauuucccguccacugcucugcgcccugaaguggcugaaaagugcucuuaaaagg\n", + "aguuccucagccucagugcuaugaaggugacagcgugaggugacccaucuggcccgccgcgaugcuggcaacacggcggcugcucggcuggucgcuucccgcgcgg\n", + "cacccaagaaaaccucauuuggcucgcugaaggaugaagaccggauuuucaccaaccuguacggccgccaugacuggag\n", + "gcuaugaaggugacagcgugaggugacccaucuggcccgccgcgaugcuggcaacacggcggcugcucggcuggucgcuucccgcgcpuaucugugcguuucagcggcgacacg\n", + "uagauguuguacccaggcugguuacccugguaacaggcgucgcgguuugucaaggaacugagagaagag\n", + "ggcgucgcgguuugucaaggaacugagagaagaggupuuugccaaccuauagaaugauuacccguuagaacugagagaagag\n", + "agagcaucgcggcuuuggcugcaacaggcggupcucggcucpcggaggcggcgaaapcpagcgcgaggaggagcgaccuggccucaccgcugccgccucuuccccgccgc\n", + "cuuccaucuccaugguuacgcggcgguggcugcgagcgcccaacugcuccgaccgucgcggugapccccaggacagaagcagacagacacggcuccugcugucgauuccgauccag\n", + "gccugcggcguagacuuugagauucgagccuucugugcuaaaucacuagaagagaaaagccacaaaag\n", + "gaacucugugcggcuggugauccgaaaggugcaguucgccccggagaaacccggcccccagccuucagccgaaaccacacgccacuuccuc\n", + "gcauuggcgcpaggagcapaucuuggcagcpcgaggaggcugcgagcgagccgcgaaccgagcpcggcpcgcgcgcacc\n", + "auuggcgcpaggagcapaucuuggcagcpcgaggaggcugcgagcgagccgcgaaccgagcpcggcpcgcgcgcacc\n", + "paggagcapaucuuggcagcpcgaggaggcugcgagcgagccgcgaaccgagcpcggcpcgcgcgcaccaupagaaacccpaccag\n", + "apaagaggcgagagcgcggapcgcgcgugcgcauuggcgcpaggagcapaucuuggcagcpcgaggaggcugcgagcgagccgcgaaccgagcpcggcpcgcgcgcacc\n", + "gcgcauuggcgcpaggagcapaucuuggcagcpcgaggaggcugcgagcgagccgcgaaccgagcpcggcpcgcgcgcaccaupagaaacccpaccag\n", + "ggaacaagugcagaacaggauaaucgguucagcaacaaacagaagaaacuacugaagcagcugaaauuugcagaaugccuagaaaaaaag\n", + "agagaugucuuccaaggacaapagapauuauacaagagugagguguugucccugauauagaccugaaupcucagcccuagacacacuuuuaaag\n", + "cauuccuuccpauuaccucacgguucccaggagaagaggaggagaagaaugagcaauggauguguuguugacuguccucccuuuug\n", + "aagcuguauccuuugucccagccucagcucupucacguugauuugucacggcagccccacugcau\n", + "guccuccaccaugugaaugccaacauggccaggucauuagagcugapaaaacuagugcccaaagauaugaaaagaguguggaucuucuggagaagugcuguuguucaacag\n", + "aggugaucauuucaaaccaagcaucagcaacaauuaaaaauauucacuugguaucuguaguuuaaua\n", + "uugugcuuugcgaugcugaguuuacuguuuuaaauggacuucaagcauagcccugaaguguugucccguuguucccaccuccuagapccugacagaagagguacauaugcuau\n", + "acucaccagacagcapucgacugcuagugaccuugagcccaguccggacagacagacaggcagacagacgcacggacaagcag\n", + "gcgcugcguucccuccgacgguacccacugccgcugcgcagcpaaggaagcuaagauccuacagcacuucggagacpcucugccgg\n", + "ucggaacucgccupcgccgccggcggcggapagcgugacugcgcugcgcapcgcuaggaggcauugucgcc\n", + "gcgugacugcgcugcgcapcgcuaggaggcauugucgccguaaguggagccaaaagcggcccggagcpaccacacgcuucuugccccgcaaa\n", + "ccccgcgcgccccgccccgccggcucggaacucgccupcgccgccggcggcggapagcgugacugcgcugcgcapcgcuaggaggcauugucgcc\n", + "accuggccgagugcaagcuggucuccuuucccauuggcaucuacaagguccugcggaaugucucuggccagauccaccucaucacccuggcuaacaacgagcuuaagucccucaccagcaaguuc\n", + "cggaacucgccupcgccgccggcggcggapagcgugacugcgcugcgcapcgcuaggaggcauugucgcc\n", + "gcggcgcuccccugcucucuggcuccpcugcggcgcggcggcuggagcgagccccugucccggcgcpcggcggcpcggccggcaggcgcugccuugcgugugagugcaccucacucacau\n", + "gguuagaagcucugcuccccggcpacacucagucgcgucggcaccgcggagcpcugcgucag\n", + "agcaccuauggcccucccugagaagacaggauuuugcuauauagacuucgcaaaccuucucucugccugagagacug\n", + "gaggaccagcgcaacgaggagaaggcgcagcgugaggccaacaaaaagaucgagaagcagcugcagaaggacaagcaggucuaccpccacgcaccgccugcugcugcugg\n", + "gugcuggagaaucugguaaaagcaccauugugaagcagaugaggauccugcauguuaaupuuuaauggaga\n", + "gaacugaaguuaaaagaugaagaaugugagaggcuuucaaaagugcgagaucaacuuggacaggaauuggaagaacucacagcuagucuauuugag\n", + "cuucauugguapaaacucugcagcuuugucaucuaacucuuccagacaagaaaguggaauugaaaacuacaacauguuaauggaagcaag\n", + "gcaccuguugaaggaaaaagaagauccauccuuauagaaauaguugaaggcaacugagaaaaggugaagccauu\n", + "uuacuuacaaugcaucuuuagacgcuaucauuuccaguacaaccagcaauacaaauaguguggug\n", + "auucagagucaaguacuucauugguapaaacucugcagcuuugucaucuaacucuuccagacaagaaaguggaauugaaaacuacaacauguuaauggaagcaag\n", + "ggcauucagagucaaguacuucauugguapaaacucugcagcuuugucaucuaacucuuccagacaagaaaguggaauugaaaacuacaacauguuaauggaagcaag\n", + "gcauucagagucaaguacuucauugguapaaacucugcagcuuugucaucuaacucuuccagacaagaaaguggaauugaaaacuacaacauguuaauggaagcaag\n", + "aaacpaacagcccuggcugapagcugcagcgcagcagaguaucugacggcgccagguugcguaggugcggcacgaggaguuuucccggcagcgaggagguccugagcagc\n", + "acacagcgguccupuugccuuccagaugaagaucuaucaaagauuugaagucuuguguaugugguccuagaggaccccaggcuguuauaccgauccaugaggcaucugaccccuuccaaagg\n", + "augaugcaguuugcuuggcagagcuauaagcguuaugcaaupaaaaacgaacuccguccacuaacaaaagauggcuacgapuaac\n", + "auggccugauaugaaggagucacgccucccgccucccggagcugcccaguggcugccuuguccuucaagugcaggagcugguucaa\n", + "uccppcpucagcggaagugapcgguugaggcupcggcccaagguggaaggapccgugaggugagagaguccpagcccgagcuugag\n", + "apaaaucuggugcuccuccagauggccugauaugaaggagucacgccucccgccucccggagcugcccaguggcugccuuguccuucaagugcaggagcugguucaa\n", + "ggucagcggaagugapcgguugaggcupcggcccaagguggaaggapccgugaggugagagaguccpagcccgagcuugag\n", + "accaucccaaucuggcaaaacaagccacaupcugcucgaaguguaguaagaagaauupaccaaccuacccuugaagccgugugcccpcguccuuugag\n", + "acccugcccaacaucucugaccuguguuugagagaugugcccccagucccuacccuggcugacaucgccuggauugcugcggaugaagaggagacauaugcccpucag\n", + "apcgguugaggcupcggcccaagguggaaggapccgugaggugagagaguccpagcccgagcuugag\n", + "pucagcggaagugapcgguugaggcupcggcccaagguggaaggapccgugaggugagagaguccpagcccgagcuugag\n", + "cugucuccgucucuuugcuccagaccaucccaaucuggcaaaacaagccacaupcugcucgaaguguaguaagaagaauupaccaaccuacccuugaagccgugugcccpcguccuuugag\n", + "gcuuccppcpucagcggaagugapcgguugaggcupcggcccaagguggaaggapccgugaggugagagaguccpagcccgagcuugag\n", + "auggccugauaugaaggagucacgccucccgccucccggagcugcccaguggcugccuuguccuucaagugcaggagcugguucaaaugucaggaauggaagccacugug\n", + "aauaggugcucaguaacugaguaauaaaguaugcugaguccagcuuccugcuuugaucuccuggaaggaacccuugcccccapacagcugguucgguagcagugguguucagg\n", + "ggagcggacccgagugauacccpagacuagcuuggccacaggagacaacguugagguacagacag\n", + "uuugcuaggucuaccauaaccaaauaccgcagauugagugguucaaacgccagagauugauauucucacaagucuggaggcuguagaaaucuaacaucaaggugccaacagg\n", + "gccucapaagcgagcccpcgccggcpcggccgucgcgucugacagaccacugcagaccacpccgaggcccagcgcccguccgcagcgcggccggc\n", + "guugcugcuuuugcucagaggacauccaugacccuaauggucuuuuuguucaagauaaagugauuuuuugccuuuguugauuaacuggacaaauucag\n", + "gauaccagaaggcccuauugaucapccagcuauaggaagaguacgcguuuuagaagagcagcuuguuaaggccaaagaacagauugaaaauuacaagaaacagaccagaaaug\n", + "agacapuuucucuguguugcccaggcuggucucgaacucugagcucaagcgaccugcccaccucggccacccaaaauguupauuacap\n", + "gugugcupcggcgcgcuccgguccucccgcucagcuggcggucupcugcucupcagcccuucgguccacugcucugcaucgcpcgccpaauuuuccgaguccgagcgg\n", + "auucuauuuugaccagcaauaaguugaauuaupcuagaagauaaggacuaaaaacaagaauugguguccagaaag\n", + "agauuccgaaauuuuuaaccucugaagcugugccuucacaugaucuaggacagcguucagaagauggcuacagucuguugguuuguauucugugaaaauagaaaaaaaaauccg\n", + "aguaugguguuugcgaaaacuugcggaagcuggagaucacaggcgugucuugucpacgucuaugcgaagc\n", + "ugcuucaccgauauagacacauuuupauuguggcagccagauaucpccauacggaggacugcugaacguggug\n", + "ggagcupccpcccgagcggaucgcpcucpcugcpcuccggcugcpcgcupccgcgaggcgcggagcuupagcggagcccaggccgugccgcgcggcgcc\n", + "cccgagcggaucgcpcucpcugcpcuccggcugcpcgcupccgcgaggcgcggagcuupagcggagcccaggccgugccgcgcggcgcc\n", + "gapcpcccgucupcgccggcpugcguuugaaucugguccgagcgcpaaacggcpuccccgagcccag\n", + "gaauggccuuuagaaapagcaucuucagaaucugcagcupaucagauuguucuuuuguugaaucaacucagcucugccgagccagcaucuugcuaag\n", + "pcccgucupcgccggcpugcguuugaaucugguccgagcgcpaaacggcpuccccgagcccag\n", + "gucucacuguguugcccagguuggagugcaguggcguaaccucccaggcuccauugaucucccuccuuagccucccagauagcupacuacag\n", + "cagcaugucagcauuccgucugcaguugagauguugauuccuccuuguauugcacauugcugaaapcuuccugaggcuggagagagcagugag\n", + "caugucagcauuccgucugcaguugagauguugauuccuccuuguauugcacauugcugaaapcuuccugaggcuggagagagcagugag\n", + "uuuccuccuccuagccggacuggapagacaaagcagcgcccgucugcuucpccucuggaauuuagcgcucgcccagcuagccgcag\n", + "guuggagugcaguggcguaaccucccaggcuccauugaucucccuccuuagccucccagauagcupacuacag\n", + "cuccuccuagccggacuggapagacaaagcagcgcccgucugcuucpccucuggaauuuagcgcucgcccagcuagccgcag\n", + "ggcggcgguuggcccaguuccaagguugacucccucuuacguccucuugcaucuuggugacauuuuuuug\n", + "ccauuuccuccuccuagccggacuggapagacaaagcagcgcccgucugcuucpccucuggaauuuagcgcucgcccagcuagccgcag\n", + "aggapuupcagucgcuggcgcugccgcugguggucccugugcuugaagugccggugguaucggaguccaugcacccaaggcccagcacccagcaacauucucuggcccagcagap\n", + "ggagacaaagcagcgcccgucugcuucpccucuggaauuuagcgcucgcccagcuagccgcag\n", + "cugccgauucugcauagagagaucaucuaaaupcagaagccugcacaauuuaugaagugcugauuuaacaccagccuaugcaag\n", + "pcagucgcuggcgcugccgcugguggucccugugcuugaagugccggugguaucggaguccaugcacccaaggcccagcacccagcaacauucucuggcccagcagap\n", + "cuagccggacuggapagacaaagcagcgcccgucugcuucpccucuggaauuuagcgcucgcccagcuagccgcag\n", + "guacupauaguccgcapaguuggaacguaaaugcaaggucugcagcuuccgaaggccauagaagagcucupugcagagaugacagcugauuaaaagacagguccaaauuuugcag\n", + "accgcuccuccucccucucapucacucccggccuaagcucccacuapccpaggaaggaauucugag\n", + "aauaaagcgagaaagaagaacuccugacuuaaaaacaugauauuccuucaguguaggaagcagcagugagguuguaauaaaggcugcauucaagaagacccaucugaaca\n", + "ggagugcccaggauggagugcaguggcuauucacagguuuaaucauagcucacuaccgucuugaaucccupcucaagugauccuccugccucagccccugaguagcugguacuaaag\n", + "uuaccuuccacgcuguauguccgugagaaauacaaugaagacggucugaauaaugaacugguaaucuucgauaauaugaaacgaauuuaagagaacauaucaaagag\n", + "aguuaccuuccacgcuguauguccgugagaaauacaaugaagacggucugaauaaugaacugguaaucuucgauaauaugaaacgaauuuaagagaacauaucaaagag\n", + "acuuccgcccgcgacccccuuccagacccgcucccgaaaccuugucgaaggaccaaaggcgaccggugcag\n", + "aggccccuucccucugcccccpugcuugaagucuagccccauccugguccaaugcgcucuugguagccuccuuucccagcugcccgcccgccgcc\n", + "gcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "uuuuccagcggaaguggcuccuguaaggcagcaagguagcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "ggaaguggcuccuguaaggcagcaagguagcguggccggcgcccgagcupuugugucccugcupcugccguuccagcuggacugccgcc\n", + "aaaaauugaugaacugaagaagacaugguccauuaugccuuacaaacuuacacagugcuuupaauuccaaaguacucaguggagagagg\n", + "guugcuauguugcccaggcuggucuugaagugccuugaccuccuaaaguguuggaaccacagacgugagccacuccacccagccuaaaacuucaucuucuuug\n", + "gaugagaugaacacuuuuaacaagagaacaggacucuauauaaaucgcugupcucaccaccucuaaggaggagcacugacugaagacag\n", + "caucuacagcuccgugauuucaaggcauccuucccacccguucguuuuuagcucggcugccgaacuucauugcacaguugag\n", + "guuacaauaccaggupccaaaauuauccuuccaagauuaaucaggaaaggaaacaguuuggacaucccaguagcaguuacaauuuucuuupccaaugacagugcacuaaaag\n", + "cggccccgccccgccccgcccggcugcuccauggcgcugugcgaggccgcpcugcpagugcccugcucuggccucgcuuguugcucuucpacuccaucacccag\n", + "agugcugcagccgcugccgccgauuccggaucucauugccacgcgcccccgacgaccgcccgacgugcauucccg\n", + "gugcugcagccgcugccgccgauuccggaucucauugccacgcgcccccgacgaccgcccgacgugcauucccg\n", + "agagugcugcagccgcugccgccgauuccggaucucauugccacgcgcccccgacgaccgcccgacgugcauucccgguacg\n", + "auggacuugccaguuucaaaaguuuccugaagucugaauucagugaggaaaaccuugaguucuggauugccugugaggauuacaagaagaucaaguccccugccaag\n", + "agacaguuuugaaguuuucaaagacuggcucugcuguuaagaaguuguacuuaaagcggaggagcuaagccaccugccaaa\n", + "aaacagagcgcuuaaaaagcacugucuggauaucuucagapaaaaaggagaaaguuaacugaauuggugacacuucpucucucacagaggaag\n", + "ggccaaggagauuaagaucaaguupaauucuccuccagaagccagacucaguuggugaccuugucauuccguacaaugagaagccagagaaaccagccaagacccagaa\n", + "guuuucaaagacuggcucugcuguuaagaaguuguacuuaaagcggaggagcuaagccaccugccaaa\n", + "cugaucaccugccuuuccagaccggagacpcggcaaguuugaagucgacacccagaggccaguuugucccccuucccg\n", + "cgccagcgagaagagagcuccacgcucagccucagaagaaagacguucaacgacuuacupagagaaagaaaaggaacpagcugagag\n", + "aaaccgcaacggagagcagguccpuggaagagguuuccuccgcgccgccgcuuuauuucgcugaacuugcpcuccagagaccuuaaacg\n", + "agaaagcucgccagcgagaagagagcuccacgcucagccucagaagaaagacguucaacgacuuacupagagaaagaaaaggaacpagcugagag\n", + "aaaguuucacacauaugauuuagaccuuacgaucagccauuguuuacaucpaagcaucaauccggaguaacuggcaagcag\n", + "cuuucguugcagcgcgcpcggcccgagccucggcggcggcgguagcggcggcggcgacgcugacaccucccacc\n", + "aaauccgaucucaaauaggaaagaagucucauuggccuuuuggucuucuaccuguguccugaauugaguuuguuaauccucauucggag\n", + "gccauucagaaagcucgccagcgagaagagagcuccacgcucagccucagaagaaagacguucaacgacuuacupagagaaagaaaaggaacpagcugagag\n", + "pcpcggcggccgcucuggcgcggcupaugcaccuugagcggcgccuuucguugcagcgcgcpcggcccgagccucggcggcggcgguagcggcggcggcgacgcugacaccucccacc\n", + "gagcuccagccuccaggcacccpauccagcgccgccgcucauaacacccgcgaccccgcagcuaagcgcagcucccgacgca\n", + "cpcugacgcacgaggcacacaggaaggagguggagcagguguaucugcgcugugcggcpugccguggagugg\n", + "guuuuauaauaaucaagaagcacaugaaagaggccucuucaucaagcauucuugacuaaguuaugaaaauggaauugaaguuuauuuucccccuucauaug\n", + "acguuugaugcaaaugauuuguaucapcagaauuuuaacaagguccucaguuccuuagugacucuaaauaaaguaacagcag\n", + "acuuccggcgccpcucacuuccuggugcpaapcagagauuggugcagccccggaggaagaaaaaagg\n", + "gucuaccccgagccccggagcgagagcgagugccugagcaacauccgcgaguuccugcgcggcugcpcuucccugcggcuggag\n", + "ugucuuaugaapagauccagagaacagaacuaagccucuuacugucuguuuacuuugauucugucagcaacuucaugag\n", + "aaaaacacaccuugacuuuagucagauacaucacugucuguuaaaggaaaccaagcgugaaguggaagucuaacacaugaggauacagaauugauucaaa\n", + "gauucugaaaccuuccuuguaucccuccugagacaucuuugcugcaagaucgaggcuguccucuggugagaagguggugaggcuucccgucauauuccag\n", + "gauguggccagugguguggaugugaauauucaucccuguggaggaaaauagupucucugagauuu\n", + "gucagagucggcucagccugcgccpaacaucggccgccuccagcucccggcgcggcccggcccggcccggcucggccgccucag\n", + "cagagucggcucagccugcgccpaacaucggccgccuccagcucccggcgcggcccggcccggcccggcucggccgccucag\n", + "pugugugcppccggaggcggcggcugucagagucggcucagccugcgccpaacaucggccgccuccagcucccggcgcggcccggcccggcccggcucggccgccucag\n", + "acuccgccgcugcaggucuuupucgcgucugucacugcgcucugucgucggucggcgucuggcacugga\n", + "auacgccpcpccgagaguuuggagccccggagupugucggcgccucauucpuggagcugagccggagacag\n", + "ccgagaguuuggagccccggagupugucggcgccucauucpuggagcugagccggagacag\n", + "gcagcguccuugugaacuuuccgcuuggauccugacucugcuguuaguagccuaugaccuuggaugaaau\n", + "gucpucccagagccpcgcggcupcccgaggcuagcaucucucpagccgcaaggcgagagcugcaaag\n", + "uuuaauuagacacuucagaauuuugaucaccuaauguugauuucagauguaaaagucaagagaagacucuaaaaauagcaaag\n", + "ccacuuccucuuccucuacaucaagcuuguccaacccacagcccaggacagcuuugaaugcagccuaacacaaauuc\n", + "auuacacagaugaaucuugcacuuucaagauaucauugcgaaauuuccgguccaucuuaucaupaauuaaaaaaccacuccauuguaccaacucacuauacauugcuguauacaauc\n", + "gcaccugcgaccccaggaccccucccpcccuguccugcgcccuccacgcgucgccccugcupaguccgcuuucguugcaccccuccgcgucccaccccaccccaccaagg\n", + "cgagcgucpucccagagccpcgcggcupcccgaggcuagcaucucucpagccgcaaggcgagagcugcaaag\n", + "aggcgcugucuuuccuucccucccugcucggcggcuccaccacaguugcaaccugcagaggcccggagaacacaacccucccgagaagcccag\n", + "gcuggaguacaauggcauggucuugguucccugcaaccuccaccucccagguucaagcgauucuccugccucagccucaugaguagcupauuacaggcacgcgccaccaagcccag\n", + "gcucggcggcuccaccacaguugcaaccugcagaggcccggagaacacaacccucccgagaagcccag\n", + "guuucuacugagcugucaguaucuacagagagauugcuauaucauaaacaaauacauauuaagaaccagccucagccaucaccgaacucaguaaauaucuaag\n", + "uucuggaaaggaagaugauacagaaaccacagccauuuugcagauaugaaaacupacauagaaauuugacugcccuggaaaagaucaccuacuuauuugaugacagagccaguucapaugaag\n", + "ggucaggcgcugucuuuccuucccucccugcucggcggcuccaccacaguugcaaccugcagaggcccggagaacacaacccucccgagaagcccag\n", + "cuuuaagguaacuacaaacgaaugaguaugaacaugugauucaggaaaucgcuuuuucugupcuuccagaucccaggauaaag\n", + "gcauugaagacgaaaccucpaggucaggcgcugucuuuccuucccucccugcucggcggcuccaccacaguugcaaccugcagaggcccggagaacacaacccucccgagaagcccag\n", + "uaccuauaacagugccugccacacccauguaugcaggaaauaagugagcgaaupauaccagcuaccccuuugcagagaaaagaauucuaccacu\n", + "ucpaggucaggcgcugucuuuccuucccucccugcucggcggcuccaccacaguugcaaccugcagaggcccggagaacacaacccucccgagaagcccag\n", + "cgaaaccucpaggucaggcgcugucuuuccuucccucccugcucggcggcuccaccacaguugcaaccugcagaggcccggagaacacaacccucccgagaagcccag\n", + "acuuccggccpaccccggaggcggaggcagcgaaggcggapcggcpcggcggcggcggcggcggcggcggcggcggcggcggcggcggcggcguagccguagagg\n", + "agcucccgcccgccugugccgccugugcggccgccpagccaaguuugcgcggaccccgucccgagcccgccgcggcc\n", + "cgcgccgcgcucgcucagcucccgcccgccugugccgccugugcggccgccpagccaaguuugcgcggaccccgucccgagcccgccgcggcc\n", + "cucucgaguccacccuccpccuucugccccugaucgcuugguuuuccuugcagucgccugcugcugucgucpag\n", + "acauapccugauuacauuccaacagaggaagaaaggagagucuucgcagaaugcaaugaugaaagcuucugguucagau\n", + "uuuucucccucccugcccccucucgaguccacccuccpccuucugccccugaucgcuugguuuuccuugcagucgccugcugcugucgucpag\n", + "ccgcgguaccuugcacuuuucucccucccugcccccucucgaguccacccuccpccuucugccccugaucgcuugguuuuccuugcagucgccugcugcugucgucpag\n", + "uuuccugccguaaguauacagugccuccpucgcggucauuuugagccccugucuggaugacuucuugcggcuguucuaccccucccccuccccgcg\n", + "agugccuccpucgcggucauuuugagccccugucuggaugacuucuugcggcuguucuaccccucccccuccccgcg\n", + "gccuccpucgcggucauuuugagccccugucuggaugacuucuugcggcuguucuaccccucccccuccccgcg\n", + "agaugaacugaggccucugcuagcaaucaugucaguaagcugccuuggaaguggauacugcagccccaagagagccuucagaugacuguaaccccagccuaccucuuaaucacagccug\n", + "gugagaaaaaccguagccucagagagaucacgguacccugccagagguuguagaacuuguuggaaacuuggaucaagapugugacaaauaaccag\n", + "ggaaagcggccucuuacucuaggccuuucgguuugcgcgagcpcaggaaagcgugcgugcggcuaagagagupcgcucucgcggccgcugacg\n", + "gaaagcggccucuuacucuaggccuuucgguuugcgcgagcpcaggaaagcgugcgugcggcuaagagagupcgcucucgcggccgcugacg\n", + "cuaggccuuucgguuugcgcgagcpcaggaaagcgugcgugcggcuaagagagupcgcucucgcggccgcugacg\n", + "aggccuuucgguuugcgcgagcpcaggaaagcgugcgugcggcuaagagagupcgcucucgcggccgcugacg\n", + "agcuucgagccgaggugcagugagcugguppaccgcgaggcgagcgcpagccupcggcgagccpugugagcugccugaaa\n", + "gugcccggcggcpuccucagcuucgagccgaggugcagugagcugguppaccgcgaggcgagcgcpagccupcggcgagccpugugagcugccugaaa\n", + "cagupccupaagauguguuuccccuggaugugcacguuccuguuuguggcuuaucgccucucguuuauucugugugaguagguagaaa\n", + "aaacugaaagccggaccccaggccgccgcgcugccgcccggccuccccgccagcgcgccaccaupcagucccgguuuccccuuguaaagauggcggugapaucgcugcaaccuuuagacua\n", + "ucaaucucucucucucuuucpcggagucgcccaccacugccagcccagcgcuppaccugcuccaggcuguagccgcag\n", + "agucucaggcuuuucucucucucaaucucucucucucuuucpcggagucgcccaccacugccagcccagcgcuppaccugcuccaggcuguagccgcag\n", + "ucucucucucucuuucpcggagucgcccaccacugccagcccagcgcuppaccugcuccaggcuguagccgcag\n", + "cguccgccgcagcgcccuucuacucauggacuuaaggcggcccuguugagagaaaucuggaggauagcguuacacuugguccgaugcaaguuuuuuguuccaa\n", + "ucccuccuggagacgcacgacucuguggccucaaagaccuaugagacaccaccccccagcccuggccuggacccuacauucagcaaccagccuguaccucccgaugcugugcgc\n", + "gacaagcaauaaacgcugagcgcccggcugcgcuggagccgcccggagcuapcuucccpcgcag\n", + "ggaaggaggacuucuggagucccuucucugacccugugapagagcagcgccagccaggagaaggcuccag\n", + "aaaguggcuucaggcaccaagguggugagcugugapccccgguaucugcgcggccuccccpcugugcpuupuacuuagaagcccggcauuac\n", + "gcgcgugcacaaaagagagcugapcpcgcugcggcacagcugguuugagcaacugaacuggaaacaag\n", + "gaccccaacgcagacacugaauggaaugacaucuuacgcaaaaapuaucuuaccccccaaggaaagucugaaagaauuggaagaggaggcagaagaggagcagcgcauccuccagcagucagugg\n", + "auuacuuuccuagacucuagucaugaacaggauguuggaagucagagguacagagaagcugccuuuuuaggccgcucacaugaaag\n", + "aaaaauuauagaggaucugcagacugagacgcauupacugaaauuaggcaauucagaguuucucaugcau\n", + "agucucacuguguugcccagauuggucuugaacuccuggccucaagugauccucuuuccuugcccucccaaagugcupauuacaggcuugagccaccacucccagccaacagaauucuuuucaaca\n", + "cuuucuupcucuaaggacccaggagucupugcacagccuccuucucucugagauucaagagucugaucagcagccucuuccuccuccaggacccagaagcccugagcuuaucccc\n", + "aaggacccaggagucupugcacagccuccuucucucugagauucaagagucugaucagcagccucuuccuccuccaggacccagaagcccugagcuuaucccc\n", + "caggagcaugacgapagagaggucaucgaggcupugagacaucugacuuaccgucaggagccacgucagugccucauaaaauccaaucuccauucag\n", + "cuacuugcaauaugugcucupcuggacgcgguggcucacgcuuguaaucccagcacuuupaggccaaggcaggcggaucacgag\n", + "guacagaauuucagagupauaucagaucuuuagugugaagauacaucuacauuaaaccaggaaucacuagaacugacauuuggacaagaaaauuuggaaaauuuuaaaacugugaagguugauc\n", + "cgcacacgcucacacgcucgcaagcgaacgcaggaaagucaggcuaaaagugucugcugcugcugccgccccccacuccgccuccpagag\n", + "gcgcacacgcucacacgcucgcaagcgaacgcaggaaagucaggcuaaaagugucugcugcugcugccgccccccacuccgccuccpagag\n", + "pcgcuguuuupaaauggcagaacucccucagaggcugaucuaapuucccggcagaapccaucuucagaggcucugguugcaugacuguuuggaguuugauggccugaag\n", + "cacacgcucgcaagcgaacgcaggaaagucaggcuaaaagugucugcugcugcugccgccccccacuccgccuccpagag\n", + "gcuuuacaggaggcauaguacuggaaaucugcuccugaugaggucucagaaagcuuccacucgugguggaaggcaaaggaggagcaggcacaucacaug\n", + "aaaggauaaauuaaagucgagauggaccugaggaagaccacaugapcugaupaagaggcauuugaag\n", + "auaucuggaauacaaaguuguugcugccagugauuugaggaauucuaauaagaggaacaacagcauug\n", + "cgaaguuucuupcuaugccaguuuuaaagupagagcugcugaagucaaaggagcaauugcugguccugagccugag\n", + "auaugcagagaaaauuauaguuagugaaacaacucupugcuguauuuuaccucuuguuauuuucuagccuguuggucucuuuucuuuuapaaa\n", + "caaaacgucauauuauuucacaaaaagcccagcgauuucaccugaagaagcuupaacuccugccaaaaauuguagcacuucucacauugcaaug\n", + "cccugcccuccccgagcucggucccggccacucccuccgcagcupcgucgccggccgcgcup\n", + "gcgagaaccgaaguuuggagguagacgagcaggcgagcgguuugcccpcgcagagcaugaaggccpcpcgcpagcggcgc\n", + "ccgccgccgccgccgccccuguugcgauggcgcagaaaccccguugacaaggcacugcuuuuucaugacg\n", + "gagucauagaggcupuggucuggcaaggacuugugcauuugagaacugacaggugcagcggagacuucuaagapaaaaccaag\n", + "aauuacacgcaguggaaaagcagcaccguggagcupugauuccugagcccaaccugugccucuggucuapcaugcapaaauugcaaccuccaauggaaagagaagcaagag\n", + "guuuuucucucugcuuucucaacagccagaucugccagugagccucaggcuuuaggaacugaagag\n", + "aagauauugaaauugcaaucaucuuguuuuupaauggagucauuccauauuggcucuugaguaugucugccaccacucugauucuagcuggaggcugccagaa\n", + "aauuacacgcaguggaaaagcagcaccguggagcupugauuccugagcccaaccugugccucuggucuapc\n", + "ggaugauacugugaaguguucaggaaugaagucucgugaugucugcuaccuaguuucaaauggcaggagagacagapaupaagcaaaagugaccauuguuaacucuaggugguug\n", + "agugucuuccucccucagcuugugcagcugcuuucaggauaaccucagacacagcuaucauuugcca\n", + "ggcgcguuccuuccucuuccucucuccucuccggccccgccuucccuucccuccgcccaccucccugaagcggagccgccgucgccaccagcgccguc\n", + "gguagcaagaaagcugcagaggaggcugccggcaguacaggaugcapagaacccaggccupuugaggccaggagacucaauuccagcuuuacugugugccuuuag\n", + "pacaacugupacauggcccagaugaucugauccuggcaguagugacuguupaccag\n", + "ucucuggauaugaggcaggapcuupacaacugupacauggcccagaugaucugauccuggcaguagugacuguupaccag\n", + "agaaaguccguuggaacuguccgcugcucucuggucucuggauaugaggcaggapcuupacaacugupacauggcccagaugaucugauccuggcaguagugacuguupaccag\n", + "ccauuacagcagcagaucaucagacuccaccaagagcuupagacagaagucucugupcugauguucauggaaaacuccggagucauauagaugcuuugapagcagaac\n", + "gcugcucucuggucucuggauaugaggcaggapcuupacaacugupacauggcccagaugaucugauccuggcaguagugacuguupaccag\n", + "guuccaguuacagccaucccuugucauaacuuuugaacuguauuuggaaaaauacuggccaggaaagaaaa\n", + "gcaccgcguagccagugaagguupagcaagcuuaugcpaaagapapacuccaggaaaagccguugagaggaccaucacaaccugagcagcacag\n", + "gccccgaggaggcccgcaccgcguagccagugaagguupagcaagcuuaugcpaaagapapacuccaggaaaagccguugagaggaccaucacaaccugagcagcacag\n", + "ccgccauuucguggacgccpugagugagagaguugguugguguupccggaggaaagcpaagacucaucggagcguguggauuugagccgccgcauuuuuuaacccuagaucucg\n", + "gagaguugguugguguupccggaggaaagcpaagacucaucggagcguguggauuugagccgccgcauuuuuuaacccuagaucucg\n", + "ucugccccaccccgucccguuccguuccgcugcccaguccugcugguacucacuagguaguagcggcaacggacgcc\n", + "ggcpagcgagcpcaapcpcgagcgagcaagcgagcgaggccggugcccucccpcggcgaccpccupuccacgccgapcaggacgaacuucaccag\n", + "uuggaaacccagcucacgaaccgcagccapaaacpaguuugcccaguuguccuugcggapugugcggaaacgcccgcgaupaacuuucugcagaucau\n", + "pagcgagcpcaapcpcgagcgagcaagcgagcgaggccggugcccucccpcggcgaccpccupuccacgccgapcaggacgaacuucaccag\n", + "guggagucucucuguguugcccaagcuggaguguagaggugcgcucucagcguacugcaacuuccgccugcupuuuaagcgauucuccugccucagccucccuaguagcupauuacag\n", + "gcuugagugcaguggcacaaucucggcucacugcaaccuccgccuccupuucaaguggucaucccgccucagccucccgaagugcupauuacag\n", + "cuugcgguaggaggaggaggagcacagguagugcuccgagccgaagcucauggugccpaucpccggacgugcggcuucaacgcgagcuacagaagaaaggagag\n", + "pcpapcgcgcguugaggcggcugcggcaguugcgcgcupauuguugcggugcgcuggagccg\n", + "auccccgaacaccuugcgguaggaggaggaggagcacagguagugcuccgagccgaagcucauggugccpaucpccggacgugcggcuucaacgcgagcuacagaagaaaggagag\n", + "agaupucuugcuacguucuccaggcuggucuuaaacuccupcucaagcgauccuccugucucaaccucccaaagugcupauuacag\n", + "auuaacucauuuaaucuggagaacacucuuaaaaaguagaaaauauuaccccagaaagugguggagcugguauacaaaaccgcguaggugcuuuguuaaggaaugaugcauuaguuucccgguaggag\n", + "aaaaagcuuguggugaappcaaaaaaaagaagcaaguucugaaguucacucuugauugcacccacccuguagaagauggaauc\n", + "ccgcuccagcggcccccagcccccuccccucgcguccccuguacgcacuucugcaugucgcggaagcagcggaugcacaacagcaacuucuugucgguggagaacaagag\n", + "ggcugcacuguucacagacuagcccapccgcagucaggaccagcccagcagcccagccacagaggagccagcgaaccucucccggcgccugugcupcuuucuguuccagcgucaagg\n", + "ccagcagcccagccacagaggagccagcgaaccucucccggcgccugugcupcuuucuguuccagcgucaagg\n", + "acuagcccapccgcagucaggaccagcccagcagcccagccacagaggagccagcgaaccucucccggcgccugugcupcuuucuguuccagcgucaagg\n", + "cccuccccaaccuucccpcccccgaaggaucucggaggcgaaguugcuagaagauacguaagapccccaguggag\n", + "uuuucgacccugcggagcauccgcuuccgguucccagacugaauugucagugagcggagucugaggucgcuguggacugcccacug\n", + "gauugugaaaaaugagguccucuuucuagaguaccugacagguugcuuggcauccagaagauguuuagcuaa\n", + "auccgcuuccgguucccagacugaauugucagugagcggagucugaggucgcuguggacugcccacug\n", + "agapcgacaacgcagcgccacucuuacpaauucccuucaccucuuccuucaugauccuaucucagcaccgucucugcgapaaaaagaaggcucgcugaugaau\n", + "apaucccpagcuguccggccgccucggugcugaucccgccaccgcccacpccgcuagcagcgcagcpcacuaugagcpcgucuacggcggag\n", + "gagucccgccccgccapaucccpagcuguccggccgccucggugcugaucccgccaccgcccacpccgcuagcagcgcagcpcacu\n", + "gccgcacccggccggaggcggapcagagcgcgcgcccaguugcccpcaccaaaucggagcgcggcgugcpaggccccagagcaggacuggaa\n", + "auucauuugagupaaucucaaagcaguugaguaggcagaaaaaagaaccucuucauuaaggauuaaa\n", + "agacagcgcaagccccacgccacgcgucgcuggucccaggcagcgagucgcucgcgcgccccgccgcccgccuggcgacagcuccgccgcgcacgcac\n", + "gccccacgccacgcgucgcuggucccaggcagcgagucgcucgcgcgccccgccgcccgccuggcgacagcuccgccgcgcacgcac\n", + "ggcccgcucaccacgcaguaucuguggcaccgcuucagcgccgaccucggcuacaauggcacccgccaaappcugcagcaaccgcagcgcggaccccacc\n", + "ugaaacuuagugccucagacaagcapcaagucugcuaaggaagcuguggccagaagcacagaucag\n", + "ugacuuuupagagcugaccuuuugugacuuuupagagcugccaaaagugaaacuuagugccucagacaagcapcaagucugcuaaggaagcuguggccagaagcacagaucag\n", + "cuuuugugacuuuupagagcugccaaaagugaaacuuagugccucagacaagcapcaagucugcuaaggaagcuguggccagaagcacagaucag\n", + "aaucaugugapccaaccpaagguggagcagaugagcacacacaggagccgucuccucaccgccgccccucucagc\n", + "gccugcgcagugcgacaaaucuggcgcuguccccuucagcaccacgcggaguccgcgccgccccuccccgcg\n", + "pauaccugguccuccccccpaagucuccucucaugcccagagaaucgcuagagccaaaupaauucuucuauggcuccuuggacccccccagcucag\n", + "aaacpagccgcgcugccuucacagcucagcupcccagccucuccucugucucuccucggucucagcucupcgagcagcg\n", + "gccugucugaagagcaugcagcccccuuacuccccgccuggccucgccaucccugcccccccagccugacccccggccccagc\n", + "cccuuccuuacuuccgguucucuauggugcgcpcaagcuuugcuccgccuccggcaguggcuuacucccggugccagguucuuggagcugugag\n", + "guguucagcauuauuuaagaucaccuaugcaucaucugaagccacagucccaggucaucuucaucaccuuccccaguggaaugccuccuguguuaaagcccacaacaaccccugug\n", + "ggugcgcpcaagcuuugcuccgccuccggcaguggcuuacucccggugccagguucuuggagcugugag\n", + "acuuccgguucucuauggugcgcpcaagcuuugcuccgccuccggcaguggcuuacucccggugccagguucuuggagcugugag\n", + "agcpuuccgguugucuggagcccagcggcpugugagaguccguaaggagcagcuuccaggauccugagauccggagcagccpucggagcgg\n", + "ugucuggagcccagcggcpugugagaguccguaaggagcagcuuccaggauccugagauccggagcagccpucggagcgg\n", + "auuauggcaucgucaaagcauuguggugucuuuuuuacugcugcuugcugugcuuauagcuacguauuauguugaaggagugcaucaacag\n", + "uaugugcaacguauagagaaacaguuucuuuuguaugccuacuggauaggcuuaggaauuuugucuucuguupcuuggaacapcugcacaccuuucugcuuuaucug\n", + "gagcpuuccgguugucuggagcccagcggcpugugagaguccguaaggagcagcuuccaggauccugagauccggagcagccpucggagcgg\n", + "gugagcpuuccgguugucuggagcccagcggcpugugagaguccguaaggagcagcuuccaggauccugagauccggagcagccpucggagcgg\n", + "puuccgguugucuggagcccagcggcpugugagaguccguaaggagcagcuuccaggauccugagauccggagcagccpucggagcgg\n", + "cpacuuagucuccucccupuuuggacacuggcauccugcuuuaugugugacaccacugcaccccucugagccucgguuuccccaucuguaaaauagaagcgaucuacccucacag\n", + "aacgccugccuccucucgagcguccucagcgcagccgccgcccgcggagccagcacgaacgagcccagcaccggccgg\n", + "gucaacgccugccuccucucgagcguccucagcgcagccgccgcccgcggagccagcacgaacgagcccagcaccggccgg\n", + "gaaaagaagaauuucuagacucuucaucaagaucuucauuuauacagcuguuaaauccaaggcuacuuuggugaaagc\n", + "gaaagccauuuaagaaguuccuggaauaauauuagucagaguaauauaggaucugcaggaagugucucaagauaguug\n", + "gaaaagaagaauuucuagacucuucaucaagaucuucauuuauacagcuguuaaauccaaggcuacuuuggugaaagcaugaauaaaaauacaucuacuguaguaucacccagucuacuugaaaa\n", + "ucuucccucuccagacagguggagagcpugapucucgcucggcuuucccccugcaccuuucccacccucccgcccgucccupuccuccgucaccgcggcc\n", + "caaaauupaagcgguucucgaaacauacugucaaggcguaguugcagugaguugugaagaaauguugaucccagagaaaaguuugcauuuugcccaccucaaagauauuuugauu\n", + "uuuggucgcccaacucacauugaagccuaagacccagcugauuucucuucauuucugcaaaguuacuguacc\n", + "gcguucguccpacccgccucaagccucgcagccuuucacccaguuuccucccgauucuugcupacaacaaaauupaagcgguucucgaaacauacugucaaggcguaguugca\n", + "ucgcccaacucacauugaagccuaagacccagcugauuucucuucauuucugcaaaguuacuguacc\n", + "aauucaggcccuugucccaaguaggaggacauuccccaagcaggcpuaaagucuccuccuggucaagugcuaacg\n", + "auaaagccaccaauccuuccaaccgccaggaggacupaauacauaauuggcuucugugaucagaucaacaaggagcuggaagg\n", + "gccacagaucgccguccgacugcuggcccacaagauccaguccccacaggaaupaggcgcuccaggcccugacg\n", + "aacaauucaggcccuugucccaaguaggaggacauuccccaagcaggcpuaaagucuccuccuggucaagugcuaacg\n", + "uaccupacapugucugagaaagugaagaccaagguuauugagcugcuguacagcuggacc\n", + "acaacaauucaggcccuugucccaaguaggaggacauuccccaagcaggcpuaaagucuccuccuggucaagugcuaacg\n", + "gccuccccucgcgccpaggagcuggcggcgagcgccgagccpcgcgcagcgacggagcupccggccupaccaupcg\n", + "caguugcuuauagucuaggaapaucacuuguguaacaupagcaaaugcugccuagcggaauauucgugacuugg\n", + "ugagugcaaucuacggaucagucucugauggupucguuaaccucagupacuccaagauuuccaugaagaaaaucaguugucuucauucaagaauup\n", + "aauuggaaaagaggucaaaagaaggupcaucagaaguuuaaaaauauuccagauggcaaaugaauuguaaaaucugaauccuuuccaaaaagugug\n", + "aaaauuuugcapuaaauuagccugucupucugagcucuuuauucuuggauacguuggagaucggaaagauauuaagau\n", + "paggagcuggcggcgagcgccgagccpcgcgcagcgacggagcupccggccupaccaupcg\n", + "cccucucccgcacggcccccgcacucccgccgcuggauuccagccgagauucaagcucccpaucccccuucccpcgguccugagccggcuagucuccag\n", + "gucuggcucagaauuccugcagcuggugaaaaucuguuuucuagaagagguuuaauuaaugccugcagucu\n", + "ccccucgcgccpaggagcuggcggcgagcgccgagccpcgcgcagcgacggagcupccggccupaccaupcg\n", + "pccccgcgagcuccccgguggcpugcgcgccgcccucgccuccccucgcgccpaggagcuggcggcgagcgccgagccpcgcgcagcgacggagcupccggccupaccaupcg\n", + "cccuggupagcuccggccuccggucaaggccuggccpagcgccacgaauucucgcgucgucucgcgagaguccaaguuaaagaac\n", + "aguggcugccggaccgaccggaccgcgaggccgcupcggcggucggcuccugcugccccugugccgagaccccgcgcaccuggccag\n", + "aauugugaccuggaucagcagagcauuguucacauugugcagagaccguggagaaaaggucaagaa\n", + "aggauuuaacccaggagagccgcuggupaggcgcggcuggcgccgcugcgcgcaupccuguuccuggcccgcagccgccaccuacccagugacc\n", + "ccuggaggauuuaacccaggagagccgcuggupaggcgcggcuggcgccgcugcgcgcaupccuguuccuggcccgcagccgccaccuacccagugacc\n", + "gauuuaacccaggagagccgcuggupaggcgcggcuggcgccgcugcgcgcaupccuguuccuggcccgcagccgccaccuacccagugacc\n", + "aguggcuacacacuuauaaggaaagauagugaggaagaaguuucauugcupaagccaagauauagaagapaaaucaccagguggaagauggauguagagaa\n", + "gccgcggccaggccacaggaagagcucgaggcccpccgcaccggcugagugugcpcccgcgcggcucggagccgccgccgcccaucgagccccuccpcgcpucggcccgcc\n", + "augauupcucagguuccagccggagcgguaacupcgcaggucccagccgccgcacuaaacccggcccgugcggugauuggacgcaggccccpccgcggcggaggcpcgauccgaaagag\n", + "accuccgcgcucuggcagcuccucuuccgugugcucucgccacucccugcpcaacgccuuggcaucgcucgcccugg\n", + "acggapcgugcpapagaggapcuugcupppccccgaggcpccpapccgccuggaagaggaggucpcgaaggaggccgagaagaaag\n", + "cccugccaggagcccggaagupuccgcacgagacagaauagacuacacucaaacuccapaaccguucauupcuuggacacgaaggcpacccugccgacgcagugauuggaugc\n", + "upcgcaggucccagccgccgcacuaaacccggcccgugcggugauuggacgcaggccccpccgcggcggaggcpcgauccgaaagaggcuggugcuggcugc\n", + "ggcuacccgaggcuggcacuggcacaacuaccugaggauggcucgcapcagucpagcugcugcuggcucuguccuggcucuuggcccgaggaccugugcccgagcag\n", + "cacgaaggcpacccugccgacgcagugauuggaugcauguccggccagcgcggugauupuacaggucucpagcgcggugauugg\n", + "uuccagccggagcgguaacupcgcaggucccagccgccgcacuaaacccggcccgugcggugauuggacgcaggccccpccgcggcggaggcpcgauccgaaagaggcuggugcuggcugc\n", + "gcagagcugcuccgccaucucccccacgccuccugccaaguucuguggcgccgcgguuccccaccuccugcucccaucccccuggcucccgccgcccuguagcucggcag\n", + "gugcauugcccauccuucagagagcucugugugaauccauaaaaggugcuuaaagcuuuucacuccaugaagccucaucugucucaugaaagcaauaaau\n", + "gcaguagcagaaucccaugguagccaggupugaapagcgaggacguucuaccugccuugaagaagacaccugaccugcggagugagugaccag\n", + "auuaacuggcauucuuuaaaaaggcaucaguuuucuuuugcacagguguuuggagagcccggacuggaugcccacuagaauccugugcug\n", + "gacaggupaguuaaccaagaaapagaaaaugaagaaccuucaggaaggaauucaugugccagaugupcugagapcacccagcugcucaggaap\n", + "gcaaccugucuggacugagcauuucucugacuugacauaacuucccauccagccaggagucugcacucuucagucuuugcag\n", + "aaaauauucuagacucuucccuuccagcgcucacuguuuacuuccucugcacuuccccuuccugccuccccgugugccg\n", + "gupaguuaaccaagaaapagaaaaugaagaaccuucaggaaggaauucaugugccagaugupcugagapcacccagcugcucaggaap\n", + "gcaguagcagaaucccaugguagccaggupugaapagcgaggacguucuaccugccuugaagaagacaccugaccugcgga\n", + "guggauccccupagaggacacgucccuagucccauuucacagaugaggaaguuguggcucagaaaapcg\n", + "caagucucucuucggugccaccggcpcgaggccggauuaaucaccgcugcuucggccgcccauguguccug\n", + "agucaacpaaugcgguaacuguugguaacagaacaacgagcugugcaccaagccaagucucucuucggugccaccggcpcgaggccggauuaaucaccgcugcuucggccgcccauguguccug\n", + "agucgguagcuggccguagaaggaggaggagcuccgacuacauucuguccuugugccucuuggacuuuuuuguguguuuaggugccca\n", + "agagcgcagagccggacagagcagaagaacccucuuggacuggacgauuupaauucaaaacuupacaaacugucagccuug\n", + "aacaaaagugcugcagccgcuugcuccggccggcacccuaggccggcccgccgccagcugucgccgac\n", + "ccgcuugcuccggccggcacccuaggccggcccgccgccagcugucgccgacauggaacccuuggccagcaacauccagguccugcugcaggcggccgaguuccuggagcgccgugagagag\n", + "aaaagugcugcagccgcuugcuccggccggcacccuaggccggcccgccgccagcugucgccgac\n", + "caaaagugcugcagccgcuugcuccggccggcacccuaggccggcccgccgccagcugucgccgac\n", + "ggauagaapacaaggaggcacacccaggccggcaaagagcagguaucagcacugcaagcaccaagugugucuugag\n", + "aagugugaguaaacaggagcugagupcaapcuuuggaaggacaagcaggaccagcagaacauuccagauugg\n", + "agaaaugccuggaacuugcccucacugagccuaagcucggaggccccugcccugcugcccuccccagcupcggcccgaggccggacauaguagccaugguagagu\n", + "gaaacaagaccaugacaagucacuggccggcucagacguguuugugucucucuuuucuuagcucagugaguacugg\n", + "aagcuucacaagacugcauauauaapcuggcuguagcugcagcugaaggagcugaccagccagcugaccccucacacucaccuagccacc\n", + "aaacggccupuggauagaapacaaggaggcacacccaggccggcaaagagcagguaucagcacugcaagcaccaagugugucuugag\n", + "pupucuuucugcccagaugupauccucuccuaaacccaggucaacccapcacgaggcagauggcug\n", + "gccauupuguggacagaaagcuagugaaacaagaccaugacaagucacuggccggcucagacguguuugugucucucuuuucuuagcuca\n", + "gaagaggccuuugucucacagacaaaccacaaagccaggcauuggagucagagaggcagcagaugccaggcuugcacccauccuugcgacugguccccupugaucugucuucuucucugucccu\n", + "puggauagaapacaaggaggcacacccaggccggcaaagagcagguaucagcacugcaagcaccaagugugucuugag\n", + "aggaggaggaggcaccaaacggccupuggauagaapacaaggaggcacacccaggccggcaaagagcag\n", + "ccggcaacupcuggaccgaaaccggcgcggagcaacugaggcccgagccuucucpacccpacgccuaaccccgcgag\n", + "cgaaaccggcgcggagcaacugaggcccgagccuucucpacccpacgccuaaccccgcgag\n", + "uuacuugcuggacagaagaaaagcucccccuucuggacauuugaauacuaccaaacauucuuugauguggacaccuaccag\n", + "gucuuugacagaauuaaaggaucucuuuugccaauacccpaaaaacuuugugagguuauauauccgcagcaauccagaucucuaug\n", + "gccccuuuuggauaugugccacguuggucuuugccauagcaauuagupaaucuuuccaacuucuugauccaucupagagaagacguaccauuaugugcccgaauuccgaaaag\n", + "uguccauagcagcuaccaucaucuaugccuaugccuggcugguuccucuugcacucupuuuccuc\n", + "auuucuucuugaauggcaaccuaaaugccaguccaaagaggcccccaauagacuuguucacccuucauguccucaacucupaaguuaag\n", + "uaaucaaguugaagaaacacuuccacuacuuaaaaagguaccugcaaauuacuuucacauuuguucagcuauccua\n", + "ugccaccugugauauaugugaaguuccugaaauaccuaaguccaaguuacagcucugucauauucuacugauuauuuguuccuguaccuguacaag\n", + "acagcauccuggcuguggcgcgugcugacugagcuagucuupuccuggagaapcuggaggcaugcccacagccuccccccc\n", + "caggauccagcaccacgcggcgucuacgucugcucuggcccaagcagcacccccaauccgugcgugcaccccacgaauugacucccuauccacccaggaccagg\n", + "ugaagaaaauauuuggaagcucugugaauacaucaaaaaccaugaccaguauccuuuagaagaauguuaugcugucuucauaucuaaugagaggaag\n", + "ccuacgucugguccagucggucuuccuccggcccpcccuggcccagcuagccggccauggaag\n", + "acuacaagcccgcccuuuccuacgucugguccagucggucuuccuccggcccpcccuggcccagcuagccggccauggaag\n", + "acuacaagcccgcccuuuccuacgucugguccagucggucuuccuccggcccpcccuggcccagcuagccggcc\n", + "ccpaacccacgcpccacuacaagcccgcccuuuccuacgucugguccagucggucuuccuccggcccpcccuggcccagcuagccggccauggaag\n", + "gcauuuuuuacugucuacagaaacuuauuguaauucauuuuuccucacuccaguaguaagaauuauaccaa\n", + "caacgaguuguagccgcggagagcaggcgucgaugcuggcgcccaaagccuccagccugagagucgccucacucgugugacg\n", + "gagaggagcagaggucuguagagguagagacguaggcuucggaucuuuuagaauucugcuggaagucuccaagucaag\n", + "acacccagcugccugagacccuccuucaaccucccuagaggacagccccacucugccuccugcucccccapcagcacc\n", + "cuggcucggagcagcagccucugaggugapcgapcgcpccggugupccgcagagacguuggagccggcpcupacuggccucpcgacuugag\n", + "gcaguagcugcccgugucggcagcugcagcpucgcacggcuccggcccaucucppcpcpaggcgaggugcgcgagccgaguccpcacg\n", + "caugcgccpucguacacggcggccgcgcgcacgcupcguggcugcgcgauguaaucggucucuggacgcugcgcggcgcuccuaggagcaggcguucccgacuccggcaagagg\n", + "guggcgccuggacucucgcccucagapaggcccgucccacggucuguggcuacggaucccaggacccucuucgcpcgauucgcguagccucag\n", + "aggagcccaucuggugagcugagaguuagugapcccaagagaaupcuugcucugcccugugcuuuagauggacc\n", + "agcccapagccgccgccgcagccgccgccgccgcggugaguuuuccagccuggagaggccgaaccagcgcpucgag\n", + "uccccgcccccggccccgcccagcccapagccgccgccgcagccgccgccgccgcggugaguuuuccagccuggagaggccgaaccagcgcpucgag\n", + "augcagcccaaguggcpaggaguuccuucapaaacuaugcucagcccuguucagagaauccugugcacapcuccacugcaguuaggagccggugaguccpugg\n", + "agauagaucuuacaggucccagccuguagacaucuuuuacuccaauuuccugaauagauagcuuuauuccuucaagguaauauagugcgguggcuucuggcugag\n", + "uccpcaggcugccuccguuapccgccccugcucuccggacgcgacuuuucauuggucucagaauuucuuggcuccucuuggccucugcagccuugcuggaggcugcccugcggaaucuga\n", + "pcaguggacpcagcuuggcugugcuguugagccugapcugagaggacaccccpcaguguaaaggagacuggacuuagcaauug\n", + "ugcapuccuuuuuggaagcucuugccgucaucgcugacuupcaaupccggupuuupcggaagagacccucpuugagaa\n", + "auaccuguggapcggagcuguagcccucuuuauuaccaguaucggaguauauacuacuaccugucugaccucag\n", + "uuagaaggaggcucaagauguauauauguguuuuucuguuaguguuugagaauaguuucagauagccacaauggauauucauuuggcgu\n", + "uauauuuaccaggauuacuaugcugaagguauucuucaagaguuuguuuuuuuucuacugguugaucucuacuuuuagaag\n", + "guguuuguuauugugaaucccuaapugacuguuuuuucagcapcgaguuaggacggcacaaacugagaguuucuguucug\n", + "aguggaaggcggupaaggagguguagcgugagacuggacugcccgcauupuacaugcgcagugccgcucgcgcpccgcgccaauccugcagcgccuucaacag\n", + "agcccagugaccugccacagcccpcaccagauuucugccuuaauuguucuuccauugucuuucuccu\n", + "aggcgucppaaucucgcgapuuggaguuuuggcgagaguuuguggaagauggcgccuguugugacagg\n", + "uacagauacacuggcugagguguuuugaggugcaucgaaguguuccaagcugugacuuaccuuaacauguucuugaaguaccauggcguggauuaaaag\n", + "ggucuugcucugucauccaggcuagaguggacuggugcgaucucagcucacugcagccucgacuuccuggacucaa\n", + "ucuugcuucaaggucuuuuucaagugcugugucuucacugucucagaaguuuacacuuccuauuucagaggaaauaacag\n", + "gcuggaaugcaacggcccgaucucugcucacugcaaccuccacuucccggauuagagcaauucuccugccucagccuccugaguaccupacuacag\n", + "gccguggcucaggcuccagcgcgugapcpcggcggcggcggcggcgaggccggcpugcpc\n", + "gagcpccpcpcguggcgupugugccaggagcuccgcgguugccgcgaagcgagcuggagcugacccucggcguccc\n", + "ggagaaugauacagauacacuggcugagguguuuugaggugcaucgaaguguuccaagcugugacuuaccuuaacauguucuugaaguaccauggcguggauuaaaag\n", + "uagagacpuuucaccguguuagccaggauggccucaaucuccugaaaucgugaucugccugccucggcuucccaaagugcupauuacaggcaugagccaccgcccccagucugucuug\n", + "agapaccapaaggcgucppaaucucgcgapuuggaguuuuggcgagaguuuguggaagauggcgccuguugugacagg\n", + "aguugauugcagguccuccupccagaapugccupaggccagguucupauccccuccauccagaagaaccaccugcucacucugucccuucgccugcugcupacc\n", + "gaaucgguuguggcggccgccggcgaggaauggcgguauuugugagaggagucggcguuugaagagguggaacuccuapcuuuuuugagagug\n", + "acggagucuaccucuuguuaccuagacuggagugcaguggcacgaucucggcucacugcaaccucugccucccpuucaagcgauucuccugccucagccuccugaguagcupauuacag\n", + "uuuugcccaaugaccauguuuauguauuuuuauucaaauuuuauuuuuucagcugauuuagaagaauacaaauc\n", + "uuuuugaaucgguuguggcggccgccggcgaggaauggcgguauuugugagaggagucggcguuugaagagguggaacuccuapcuuuuuugagagug\n", + "acccccagcagccpcccugacgcggagupagaccgaagcccccaguauugcupcaucuucgcccucaccuguuggcucuuuuggacagaagagu\n", + "ugguupucagugccgcgcgccgaucggucguuaccgcgaggcgcugguggccuucaggcuggacggcgcpucagcccugguucgccggcuucupucuuugaacagccgcg\n", + "pcguggaaagauggcguaaaaagccacaauacgcaggcgucaucgcucacuuuuccccucccggcuucugcuccaccugacgccugcgca\n", + "auuagagagguaagccuuuggauuacagcucugauguuucugguagccaucuuuuucuaauaucucugugaaggucaaccccugacuccuaag\n", + "gagcguucacauccuguuuggaaacaaagucugcaaauuguuuaauaggccgagccuugauauccgcaucccucucagcucuaucacag\n", + "aagaguguucccugguuucuugapugucaauucapuugcuucccguuuuauccuauaaauacuucuggcugcaaagagccuacaagcagucuguuuccuguugcagugugguaag\n", + "acucuucagccugaugucaaaagcaaaaguucagaaguuccucaucaauaaggaguccuugugagcaggugaagcucaucuaacuag\n", + "uccugcacacacccagacagcuggcgcucacacauucaccguuggccugccucuguucacccucc\n", + "ggaugcaccuacgccugcgcccugaggucpcgcucgcpccaggagcpagccggcpcagcgccgcggcucgugaggug\n", + "cuggagaaucccggacagcccugcucccugcagccagguguaguuucpagccacupccaaagugagaguccagcggucuuccagcgcuupccacggcggcggcccupagcagag\n", + "gucuucccggcgcccaggcuupcucauapagaaaggaagcugcgcugcauucugcpacgaacccugcuccgcgcgag\n", + "agcugauuauauugugaaaaucuuugaucgccauggucaaaaaagaagugaaauuaacuuaccugg\n", + "uaacuguguugccauggauupauaaagauggagauguccuagcagugauugcugagaaaucuagcugcauuuaucuuupaugccaacacaaauaagaccagccaguuagacaauggcaugag\n", + "gaaaacauacuaagagaaucacuuguggauguuggaaugcagaaaaucugcuugcuuuagguggugaagauaaa\n", + "aaccuguaggcagcgcuugapuagcpauagcagcugcaagcgcgcgupaggcpcucupcggaacaaaaaucacaggaugucagaggauguuucccpaagaacupauaaagg\n", + "aapucccagcaccauggaggacccgaacccugaagagaacaugaagcagcaggauucacccaaggagagaaguccccagagcccaggaggcaacaucu\n", + "uuggccugugacaggcaaucaggucaucguccacggcuaccagguguuucaugucuacugugacuuccaggaccacaagcccuuuugcgcccacc\n", + "agagacacugcgagcggcgagcgcggupccgcaucugcaucagccgccgcagccgcugcpccgcgaacaaagaggaggagccgaggcgcgag\n", + "agcaaagucugaaauggauguuacaugagucauuuuaapaugcacacaacuaugaacauuucugaagauuuuuucucaguaaaguagauaaag\n", + "gcggccggcgcpucgacpacccagcgucggcggaccccuagccgcggagaaggcgguggucucgacauucccccauccccgcccugg\n", + "cuuucuggccggaugugugcugagacccagagucacccapucuccgucacgugccaggaguaggcagaagupcugugacag\n", + "aucaggaaacagagcucagugcagcccacuaaauugcucapcccuacagcuaacaagcggcagaggcaggaucugcacucag\n", + "cugagacccagagucacccapucuccgucacgugccaggaguaggcagaagupcugugacag\n", + "agccuuuuaaagccaucgcuccuucuuucuggccggaugugugcugagacccagagucacccapucuccgucacgugccaggaguaggcagaagupcugugacag\n", + "aaagccaucgcuccuucuuucuggccggaugugugcugagacccagagucacccapucuccgucacgugccaggaguaggcagaagupcugugacag\n", + "ucgcuccuucuuucuggccggaugugugcugagacccagagucacccapucuccgucacgugccagga\n", + "cuaguccuuauucucgagaaaagcaaaaaugccuuggcauucaaacauucccuaggccuguggagaauuagagcuagcagaa\n", + "accacagaugacauccuuguggccucagcagagugucccagcgaugaugaggacauugaccccugugagccgagcucag\n", + "ccaacccaacccgagcaggcggcagagagccguauccaggcucagcagaagugauccpaguccagcagcaccacpu\n", + "gagucapagcucuccugucaccaguauugauuucagaggauggacuaaauuuccuaggauuuccauuaagaauuaagaaaaaagcucuaagcacgcapuagccagacagac\n", + "gcucaagccugacgccucugaaaaggcagcagcagucgccuuauccauagaccucaggaaauucgcuuugaccgaugcaugcuucaggcucuggcucgagcugapaauaaccpcag\n", + "auuccacaucaggagcguuuuuggagaaagcugcacucuguugagcuccapcgcaguggapapagugaaggagcucucuguacccaaggaaagugcagcugagacucagacaag\n", + "ugaguuuuguuuuccacaggagccgcccaggaggcuccucaggccgaccccagacccuggcuggccagg\n", + "aaacucuuucuucggcucgcgagcugagaggagcagguagapcagaggcpacugucgucup\n", + "agguuagacuuguuucuuauaugugaugccauuccagcacuggacucauggaggcugagcauuuauucag\n", + "ggccgucpccgagccgcagccgagcggccgupcccpcggcpcggagacgupcgcccuccccgccaaggcccgugcgag\n", + "ucuaauuccaagcuaaaguuggugcguagccuggcagugugugaggaguccuccaccccauuugcugaupccauuagaaacccag\n", + "gauauaauucaauugcacaucaguugcccuucugacaaggaggaagaaaaguccacaaaagaugucucugaaaaggaagacaaggacaaaaacaaagaaaagaucccaaggaagaugcuguccagag\n", + "acuccagccaggaauauacggacuccacuggaauagaccuacaugaauuucuuguaaauacacugaaaaagaacccaag\n", + "cccugaacagagguucucagaacauauaaaggaugagaagaauacagaauuucaacagagguucauucucaagagagaugaugccaguauggaccgagaugauaaccag\n", + "paaccgugaaggacugagccgcaccucaagcagccgccagagcagcacagacagcgaacucaaaucccuggagccacgcccuuggagcagcacagacucugauggcucuguccggagc\n", + "gcagccgagcggccgupcccpcggcpcggagacgupcgcccuccccgccaaggcccgugcgag\n", + "augucagaaacauccgaggacuacagagaccuuggugauaagugugucuuucuuucucuccucuucuuccucuccugcauggccucccucucugccagcacuggaaaguccuguuugaucag\n", + "acggcpucgccagcgccgcaguagcucgcgcggugccugucgguagucgcgugcpcggcpcggcpcggccggcggcggcc\n", + "gucacaaggcacuuccagccagucgcaacggcpucgccagcgccgcaguagcucgcgcggugccugucgguagucgcgugcpcggcpcggcpcggccggcggcggcc\n", + "augcuuccagccauugucggagugucagccgucacaaggcacuuccagccagucgcaacggcpucgccagcgccgcaguagcucgcgcggugccugucg\n", + "cuguggugcaccugccauaagaaguccuugguggaaacagcaugcagaaagagucucaaggccuugaagcugaacuauuuggaccucuaccucauacacuggccc\n", + "aucaaagcagcggccggcuguupuccaccacgccuuccaccugccccacugcuucuucgcuucucucuuggaaaguccagucucuccucggcuugca\n", + "uucuagacuugucggcgcucgauugaggagcguggcuacguugcuuccggugccuggcuccguuuccugcuuuugguucuuacaguagucggcguaggccuuag\n", + "aaaagagagacagaaauuguaapagaggcuuugagauaaaaccccaggaagaacuucccgagucugugc\n", + "ccugcagagaggaggaaagccugccucggaacagcccuggacaaapcucagaugccccaucauacugcaggcuccaag\n", + "cuccacagcaccuguugccuucauuagcagcuuuuccuccucuucccugcacuucccagaaccaaagaaugugaapucc\n", + "gucuuccagaacuuucaaaaucaaaaucpuugcguuaggacaugccucupauaagauuccccauggupauggcagcag\n", + "cuccacagcaccuguugccuucauuagcagcuuuuccuccucuucccugcacuucccagaaccaaagaaugugaapuccauggag\n", + "ggcucacguccccgcgccccgagcggccacuuagcgccgucgccgccggcuuucgacggcgagcuggaucugcagcgauacuccaacpccagccgugagcgcapucgcucp\n", + "agcgcgcpagcgcacggcpcgcggccgacgcupacgcggcgcacggapacgcggccggcgccc\n", + "agcggcggcuccugcagcgguggucggcuguupuguggaguuucccagcgccccucpuccgacccuuugagcguucugcuccggcgccagccuaccucgcuccucggcgcc\n", + "aguuuugcggccuccaggugguggauccaauuuuucauuagguuuugaugaaccaacagaacaaccugugaggaagaacaaa\n", + "aggacuccagaacuguacggaugagaaaaggaugcaggaaauucuguuguuuacacauguggcugcaacugagacacuggagcagcccagcaagcccagagg\n", + "aapcuuuacuapaaaacggugcugguucacupcgcguuuccpaaggugaauaccggugaaaguuaugcugapugag\n", + "uaaacucaaaaacugacacucgauucagcuauuggaaaguuuuuuuaaugugguuggaacaacugag\n", + "ggugccccccuccacgcccaggagcgupaacccugcuuaapcuuuacuapaaaacggugcugguucacupcgcguuuccpaaggugaauaccggugaaaguuaugcugapugag\n", + "agaacccaaggaagccuuaggcucaggucucugccugaagguaggcupaggcggagapacagapaagaauccccuggacaccgcgccucapaggcccapuaag\n", + "cuuucuuaaccaagguuaccagcagccacacacauaggucupcucugaagaggaccggauacauaaggcagaacccaaggaagccuuaggcucag\n", + "cuucuuucuuaaccaagguuaccagcagccacacacauaggucupcucugaagaggaccggauacauaaggcagaacccaaggaagccuuaggcucaggucucugccugaag\n", + "aggaaaugcupaggupcagaucacaucaacauccuggcauupcupucggcguggagccccagaaauguucccaagcccauucuuaccaagaacca\n", + "aaugcupaggupcagaucacaucaacauccuggcauupcupucggcguggagccccagaaauguucccaagcccauucuuaccaagaacca\n", + "gucacuaagcccpaacuggagagaugucugugaapucugccaccgugauccucpucaccuccucggugcccucccugccacuccccaauguccuccug\n", + "ggaaaugcupaggupcagaucacaucaacauccuggcauupcupucggcguggagccccagaaauguucccaagcccauucuuaccaagaacca\n", + "gcupaggupcagaucacaucaacauccuggcauupcupucggcguggagccccagaaauguucccaagcccauucuuaccaagaacca\n", + "uaaaupaggaaaugcupaggupcagaucacaucaacauccuggcauupcupucggcguggagccccagaaauguucccaagcccauucuuaccaagaacca\n", + "aguaaaupaggaaaugcupaggupcagaucacaucaacauccuggcauupcupucggcguggagccccagaaauguucccaagcccauucuuaccaagaacca\n", + "gccguggagaccgaggcgauggcaaccaggagaagccaaacuuggucccccggcucgcggagugccugcgagcggugcuc\n", + "gaggcgauggcaaccaggagaagccaaacuuggucccccggcucgcggagugccugcgagcggugcuc\n", + "augcacaaggcuuucagguccucacacgaaugaugagauaagauccaacaucaagaaucugaagcaaagacacucgugguuucagaaucuauaaacagaguuug\n", + "guaugcgagcaaacaagguaggaacuggagugcaugagcgcuggagucagcuggccacuupcacuggcaggaucaaacuccacucagacccacugccuuccaccccuugupapagcacccag\n", + "gucacauggcaggaggcuuccccagaacgguucgucaguccapagccguuucauuuucuggcugauagaguuguacuuggaaaauacucaguuuccugcuuacugcuucauu\n", + "cguuucauuuucuggcugauagaguuguacuuggaaaauacucaguuuccugcuuacugcuucauuauggauuauacag\n", + "gagcugcgccuccpccggugaaucaucccggcagacaccaagagccgcggcagcagagaggagcgcugaaac\n", + "gguggagaucuucauuaucaaguuuccuguaacuaaaapaacagaucgucugagaucuugcuccacuuguccuugapuuauuaag\n", + "aacucuacucagcucaaaauacagaacauuuccauuuccccuggaaguucucuuguggccuuucccagucaauauuauuuccccucuucaugaaaag\n", + "aguguuccpagcupuuauaaaaugccpuuaagcggcaacucagacucaggaucccgcucacgac\n", + "agucagagcagcggagcugccccgaacaaagauggcgcpaagcgucugugapcagacugauccgagcacccaaacccucggcggacagcggagccagugguagccgcacggcccuaaaacc\n", + "agaacuuagucugcgcggcggcauugacacuagcupcuccucpcgcgccccaggugguccgaagcccgguccgcccuccacgcaggugccccgcgcuccccgcucagcc\n", + "gcaggcugcgcggcuguccpcgcucgccgagccpccgcggcgccgagucgaacpagccgagcuggagcugccgcggcgcagccag\n", + "aaaaggcgcgcaggcugcgcggcuguccpcgcucgccgagccpccgcggcgccgagucgaacpagccgagcuggagcugccgcggcgcagccag\n", + "aaaggcgcgcaggcugcgcggcuguccpcgcucgccgagccpccgcggcgccgagucgaacpagccgagcuggagcugccgcggcgcagccag\n", + "auucccaccapcgaacccagcaccgccuguauaccagacucugugccaggcacugaacguaaauaaaag\n", + "ccuuaccacagcccucugcaggcaggccacagagccagugcaagacagagcagagcaggacugcaccccauacuuuguauccccag\n", + "pcgagcgaccccgagcccgugguugcccaggcgacuguuagguggcuuacgcggcccggaugcagcagaaacaccagcguugcugcgaccgcguuggcgauggcgcacgaaggcucg\n", + "cgagaagagaggaccgupcguucgcguggcucccagcccpaccccacccccgcuggacagupaaacugaggccugagcgg\n", + "ucgcgagaggcgcaaggcguggagucgacggcuggagagaagccpagcgagcccaggcggcag\n", + "auuaaauugcacuuugucucugcccagucuugauucccuuuuggccagcaguuuuuaggucugucaguacugcacugcaaga\n", + "ggagccuccuccucucgcgagaggcgcaaggcguggagucgacggcuggagagaagccpagcgagcccaggcggcag\n", + "guuuagucccaggaagcaccacucugcacagugcugagauuuuggcugaaaucgcccggauccuucggccugguggaugucuuuuucugaaggagccaguagagacagcuguag\n", + "auaacaauagcaaagugaagacagcaucuaagcuguguucagcccugacucuuucuggucuuguggaagugaaagag\n", + "gagccuccuccucucgcgagaggcgcaaggcguggagucgacggcuggagagaagccpagcgagcccaggcggcag\n", + "uuuuugcacuaacuucaggaaccagcucaugaucucaggauguauggaaaaauaaucuuuguauuacuauugucag\n", + "aggcuaaggucagacacugacacuugcaguugucuuugguaguuuuuuugcacuaacuucaggaaccagcucaugaucucagg\n", + "cacuauucucaugcugagaagauucaaaauaaupaaauugaaguccuaggaacaaguuuuauguuucagaagagcccauuugguauccacapcuaagaaaugugcacccuaaau\n", + "gcaggaaggupccuggaagauaacagcuagcaggcuaaggucagacacugacacuugcaguugucuuugguaguuuuuuugcacuaacuucaggaaccagcucaugaucucagg\n", + "gguucauccagugauucauuugcaagcaggcaupuaaggucuucagaguauguuucucagaggcccaugcagcuaagaaaaugugcaguguuggcacaaggucugucuauuccupuagccag\n", + "auucuaacugcaaccuuucgaagccuuugcucuggcacaacagguaguaggcgacacuguucguguugucaac\n", + "cauggauccuuuggauuuugauuccaguugaucccuggaguaagguccuaaccpucucccgaggucguuucgccguccaggauggagcag\n", + "gcpagcucgcaccgccgcgcccpccgcgagugaugauaaccuaagaggccggcgcpcpcgugagcggcggaggagccpcgcggcgacacgcggcc\n", + "auugcugucuugguaccugcacuccgcggaguccugaguucuuguccugccuccaagaagaacgagauuaugccgacaaccagagu\n", + "acaguguuauugcugucuugguaccugcacuccgcggaguccugaguucuuguccugccuccaagaagaacgagauuaugccgacaaccagagu\n", + "ggagaugcaguuaaagacuugaugcuucgcuuucupugaaaaagcugcagcaaagagacaaguccuaaaugccgacucaguggaacaaucuuuuguuggauugaaacagcuaauc\n", + "cguugacaaauggcaugccccuccgugccgucagcacacugacguugucaccauuacuaacggcuggcuggcgcugcuuccagcaag\n", + "agcugcagaaacuggapcagcaguggaccugugcggacgucuccucacagcccacggccapcuacggcaagagcpcugcucaccagccacacgacagauucacugcag\n", + "gacagcaagaggcccguagcgacccgcggugcuaaggaacacagugcuuucaaaagaauuggcguccgcuguucgccucuccucccpagucuucugccuacucccagaagaggapaagcacag\n", + "agugcuuucaaaagaauuggcguccgcuguucgccucuccucccpagucuucugccuacucccagaagaggapaagcacag\n", + "gugcuuucaaaagaauuggcguccgcuguucgccucuccucccpagucuucugccuacucccagaagaggapaagcacag\n", + "aaggaacacagugcuuucaaaagaauuggcguccgcuguucgccucuccucccpagucuucugccuacucccagaagaggapaagcacag\n", + "cuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "gauugcgacucucacacccugagcuccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "uugugacucccggccaggcacaguggcucacaccuguaaucccggcacuuupaggccugaggcpuggaucaugaggucaggagaucgagaccauccuggcuaac\n", + "acacccugagcuccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "gcgacucucacacccugagcuccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "gagcuccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "puuugagapcpauugcgacucucacacccugagcuccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "cugagcuccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "uccggugcuccuuuccuaacuccacuggcugcggcaucugupaaaaguguggcupucuucgaggagccgcacca\n", + "acaagugugaagccuggaagccggcpugccgcuguguaggaaagaagcuaaagcacuuccagagccuguccggagcucagagguucggaagacuuaucgacc\n", + "aaacaugcaguuaaauaucugaggauauucapacuuggauuugguggcaggagaucaacauaaaccaagacaaggaagaagucaaagaaaugaaucaaguagauucucupauauaag\n", + "aggcagccgaagaguucacaagugugaagccuggaagccggcpugccgcuguguaggaaagaagcuaaagcacuuccagagccuguccggagcucagagguucggaagacuuaucgacc\n", + "agguucacaaucucuuccacaaaacaugcaguuaaauaucugaggauauucapacuuggauuugguggcaggagaucaacauaaaccaagacaaggaagaagucaaagaaaugaaucaa\n", + "accugucuucuccacugccuguaccagcccaccucaggugccuucucgccggccuuccucacccacc\n", + "gcugaagugcaguggcaugaucucagaucacuacaaccuccaccucuupuuccaguaauucuccugccuggccuuccugaguaacupauu\n", + "auugguuggcugccgccugauggauagacgapaggaguguacucucuucaguguguucugacggagccgaaguacagaaaccauauuuacag\n", + "gaaaaaaugaggaaauaucaacagacugaaaauauguuuucagaggcauagaaucuucaggaaaauacuggaguuccugagaucucaag\n", + "gcgccgcgcucpaugucgugaagcupagcucgucgccgccgccggcggcuagcpcguccgcgcc\n", + "aaucguaaaapcpacgcgccgcgcucpaugucgugaagcupagcucgucgccgccgccggcggcuagcpcguccgcgcc\n", + "gauuccuuccucaaggcucagcaguggcugaaggaccuggaggaggagcugcacccaggagaaguccuggug\n", + "cggcgaguggcuccgucuccgcggacagagcgcgcgcccccuggcccggcccgcgapcucccggcgcgguccccgagcauuucccgccpuggagcpccgagcccggcagg\n", + "acuuagcggcgaguggcuccgucuccgcggacagagcgcgcgcccccuggcccggcccgcgapcucccggcgcgguccccgagcauuucccgccpuggagcpccgagcccggcagg\n", + "gagaagagaapacagcggcuuggagagacagaacggcaaaaccgcugcugcugcugcuucugcuucugcugcugcugcugcugcugcugcuuuugcagcugauugagacacu\n", + "agcugaagccauuuauugguaucuuggaugguuaacaucuaaaugcuuaauuccugaaaccacucaagagucauaggauuagaugauccaagucaccaagaaauuacugucucaagugauacg\n", + "cuucagcgccagucagcaaaguaaauaaauacugugcuucuuccaacuuucauuccacuupaaaaaaaaauaucauc\n", + "pcaccuugugcugugcaggugcagacgucuucucugaccucapagagucagaacaggaagcagccacugccggcgccugcuggucaccccacagugccggcggcugcagcccag\n", + "gucagcugagagcauccucacucggucaguuccucpcgaguuacpacgaccugcpagcacgcpcaguggccggacgcugaagcccaggagagcg\n", + "guggcugcgcgauguaaucggucucuggacgcugcgcggcgcuccuaggagcaggcguucccgacuccggcaagagg\n", + "ggcggcggcggcggcgccggcggugguggcggccccpcugagcgcucggcugcagcggcgcggaggccgucucccuggucugccgcgguccccgcccgucccgccgccggcugcc\n", + "aaagacacuuuuauuucccacagaacagaacaauaucaaauagcuaacuucacccccaaccacaguccuugcuguuggcauuuacucaacuagucuuuaauuccuguuugacaaacuuuauaag\n", + "gcgcguccccgccgcguuccggcgucuccuuggcgcgcccggcucccggcuguccccgcccggcgugcgagccgguguaupccccucacc\n", + "cccgagaaagcaacccagcgcgccgcccgcuccucacgugucccucccggccccpccaccucacguucugcuuccgucugaccccuccgacuuccg\n", + "guccccgccgcguuccggcgucuccuuggcgcgcccggcucccggcuguccccgcccggcgugcgagccgguguaupccccucacc\n", + "gccggccccgcapucuupcgucggucgucggupucggagcupcgcggagccccucacagugcag\n", + "caacauagcauggagaagaaucuccagagcuupauagagaguugaccaaacaagacucaggccag\n", + "ccggccccgcapucuupcgucggucgucggupucggagcupcgcggagccccucacagugcag\n", + "uucccaggugaugcuaaugcugcuggcccauggaacacaaucugaguagcaaaaguauagaucacuggauugaaaguuagagaccauguuuuccagaacag\n", + "ggccggccccgcapucuupcgucggucgucggupucggagcupcgcggagccccucacagugcag\n", + "guuacuguuuucupaucugauuggcuuagacgguguuuggaupagcagaacgcuggagcuugcuguccugcugaaacuucuaggaccug\n", + "aauuuuucucugcuuguuggacaugaagagapagacaaaggcucucagaaagagaaagacpcuggugaaggacaaacuaag\n", + "gaauuugauuauucacuuuuccaagauaaaguggcauggagupaaagaccauuaaggaaugcugaacauaaaggaauccupaccugacccucaguuaagacauaaga\n", + "uuggcupcuaggcuuccpcucugcaguccucggcgugugcuggcagcuucggagcccaccgagccpcggcuagg\n", + "gucacgccccpcagcuuggcupcuaggcuuccpcucugcaguccucggcgugugcuggcagcuucggagcccaccgagccpcggcuagg\n", + "aucaggucacgugaggccggucacgccccpcagcuuggcupcuaggcuuccpcucugcaguccucggcgugugcuggcagcuucggagcccaccgagccpcggcuagg\n", + "cuuggcupcuaggcuuccpcucugcaguccucggcgugugcuggcagcuucggagcccaccgagccpcggcuagg\n", + "accauaggucacuucugagaucupacaucaacugcccggagaguggcupuggacaucccapucuuuuuauuguuuucuguugcaucccagacccuacaaccccuuccugaaagg\n", + "agucaggacpaguccggcpuuacagcggaggccuagguggcagacapcccpccgcugcguguuguccacccaag\n", + "gucagucaggacpaguccggcpuuacagcggaggccuagguggcagacapcccpccgcugcguguuguccacccaag\n", + "caauccagaccacgucuggcaggccccaaggcccaggcagcuuuuugagagccccucuccugccuggccupacaugagccauucacaacagaggaga\n", + "aagugucagucaggacpaguccggcpuuacagcggaggccuagguggcagacapcccpccgcugcguguuguccacccaag\n", + "agagupapcaagugucagucaggacpaguccggcpuuacagcggaggccuagguggcagacapcccpccgcugcguguuguccacccaag\n", + "pcaagugucagucaggacpaguccggcpuuacagcggaggccuagguggcagacapcccpccgcugcguguuguccacccaag\n", + "aaguagugccuguaacupagucpugaaupupugacaacaguuguuuuccguggagcuugcccgcagugccuggcugcaggucupcauuauacuuagg\n", + "auuuuguccaggaacgccuacguuuguggcagguggagacagcuuauuaggcagccugcucuccucuuaug\n", + "uuuguccaggaacgccuacguuuguggcagguggagacagcuuauuaggcagccugcucuccucuu\n", + "agagucugagcgaacugcgcccagcgcpcacggagccucccaccgccagcaaccugcggccccggagaaggcagcgagcgcagugacagcgccucaccgccaccagcuccuggaccacc\n", + "aggucagagaauggcccuaguccaugagcacugaggaapacuuuaaggaaucccucucauuuugacaaggaaagcaaaagcccagagagaucacacaacuauuuagaaag\n", + "cggcucccgcggcuccggcuggcggcuucpcccugcaccugugacucucggccgcgcucgcccucggcccgcccggcgccgcagcccc\n", + "gccgugcaggcucuagcaaaaggcuppuccccagcgacccccaucagcuuugauaapauccggapugccagugg\n", + "ggcuucpcccugcaccugugacucucggccgcgcucgcccucggcccgcccggcgccgcagcccc\n", + "aggaaaguaagagcggcccupugacagcgccgcpccagucccpuuagccgcgcgucugcucgcuucugguccgucgcgcucccagccapcacagcccggaccgagg\n", + "ggaaaguaagagcggcccupugacagcgccgcpccagucccpuuagccgcgcgucugcucgcuucugguccgucgcgcucccagccapcacagcccggaccgagg\n", + "guaguuggagguggccugaggagcucaguucccucagcgcccguagcuucggcggagucugcgcg\n", + "agcggaccaccupugcugucguaguuggagguggccugaggagcucaguucccucagcgcccguagcuucggcggagucugcgcg\n", + "uagcgcuccggcupucucucccccgccccccaggcucccccggucgcucuccuccggcggucgcccgcgcucggugg\n", + "cccgcccccgccccpccaacuccgcggcgccuccuuaaaaagcgcgcpaguuguaappccggagcgagccggagugagcgagagcgcagg\n", + "gauaaugccaggcccugcccccggcagaggcggaagcggagucggccugagaggucucucgucgcugcag\n", + "gauaaugccaggcccugcccccggcagaggcggaagcggagucggccugagaggucucucgucgcugcaggcgccucagcccagccgcgugccuuggccc\n", + "gaggcggaagcggagucggccugagaggucucucgucgcugcaggcgccucagcccagccgcgugccuuggccc\n", + "agaggcggaagcggagucggccugagaggucucucgucgcugcaggcgccucagcccagccgcgugccuuggccc\n", + "auauacuccaagaaaaaaaccacaaauguuuuucuguuuugccugaauacaugauuuaaacaagagauuuccacagaag\n", + "ggcgcuuucauggaacuauaugaucauaupcaacauucuguugcagucuaccuucugucugacggauaugccauccugaaaaaggaaagaagcugaacuucaaguuccuuucauuuagccuugg\n", + "gcccapccccagugcagccuggacacaguauucaaaguuuuggcgucugagcauuguuaugcguuauuuucaagcuuugcuaacg\n", + "aguucuuccccugcucggcugccccugcccgccccucgapagcgcccguagccagcgcccccguaaagaaauaaggaggcgcccggcuucccgcccag\n", + "agcggcagcggcggcupagagcggucggcpuuucuucguugcauugccugagaggagcggagucugccaggugguguccauc\n", + "cucupcguaccggcuuggcgcggcggcagcggcagcggcggcupagagcggucggcpuuucuucguugcauugccugagaggagcggagucugccaggugguguccauc\n", + "uuggcgcggcggcagcggcagcggcggcupagagcggucggcpuuucuucguugcauugccugagaggagcggagucugccaggugguguccauc\n", + "guaccggcuuggcgcggcggcagcggcagcggcggcupagagcggucggcpuuucuucguugcauugccugagaggagcggagucugccaggugguguccauc\n", + "agcccpccagcucuuaaggaguucaggagugagaagaggcccucagagaucugacagccuaggagugcguggacaccaccucagcccacugagcaggagucacagcacgaagaccaagcgcaaag\n", + "agagaucugacagccuaggagugcguggacaccaccucagcccacugagcaggagucacagcacgaagaccaagcgcaaag\n", + "cuuguauugguuggugauggugguacuggaaaaacgaccuucgugaaacgucauuugacuggugaauuugagaagaa\n", + "ccaccuupuguugagguucauccccuaguguuccacaccaacagaggaccuauuaaguucaauguaupacacagccggccaggagaaauucgguggacugagagauggcuauuauauccaag\n", + "agaagaccgccccacucucgucgcacuapaccccgaaauccgaccgcccaupaagccacucgccagagucuuaccugag\n", + "ugaaaaaugccauggccuuguuucucauagcagguaaagaagaaccaaagaauucacugguacuaacaauuaaaccuaugcccucugagaucucauu\n", + "guauccugaugugcagacucgagugcaggcagaauuggaucaggucgupapaccgucugccuugu\n", + "aguaggcucucggcuccuggucccacugcugcucagcccaguggccucacaggacaccagcuucccag\n", + "upaapaacuuccgcuucggaccgapcaguaggcucucggcuccuggucccacugcugcucagcccaguggccucacaggacaccagcuucccag\n", + "cccuucccgccucupaapaacuuccgcuucggaccgapcaguaggcucucggcuccuggucccacugcugcucagcccaguggccucacaggacaccagcuucccag\n", + "gcccuucccgccucupaapaacuuccgcuucggaccgapcaguaggcucucggcuccuggucccacugcugcucagcccaguggccucacaggacaccagcuucccag\n", + "aaaaggaggcgccugcuggccuccccuuacagugcuuguucpcgcuccgcuggcuucuuggacaauugcgcc\n", + "uucuugaggccaaaucuggcuccuaaaaaacaucaaaggaagcuugcaccaaacucucuucapccgccucagaagccugccaucacccacuguguggugcaca\n", + "guugugcccguaagcagugcagcgapaggacauauuccaaugcagucauuucaccuaacuuggaaaccaccagaauc\n", + "aaacaaccuacaacuaugaauggaauuuaauaagccaccccacagacuaccaaggugaaauaaaacaaggacacaagcaaacucuuaaccucucucaa\n", + "uuguccgucggacuuuaugucuucaaagucacuguuucuagugaaaacgccuuuggagaaggauuugucaaugucacuguuaagccug\n", + "ccagaagagucaaccugccaccuguagcaguuguuucuccccaacugcaagagcucacuuugccuuugacgucagcccucauugauggcagcc\n", + "aggucucugcgcagcccagcccgccgguccacgccgcgcaccgcuccgapccagcgccacccgcuccgcagccggcacc\n", + "upaucuugugugugauaaugccuggaagguccauaucgcuaaguucuccuuacugguuggauuaaucuuuggcuaccuaauaacuggaugcauugcugacug\n", + "ggucggccggcggccugugcugcuguuuuccaucaucuucauucugaucuuuggacugacuguggcacugucagugaaugugaca\n", + "accucgcacucucaguuucaccgcucgaucuupacccaccgcugcccucagcuccgaguccapcgag\n", + "acuucupcagccgugagcagcpcacacpcagccacgaaagcagcagcgapuggugcaaacaccucaaaacuacaccgaauccaguagcgccuggcgcccccggcgcgcaag\n", + "cugcagccucucugccuccgcauccucgupcccugaccuucucucugagagccpcagaggcuccggagcc\n", + "gaccuaaacugccccuuccucgapucuguauaucacagagccaaagacaauucaggaacugcugugcagccccucagaguaccgcuuggagauccuagaguggauguguacccg\n", + "ggucuggcccucacugcaggacagguucagcucacugaaapucccaacagaggugaagauccaag\n", + "ggcugugccugcgcccagaagcagcuacacuucauggaccaguugcucgauaccauccggagccugaccauupugcuccaguugcucgag\n", + "ggccagugccucugccaaguccgaggaggaggagaagcuggcggagcuugccaggcagcugcaggagagugcugccaaguugcacgcgcuuagaacggag\n", + "cugcugcaaguggucauggcaguugcugacaccucugcgaaggccguggagaccgugaagaagcagcaaggcgagcagaucugcupuggcagcagcuccgucaugagucuag\n", + "gcagcupcpcugcggccgcugauuaaaggccgccuagagcagccuguguggcgacaggugcccagaagcccaggaagccggucagugcccgccccag\n", + "uccucapuuugugccucucgcucggacaguuugaggacuugcuauccccgupaacaucacc\n", + "ucuacgacgacgagcupcgagugcugccagcgcccaggcccugaccuccacccgugcggccccaucauccaggccacgcaccagaaucugacuuccuacagccaa\n", + "cuaccaagaugaaugaacuaauggagaaauagaaagucuucagugauggccuacgccaaagcacagg\n", + "uggccuacgccaaagcacaggaupcpcaggaagcccucucccaagaucgaguuggccgaggauggaugauuguggcagcagaagccguugcagccccacguugugcucuag\n", + "uugaagaagaacaggagaaaagacuccgacacuccccaggaaccuucggagaaggccaaagagcagcaggcggaggcagagcuccggaagcuaaggcagcaguucaggaag\n", + "guggcgcagcgaggccgcgcagcaagcaguccucccggcaccgucggaagcgcaguugcagcagccgucggacaagcggccggagcagccacggacaagcaguccpccccgccacug\n", + "ggcauugcagagagacagagagagagaggaaggcucacuggcuuugagcucucupuacagugucugaguggaggcaaagugcgguuccuucaag\n", + "ccgucggaagcgcaguugcagcagccgucggacaagcggccggagcagccacggacaagcaguccpccccgccacug\n", + "aaguugugguauuugagaagaacacugagucaccauugccacagacucugauaucgguacugcugguaggccauccauccaaaucuagaaaguuucuauug\n", + "aaugccagaggacuuggaucugagcuaaaggacaguauuccaguuacugaacuuucagcaaguggaccuuuugaaagucaugaucuucuucggaaagg\n", + "uuccucgccaggacggacgcacuuccggcggaugupccagcccucggaaacggaagugagcggcpucgacugacgguaacpcagagaggcuguucgcagagcugcggaagaug\n", + "aaguugugguauuugagaagaacacugagucaccauugccacagacucugauaucgguacugcug\n", + "gccagcccucggaaacggaagugagcggcpucgacugacgguaacpcagagaggcuguucgcagagcugcggaagaug\n", + "uugugguauuugagaagaacacugagucaccauugccacagacucugauaucgguacugcugguaggccauccauccaaaucuagaaaguuucuauug\n", + "guggauccauaaagaacccagccaacccgcagapapapcugagcugugaggagagcpcccaagaacc\n", + "cggagcugcuuuucagcccuapcgugcucaagaaucccccguuacucugaucaaaggacuugcuaaguuuagaaauaaagcgcuuuacaaaucaaau\n", + "cpuuccuugcuccccuccccggccgccuccgacgcpcguccuggagagcgcgccccauugugcpccggcpag\n", + "agcuugcuugcccggcucgcucacpucguugaggccggugacaugucugugagcugcggaggcugcggcccccag\n", + "cpuuaagaaaaupccggcugccpupcgaggacggcpccpccpccpcgccggcgaag\n", + "uguuauaguuuugccgcuggacucuucccucccuucccccaccccaucaggaugauaugagacuugaaagaagacg\n", + "gaggagagacuucagcaugcaaaccuucaucuguucggcuugcaccgucauuuucauuccaugcugcuggccuucag\n", + "pagcgcggcgcpagcccgaggcugagacucaccggaggaagcggcgcgagcgccccgccaucgucccg\n", + "gcugaagugcaguggcacgaucauagguggucacuacagucucagauuccupcuuaagcagucuucccaccucagccuccccaguagcupauuacag\n", + "caccagugupaaccgccpugauucgcaaggacaaugcacpuuaagaaaaupccggcugccpupcgaggacggcpccpccpccpcgccggcgaag\n", + "uguuauaguuuugccgcuggacucuucccucccuucccccaccccaucaggaugauaugagacuugaaagaagacgaugcauacag\n", + "gaacuauuucucagcauugucagcuccuggauugcuccuupcgcuauacugcacauuggcuauaccaaguagaugcucacuuucgacugag\n", + "ccgcuggacucuucccucccuucccccaccccaucaggaugauaugagacuugaaagaagacgaugcauacag\n", + "aagagacagaguaacuagcucagcaaaaccaaaacgucacauucagcaucugcaagacuaggugaacaguauccccacugacucacauacaa\n", + "gaucucacccuguugcccaggcuggagugcaguggcaugaucapcucacugcagccuugacuuccuggaaucag\n", + "gcaguccgugccgccgucccgcccgccagcgccccagcgaggaagcagcgcgcagcccgcggcccagcgcacccgcagcagcgcccgcagcucguccgcgcc\n", + "acagcaguccgugccgccgucccgcccgccagcgccccagcgaggaagcagcgcgcagcccgcggcccagcgcacccgcagcagcgcccgcagcucguccgcgcc\n", + "gccccagcgaggaagcagcgcgcagcccgcggcccagcgcacccgcagcagcgcccgcagcucguccgcgcc\n", + "gacaaauuauuggauuccagcacagugacucacuuauucaagauaacugaaaacauugguugugug\n", + "acuuccpaggugcuugugugccuggugcpagcuacpcccapauuguguuuaaaguagugcuucuaccaac\n", + "ggaagcagucgcugcaacuuccpaggugcuugugugccuggugcpagcuacpcccapauuguguuuaaaguagugcuucuaccaac\n", + "cugcaacuuccpaggugcuugugugccuggugcpagcuacpcccapauuguguuuaaaguagugcuucuaccaac\n", + "augcaagagcggaagaaacgcggcugguaccccggaagcagucgcugcaacuuccpaggugcuugugugccuggugcpagcuacpcccapauuguguuuaaaguagugcuucuaccaac\n", + "aguguccuaggcupagaaupauggagccuccaccucaugaaguagcuuccuuuggagguggcu\n", + "aauaugcuuuuaaggcuauuaaccapuggccuuacaucaguagcugucagapaaagacugugcaguaauugucacacagaagaaaguaccu\n", + "guggaugugupagcacaggccggucuggugguggcugguuacuaccaugccaaugcagcugugaacgaucagag\n", + "cacucaagcaucaagcagucgugcaucaagcauccagcaggcccgauccccgcaggccaccuacapaaaggccacagcugcgcccacaccuaugagaccupaggcccagcucaaaugg\n", + "cgcuuccgccggupacggaacuggugcccuccguggacaauuguguugaagcagaaauuguuccggaucucpucggacacggaagucuuccugcaguguuucuggaugcpacap\n", + "ggcupuucucagagaaagaaaacgugaugcagcagaggaupauugaagaaacaggagagugaaguggaaauagccuggcccgcgugacuuaaaccggcccggagaugugcgg\n", + "pcpcggcgguuccgagucaggcgcgcgcpcapuccccauugccugcugcgcacccggacgugcggcuccccucggccuccucgcc\n", + "auuuaacauugaagagcggaagguggcggagacucggcgcgccccaggccccpugcacgupcgccggugcccggaugauggagugucccgauccgugcaaucccuggcgg\n", + "uuaaggaaguucaccuccagauguacucagapccuggucuuagcugccacagauuuacaaacccuuaca\n", + "gcuucuaupcugcccccucucccaucgcapuaacuggcaccaggcuguuaagcuguggaupcaaccgcacagugcauuggau\n", + "auaauagauucuaaggagacauggauuccuuucaacucugaggauucacagcagcuggaagaggcauauagcucug\n", + "gaaaagguuguaaupagaguuguuccuacugaupcagauaugauguucauuupagagg\n", + "gguauuaagagaccagccccgcagccugcuucapcaaacauccccaaagaaucugaguucugcaguagcaguaauacuagaaauggugacuaucuggauguuggcauupcag\n", + "uucuugcugcugccaugugaagaaggacguauuugcuuccccuucugccacgaupaaguuuuccgaggccuccgccacuaugcugaacu\n", + "caucagugcagucacaacaggagcaguugucccagucagauccaucuccgucaccaaacucauguaguuccuuugagcuaauagac\n", + "gcccugcuccgccgcgccccgcccpcupuaaaggccgcggccpccaugcaguguccuccucapapcaggagagccugaggaguggcpccgccag\n", + "guccucgcugcggaaaguupcaaccuguugcuagucuggucguuggugacagcgaggcuuccgcgcucgcugcuggugagcagccccggcgugccccgcpcuggaagaggcggcggcgug\n", + "acuuccuccucpccucagaaaaccacapcgcpccapcggcggcccccapaguuggcagg\n", + "agcacagaaggaggaaggacagcacaccugacagcccugcucaggaagucucuggauccuaggcucaucuccacapagaacacacagacagcagagacc\n", + "aaggaggaaggacagcacaccugacagcccugcucaggaagucucuggauccuaggcucaucuccacapagaacacacagacagcagagacc\n", + "ggaaggacagcacaccugacagcccugcucaggaagucucuggauccuaggcucaucuccacapagaacacacagacagcagagacc\n", + "gcccccggcccccucccgccpucaaccccgaagagucgccgguggccgcggcagacggaagccgaacgaguuccucggcggcugcagg\n", + "uggaaccucgugugugacucucaugcucugaagcccauggcccaguccaucuaccuggcupauucuggupagcugcugcgugcggcccugccucagacag\n", + "cucgcuaggcgcucgccacgcccaugccuccgucgcugcgcggcccaccccggaugucagccccccgcgccgaccagaauccgugaac\n", + "gagcugugacuugaacaaugcuauucugcaugaaauugagaaauugccaguguucccaaccugauggagaguaugugupaucuuaguucugcuucauuaagcuccuuguga\n", + "gagcugugacuugaacaaugcuauucugcaugaaauugagaaauugccaguguucccaaccugauggagaguaugugupaucuuaguucugcuucauuaagcuccuugugaaugagug\n", + "gucaaupaaggaucuuucaaaggccacucaugaagaggcaguggaagcuuuucgcaaugccaaggagcccauuguggugcagguguuaaggcgaacaccucuuaguagaccagccuaup\n", + "gagcuguaagccuaggcauggugucucaugcuuguaaucccagcacuuuaggagaccacggcaggaggauugcuugaggccacgaguucaagaccagccuggcaucaua\n", + "aguucaccgaacagcagaaagaauuucaagcuacugcucguaaauuugccagagaggaaaucaucccaguggcugcagaauaugauaaaacuggugaa\n", + "agaggagucccgcguucpaguaugucaaggccgugacccguguauuauuguccgaguggccggaacpagccaac\n", + "paccagaggagucccgcguucpaguaugucaaggccgugacccguguauuauuguccgaguggccggaacpagccaac\n", + "pcpaccagaggagucccgcguucpaguaugucaaggccgugacccguguauuauuguccgaguggccggaacpagccaac\n", + "accagaggagucccgcguucpaguaugucaaggccgugacccguguauuauuguccgaguggccggaacpagccaac\n", + "upcpaccagaggagucccgcguucpaguaugucaaggccgugacccguguauuauuguccgaguggccggaacpagccaac\n", + "agauuagccagaagacuagagagaucucugucuucagucccuaucugugcucuuuuccauuccugcgucaauacugcugaaguagucugagaaggaaauaaauaaagacugcacccugucucag\n", + "agucgucuccugcgaggcpcagcgaggucagcuuggcagccgcugccucuccagccuggaucuggccgcaggcagcgguucccuaggacccgagaaaagg\n", + "augaggagacuguccuuccuguuucgcagaugaggaaacugaggcuuagagaaguuuggcaaauuggcuaaguuccuacagcua\n", + "gaacgucaugguaccuaccuccaguggcuuuucuaaggauucaaauagaucacccccauaaaggauucagcacagugugaacauauagua\n", + "pugcgcgcaggcggccgcacagguuccaggucuuuaacgugagcccgcugcaggugugcggcccaguccgagacagcag\n", + "agugaauccpupugcgcgcaggcggccgcacagguuccaggucuuuaacgugagcccgcugcaggugugcggcccaguccgagacagcag\n", + "cpaaccapcuuacugcpacggccuuggagaguacucpuucgugaacuucccggaggcgca\n", + "caacgaugugaagguuauaagcugcacugcaugguugcugcuggauguguuguguuccuggcuucccucuggaugcugacagaaacaagg\n", + "gaauuucugcugaagugacaaggcaagccagagccaaagcagguuggacccagcuuguccccacagagacgugugcuucccucucucucugagagcgaccuguuaaccgcaaauac\n", + "acaacgaugugaagguuauaagcugcacugcaugguugcugcuggauguguuguguuccuggcuucccucuggaugcugacagaaacaagg\n", + "apcccacaacgaugugaagguuauaagcugcacugcaugguugcugcuggauguguuguguuccuggcuucccucuggaugcugacagaaacaagg\n", + "auaagcugcacugcaugguugcugcuggauguguuguguuccuggcuucccucuggaugcugacagaaacaagg\n", + "gaaapuggucaucuggccguuuucaaacaaaaacuacauccauggugagcuuuauaagaaucgcgucagcauauccaacaaugcugagcaguccgaugccuccaucaccauugaucagcugacc\n", + "agaagcugcuguagcuuuaaccagacagcucagaccugucuggaggcugccagugacagguuagguuuapcagagaagaagcaagacc\n", + "gcccccgccgccuggcgcccgcccgagcugccgccuugucgagcugaguccgcgcucccgcccaggcggcggccgacgcgacgccccgagcgcccggccccgccgccgcggcccggcag\n", + "acugcggagcpcgcpugacuccagagcggcccugccaguccgcpcuggcpagcag\n", + "cucupugaaccaggaggaugagguggaggapcccagcgaugugcagaacggacaccuggaccccaauucagacugccucugucupcggccacuacagaaccpaccag\n", + "gaagapauapccagcaaggcapaucgaacgagugucuggcagccpagcccagcgaagagagcgagcaagcuuaggaaaacgagcgaa\n", + "guggccaaagccaagauuauuuucccaauuuuauggcuaaggaaauugaagcucagagaauugcuuugauugacucag\n", + "cccuucuagucagcccgcgacaacucgcgccagcuacpccucagagaagccggacuucgcaagcaccaugcaguggauaapcggaucpaaug\n", + "uacccagaaugcuggaaaauugcaagcuaacuguccuagucugaagaaucuauaaucaagaaaggaaaucugaccag\n", + "apuagccaggcaguugcugguagcaaguaaggagaaagcacccugcugcuaacucacuggcugaauuuag\n", + "aaaaaacacuaguccagaaggcugaccauuugaugacuguaggcaaguuacuuuuguuaaaccucaucuauaaaaugapcaugaag\n", + "gcagccacagccuggaaagccucuccagccagaggucaaccucugugcuagucccucagugccaaaaaggucaaa\n", + "cggucupagagcgagcuugcuupagccuugaggcucugauuggcggucgcggcuagcacgccagcgcaagucccgccccupcagcgaacgugcuacugcggcaucuguuauuggucggcgg\n", + "paupagagaagapauapccagcaaggcapaucgaacgagugucuggcagccpagcccagcgaagagagcgagcaagcuuaggaaaacgagcgaa\n", + "ccuucuagucagcccgcgacaacucgcgccagcuacpccucagagaagccggacuucgcaagcacc\n", + "aguugaagcucggcgcucpuuaccccugcagcgacgcccccuggucccacagauaccacugcugcucccgcccuuucgcuccucggccgcgca\n", + "apapcucuucacccaguccggcaguugaagcucggcgcucpuuaccccugcagcgacgcccccuggucccacagauaccacugcugcucccgcccuuucgcuccucggccgcgca\n", + "cucucccgaagccccucugacpuucuucgcuucccucuuggccuugccuucggugcagacucccauuacag\n", + "auauuaucguggagcuguaggugccuuauugguuuaugacauugcuaaacaucucacauaugaaaauguagagcgauggcugaaagaacugagagaucaugcugauaguaacauuguuauc\n", + "pugagaugugugcucugcgcugagguggauuuguaccggagucccauuupagcaagagccaucuacucguccguuaccgg\n", + "gguaagcuuaccgugaaaggapuuupcuguuguugcuacacguggaugugaaaugagucaagcggaacuuugauuacaaggaauuucauauacu\n", + "aacauugcuacuagcguuguggauaggagccaggauccugcaauguacaggacaguccugcccacugaaaaaauguucacacuuucaaaugucuugcugaacauucag\n", + "cuccagcccuucucugagacpaccapauggcagccaugcaccugacagccuggccccag\n", + "aagucggugaccuuugaggacguggcuguguacuucacccaggcggaaupauggccuguccccugcacagaggacccuguacapaugug\n", + "auucuuucuuccucuuggcuuauauuapauapaugugguuuguuacaaaggaugaguauuuugauagcuucucauuccuugaacuauucugcag\n", + "cagguuuauaacaaagcucagaaaauacuaaagguuaaaggagaauugagagcugccaaggaaaugaaagaugag\n", + "cucauugcccugaaaauaucagaucauagugauacaapagcagcgucugcuauggaucucagacaaacuucuaagucaaccaugaaaauaaaaaccaucacaccugcucuaag\n", + "aacauucuuucuuccucuuggcuuauauuapauapaugugguuuguuacaaaggaugaguauuuugauagcuucucauuccuugaacuauucugcag\n", + "acaccaggugcugaaggcugagacggugagagcaugagugauaagaugcucucuccccuugcucucuuucugaagaugacaaacuccaucuuuuuucuaaagucuuacuaaag\n", + "gugacaauguauauaguauaaugaaggauguuacuaaaugacaugugcugcacaccugagucuuguggaggcugaagaaaaggaggcuucuguagaaaauaggaacuca\n", + "ggugagagcaugagugauaagaugcucucuccccuugcucucuuucugaagaugacaaacuccaucuuuuuucuaaagucuuacuaaag\n", + "uuuaacaagaaauaaaaaaaguacaaauguuucucauucaagauaauccacauuuugaagaucucauuuuacacaaaaaagg\n", + "uacaccaggugcugaaggcugagacggugagagcaugagugauaagaugcucucuccccuugcucucuuucugaagaugacaaacuccaucuuuuuucuaaagucuuacuaaag\n", + "gcccacuggaaagcuucaauacagcuguggaaaucugcacccuagaagauccuaguacagaaauucuacaaccaaccauaauc\n", + "gacagcccacuggaaagcuucaauacagcuguggaaaucugcacccuagaagauccuaguacagaaauucuacaaccaaccauaauc\n", + "cucucggcuccuuguggcccaaaggccuaaccpuccggcggucuggccuapaucuuccccguugccccuuupcp\n", + "guggcccaaaggccuaaccpuccggcggucuggccuapaucuuccccguugccccuuupcp\n", + "gacugcpccagcucuuccccuacucccucucggcuccuuguggcccaaaggccuaaccpuccggcggucuggccuapaucuuccccguugccccuuupcp\n", + "acgcgcuuccuuccgcccuccgcgccpugcagcccucuguccuccpcccccgapcgccapccguuapucccpcagcgcucccgcgcccugucccgu\n", + "uucaaaucugaacaucaaugauguacuapaacuacucauugacucuuguugaugcauuggauacacuugca\n", + "aaapaagcgagccpcuacpcgagcgcpugcgguggucggcpaggcccccgcgcuuuaaaauaaugcccgcggcgcccgcgcgacc\n", + "ggccugcuccccgucaugucuucggccuggagaagagccagcuccugaaggaggccuuugauaaggccggcccgguccccaapcagagaagaugugaagaggcuucugaaacuacacaaggaccg\n", + "guuccgaggugaccugcgguggauccucuucugugcagaccugccgucccucauccaagaaggcccuca\n", + "gccccuccucaagugucuggcugaaagaugccacccapaapaacucpcuagcuaaggaggccauucuug\n", + "uggaauacaaacucucccgacauccguaguuacuuucaagguggauuguguauuuuaaggcugaupaacgucugguuuguggagcaaaaagaagagaag\n", + "cuugcuauggcauuguucaaguacccacuggaccgugguuuugcaggaaaugugaaucucaggagagagcagccagagug\n", + "cuauauuccaagcagacagagcuggaaggagacacuguuccacuuagaggcccaguggcaggugcapaacuuaug\n", + "agcaguugccauggaguugcucugaguaacccugaggcagupacgccaagacuggagaggaagcgacugcgg\n", + "gucuccuagcaacggcpuagcguuguugacaucccpaggcugugccgccggccugagcccagaguuucgcggccuccgcg\n", + "uggucccaaggcgcgugcuuugcagcagaugugugaccuggcguuccccugagugcucggaaaauggccuugucuccggucguucccguucaggagcag\n", + "aggugaagaugcugcuggcggaaccugcaggagcuagcpauucpcgcuaaagucgcapcapcpaaggaagauccggcgcpcacaggauccggagcuggagcccccag\n", + "cuguupugcuguggucccaaggcgcgugcuuugcagcagaugugugaccuggcguuccccugagugcucggaaaauggccuugucuccggucguucccguucaggagcag\n", + "guuccagugcauaagaaggcugucaaaugugcugucuucaagcaucuagaaagccagupagaaagacaagaaagugacugugagcagcaacaggcccccpapugcagag\n", + "gugcuuugcagcagaugugugaccuggcguuccccugagugcucggaaaauggccuugucuccggucguucccguucaggagcag\n", + "pacaggcccugccagcuacugagugagcagccugcggcagcccugacucacugcpucgugccgucugugcagcacupuacccaccacccagugccag\n", + "pcgcuaaagucgcapcapcpaaggaagauccggcgcpcacaggauccggagcuggagcccccag\n", + "aaacgupagcaugcucaggcagaccacgguggucagaaguugaauucpccggaggaggaggagugcaugaagcccugag\n", + "gcugcaccaacuuccuguupugcuguggucccaaggcgcgugcuuugcagcagaugugugaccuggcguuccccugagugcucggaaaauggccuugucuccggucguucccguucaggagcag\n", + "uguggucccaaggcgcgugcuuugcagcagaugugugaccuggcguuccccugagugcucggaaaauggccuugucuccggucguucccguucaggagcag\n", + "cpauucpcgcuaaagucgcapcapcpaaggaagauccggcgcpcacaggauccggagcuggagcccccag\n", + "aagaugcugcuggcggaaccugcaggagcuagcpauucpcgcuaaagucgcapcapcpaaggaagauccggcgcpcacaggauccggagcuggagcccccag\n", + "ggcgcuaaagucgcapcapcpaaggaagauccggcgcpcacaggauccggagcuggagcccccag\n", + "agagugucuggugaucccuaauaaaccagacuguggccuuuuuaacgagcagacgcccccacgaaggcag\n", + "aaaguggugucggagcagcgccuauuagugucauccucaccgucacggccggcgccuccuccuggauucauucacucgcucuuuucauucacgaagguagugaggccuaguggaaagcc\n", + "gucauccucaccgucacggccggcgccuccuccuggauucauucacucgcucuuuucauucacgaagguagugaggccuaguggaaagcc\n", + "gagcugacugcupcaggaacgucucucaggagaaagaguggaagagaaaauugugaacuaaggcccccugcccccuuuuccuggugcaugugaaguuaucaaaaacag\n", + "acugccuguuccaggapcagacuaugcugaucuugcucacuccaugagcccagaagaaggcccgacacacagcag\n", + "cggcuccugcuccuccuggccgcccpccaaggcgacgagagguuguaaaaauccaugupacggccccpcgagcaucggaaag\n", + "cuccgcgcgacccggcpcccgccuccgccgccpugcacgcgcagccugcgccucgugccggagcagagcagaggccaggaugcggaguugugcacuuugagccggcccc\n", + "pagaggcgguagcugacagguggcgccugcgcacupagcgcucauugugccccgcagcugcggaaccgcccgcccgccgcccguucggagcgucagucggcgacagucuggug\n", + "ggcaucccccagccgccgccagccccgccgapagccagcgccgucucugapcguccggcgccggagcc\n", + "cucuaucaaggcuugucaagcagugugcucaucacaugguaaaucaugcagcguggaaccucauaaaaucuccaagaaacaucauucacccauacugacuaguuucacaucucuuug\n", + "uuugaagaaaacaggucugaaacaaggucuuacccccagcugcuucugaacacagugacugccagaucuccaaacaucaaguccagcuuuguccgccaaccugucugac\n", + "gucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacagguaccuapagcagccaggcgaggucguuggcpup\n", + "cuggucccugcggcuggcggccgagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "uggcggccgagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "gagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "ggcuggcggccgagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "aaaucaagaugacuaccagcugguucgaaaauuaggccgagguaaauacagugaaguauuugaagccaucaacaucacaaauaaugaaaaaguuguuguuaaaauucucaag\n", + "ccaguaaaaaagaagaaaauuaagcgugaaauaaagauuuuggagaauuugagaggaggucccaacaucaucacacuggcagacauuguaaaagacccugug\n", + "uaccugcagaauaccuggcacagugcuaggagaaggauucagagacgaaugugacacauuuucuuccuucaaggugugcucauaa\n", + "gcuaagagacugauagcacuggaaacugaaauguguuaauccauuuugcaaacucagguccgaugccgaupcgaupcgcauugucpcugccuagagccug\n", + "agccucgcucuggucccugcggcuggcggccgagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "cugcuucugaacacagugacugccagaucuccaaacaucaaguccagcuuuguccgccaaccugucugac\n", + "gcagccucgcucuggucccugcggcuggcggccgagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "cucgcucuggucccugcggcuggcggccgagccgugugucuccuccuccaucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "aucgccgccauauugucugugugagcagapagagcggccgccgccgcugccgcuuccaccacag\n", + "ggaaauguggacacpacgccggaaacapacacgcaccagacgcupuguuuagaggcugccgugagaggcucagcuguaggaacacuguupaucacucgcaucaguupcg\n", + "aauucccuucccagugagaagcucggcaapcpucccggaaagcacagcugugaucupaggugcugagcacccaccugcgacccauggcpapccgaguaacgacagc\n", + "aagagcggcggccgcuucuacaccgccggcpaccacggcccggagccuugagccggacgacgagccggaccucggcccccggaag\n", + "gagcggcggcggcaaccgacguacacaapcuugagcguucuguggagagagugcgaggucaggcc\n", + "agaugguuuaaagcuugaaacugaauuacuggauggaaaaaccaagcuaauauugucuccauaug\n", + "guagcgcuugcugagcggcggcggcaaccgacguacacaapcuugagcguucuguggagagagugcgaggucaggcc\n", + "gcguagcgcuugcugagcggcggcggcaaccgacguacacaapcuugagcguucuguggagagagugcgaggucaggcc\n", + "guuguuggcauggagccaaggaugaggagguaccuuccaagcaguguguuucuguaagaguguuacaggucacaauuccaaagccagcuuuguccacccugaaggcccagcccugcaag\n", + "cuggaaugcuugcugauuccucugcacacuucuaaggcugagaaccugaggaacccagcuggaaa\n", + "cuggaaugcuugcugauuccucugcacacuucuaaggcugagaaccugaggaacccagcuggaaaaugccgucugaacgcugccucag\n", + "gcaauguucagucuuuguaugguggaaaguggagcugaugagguuaauuugcacggugugaccagccuuggcuuaaagcaggcucuggaguuugcauacacaggacag\n", + "auuuugcuggagccaggugugauccaggaugugcuagcagcpcagucaccuacagcuguuggagcuucucaauuu\n", + "gguucacugcagauuaucaaucaguggaaagugauagaagcaauggaucagcagaaupuauagag\n", + "auuuugcuggagccaggugugauccaggaugugcuagcagcpcagucaccuacagcuguuggagcuucucaauuuaugcucccacuaucucauccag\n", + "gcaccuccugacuacucccugcpacggcupugugapuggcagccuugugcucaagccgaggcupcuggagg\n", + "ggaagcugguggcggcuggupcgaccpcgcauccucauugcagugcggcggcccuaccucggcccuggccugaccccggcggcccugcccgccccucccuccag\n", + "guuuguuuugaguguggcgcguucaauccucagupucagugugaccuacggcaucuggaucugccuggagugcucpagacaccgcpcuupuucaccucag\n", + "cuuugugcgcucuguuacuauggacaaguggaaggacauugagcuugagaagaugaaagcuggupa\n", + "ccggaagcugguggcggcuggupcgaccpcgcauccucauugcagugcggcggcccuaccucggcccuggccugaccccggcggcccugcccgccccucccuccag\n", + "agcugguggcggcuggupcgaccpcgcauccucauugcagugcggcggcccuaccucggcccuggccugaccccggcggcccugcccgccccucccuccag\n", + "aaagcgcaacguagccggaagcugguggcggcuggupcgaccpcgcauccucauugcagugcggcggcccuaccucggcccuggccugaccccggcggcccugcccgccccucccuccag\n", + "gcaaagcgcaacguagccggaagcugguggcggcuggupcgaccpcgcauccucauugcagugcggcggcccuaccucggcccuggccugaccccggcggcccugcccgccccucccuccag\n", + "pcgaccpcgcauccucauugcagugcggcggcccuaccucggcccuggccugaccccggcggcccugcccgccccucccuccag\n", + "aucucgguggccguccgcccacuccgcggcguucpaaauggcugcgagacccuagaggccugcg\n", + "cucgguggccguccgcccacuccgcggcguucpaaauggcugcgagacccuagaggccugcg\n", + "auucpuccpuuuuaguuccucpagccccuggugccccggauacggcugauuuugucgugupaccuguucuggcugcuccagccccaggaaggacccaggacacccggaagccggaa\n", + "guuuuaguuccucpagccccuggugccccggauacggcugauuuugucgugupaccuguucuggcugcuccagccccaggaaggacccaggacacccggaagccggaa\n", + "cgugupaccuguucuggcugcuccagccccaggaaggacccaggacacccggaagccggaaaug\n", + "gacucaguggccuuugaggauguggcugugaacuucacccaggaggagupcuuugcugaguccuucccagaagaaucucuacagagaugugacgcuggaaaccuucaggaaccuggccucggucg\n", + "cuccuucuacucpcgccccggcggccgccaccucuccccagcccaggagaggcugcggagccgcagccgcccagaccgcgcagcgcpaggcagguuccgcacg\n", + "agacggaagcgcgcupacugacacguggacuupcggugcugcccpupucagccupcupaggcagccccpacacagcugugcccacgccgucugagcaccccaagcccg\n", + "ggaaggaagugagugcccuguccuuccucccugccaugagauuccaggaccggaccuggcaagugcccuaucccagccaguguuccupcucuuccaggcapcu\n", + "gcuccaagaaggaaccaagagaccgaggccuucccgcugcccggacccgacaccgccacccucgcuccccgccggcagccggcagccagcggcaguggaucgaccccguucugcggccguuga\n", + "guuggugucagcgagcgccgcggccguupacuccagcucccagcaggcaccgcuucugcggccgacgcgcguggcggcggugccggcupacucguagugcgguccgg\n", + "aggcaccgcuucugcggccgacgcgcguggcggcggugccggcupacucguagugcgguccgg\n", + "ccccuaacccugaggcugccgcgcggcggucacugcgccpuagupccccaguguugcgcucucuggccguuccuuacacucugcuucaggcuccagugcapcguagupau\n", + "gucacugcgccpuagupccccaguguugcgcucucuggccguuccuuacacucugcuucaggcuccagugcapcguagupau\n", + "ggcugccgcgcggcggucacugcgccpuagupccccaguguugcgcucucuggccguuccuuacacucugcuucaggcuccagugcapcguagupau\n", + "cacugcgccpuagupccccaguguugcgcucucuggccguuccuuacacucugcuucaggcuccagugcapcguagupau\n", + "ggccuuccaaggcccggcagccucaguccacugcupccuggaacacggagcaguggcugcccugcgaggag\n", + "agugcaaacgcagcgccagacacgccccgcccgcgccuccccgcccccccgcgcccgcggccccaagcgguucccgagcccaggcccgcgccgagcccag\n", + "acauuucauuugaagaauguaggaauggcugagcugagaaggcauggaapcauuggagacccapaccugcauagacaaagcaguugag\n", + "auccucggccuggacccagcgccuccpaccggccgcgcgcccccugcguccgcpccpaugcggcucugagccagcggcggcuuccagcccgacupccugccpcugccccgcgcacg\n", + "acaggaaagccgcugguugugaugguggcuaugacaaaccuucagccugaagacccpapaaaaau\n", + "gguuccaucaagcuuuguggcugaccucuuccgaguuuugacaacacuucuuugcccguggaaggapaguuaacugacccugugucugaagaugaaaggugaap\n", + "gcguggagugcggcguccuggagcugcggaugaggupuaacgccgugcugacuagcagcgacgcaaggacugcggugcapcguccapcgcauccccag\n", + "agccuccgcggagaggagaggagccagaaguugaguucaaccaccaguggccaaugauuucaucaaccaugccuacacgaugaagccuccauaaaacccuaaccaaagcg\n", + "ugcguauaaugcacaugacucucuugaagugaugacaaugaacagccauggccaagcacccaugcacag\n", + "ggcuuaagagagagccucuucagaacuccaagauuuggauguuuuucuauuuuucccagaagaauucguguugag\n", + "accguuuccauggugaccaggcugcgcguccuccuugcggcagcgcguggagugcggcguccuggagcugcgg\n", + "aaggagcuaauggacaggcaapupccuguaggauaagagagcuuggaapauuguucgagg\n", + "cucgguggcggcggcggcggccggcuccaggccpuuuuggcgccgcccgccugcugccuccuggcggcuccugaacuccagcccccucucuaucagccgcucacuccgucucaauaugucucaag\n", + "gccugcugccuccuggcggcuccugaacuccagcccccucucuaucagccgcucacuccgucucaauaugucucaag\n", + "agcaaagcuuagagucccucuaagcugaacaucuacaacacuucucuucuggcucucauucuaccuuguggcuacaguuacug\n", + "gugauacacuupuguugaaggacauuuuugaaaucaugagaacucaauguuugacuaugaauguuucguuauaacugccuggaagguuagcgucaaagaaguugag\n", + "auuuuuaaagucuucuucuapuuuccagcagagccaaauguuagaaaaaucuuuccgcuccucugaagagugaagugagcaaauacaacccagcaguagguuauugaagacagcagccccag\n", + "guuuuggaaggugacaaugaaaugugaagaaguuacauuucucaaacuugaaaguuagugacggcuuaccaaauuuuaaugaaaauuaaauaugacuuagaagcauugauuuaugaaggcuu\n", + "acupucccgcgcaggcguccccpaccgcagagcaaacuuucuggacuaucugaggacacuuguccagcgagccccacugcucpaggaggagccacggccpacag\n", + "cgcugcucuugguucugguucuggaggcupuugagaggucgccgguccgacuguccucggcgguuggucagugugaauuugugacagcugcaguugcuccccgcccccgagcagccgag\n", + "aucuugaugaacaaagcagucauaauucaucucuagaaagauuuauauccuggcauuugaaaugcuuuuuauuuagaauaguaguaaaaa\n", + "ucagaucuugaugaacaaagcagucauaauucaucucuagaaagauuuauauccuggcauuugaaaugcuuuuuauuuagaauaguaguaaaaa\n", + "gugaggugcauucucgcgccgguggcgagguuapcccgcguugcgacguggugcagcgcauauuuucacaagupucucccuuguccpacu\n", + "auucucgcgccgguggcgagguuapcccgcguugcgacguggugcagcgcauauuuucacaagupucucccuuguccpacu\n", + "gcauucucgcgccgguggcgagguuapcccgcguugcgacguggugcagcgcauauuuucacaagupucucccuuguccpacu\n", + "gcuuccgguccgcgugaggugcauucucgcgccgguggcgagguuapcccgcguugcgacguggugcagcgcauauuuucacaagupucucccuuguccpacu\n", + "gagaccggcuggagcgcccgccccgcggccucgccucuccuccgagcagccagcgccucpacgcg\n", + "cucugcgcguaauggcagcgccguggccucgcguccaucuuugccguucucucggaccugucacaaaggagucgcgccgccgccgccgcccccucccuccggupcccpagguagagaaa\n", + "agacuugauupccauucacgccucaggaugaggacuggccagucugcgccuggapcpccggucccgcugaucacgugacacgauuuuugaaag\n", + "aagaaaacuucaaaaugaagaugcguauauaggcccuugcuuccauaaguccucaaccpauugucgucucucuuccuggcauuucucugag\n", + "agcguuccggagguggcccuggagaggacaucgugacccagagugaaggaucugucgcaggaaaga\n", + "gcuugupcpcccpcaggagcpcuugcccugcggagcaguagcuaggaacagauccacuugcagguugcugcucccagcc\n", + "gcaggagcpcuugcccugcggagcaguagcuaggaacagauccacuugcagguugcugcucccagcc\n", + "pcaggagcpcuugcccugcggagcaguagcuaggaacagauccacuugcagguugcugcucccagcc\n", + "auauguaaaaugaapucuguggaaggacaugaauaaagcacaggagguugaagucagauuugcagcuuucuaggcaggagauaagacaaucugcaucuucacaggap\n", + "cuucaaagcagaaggucgcgcuuggaggaaguggcggcuuugaguccgguggcccaaucgcuguuacuacuucucugaagcuccucucggcugcuugccgagacacccugccgccaag\n", + "gccuccucugcgaaccggcuaggagcuccgcgccucgccuupagupuuguagcugacpaccucggaccggcgguggcuagagcgcggagcaggcgauacgacgagccgacag\n", + "acuuuccgcgcggcggaagagcgcgcgccagcuucggcacaccupagccggaucccagcccuacgccucguccccuacaagcuccuccaag\n", + "apuccuucacguuccauucccaggcuggucugagcuccpccguggucccgcugccuccuccggucgucgugcggaagcugcgacgcag\n", + "auucccaggcuggucugagcuccpccguggucccgcugccuccuccggucgucgugcggaagcugcgacgcag\n", + "cauucccaggcuggucugagcuccpccguggucccgcugccuccuccggucgucgugcggaagcugcgacgcag\n", + "guuggugucuuuuccacgugguagaagcuggcuaaccuccacuuccacauuccagcccaapaaaguccaag\n", + "cacaacauuuccuuguauguggauagcgugaaagaagcuugugauccugcccccacccuccccaccgccacauuuuuuaaagu\n", + "augccauuguuuguaauucauuucuguuuuuaagauucuagauugucuacaagcaaaagaauguauuucuuuagucauucggaguagccugcuguaguuuuugaaag\n", + "uuucugupaggcccugaaacgcgcggagcuucccucugccuccaggcuuucccagcgagagugaaauuaaacuugaaacucggaucaacuggcagucguu\n", + "uggcuuguccccaggaccgcgcuccccccgagccguuuuagguguguguucucuucugucccgagcagucagcaaaccacagaagaaaaaaaucguaag\n", + "paacaucuggupuacuacaggcccuauuccaggcccuauggccuguggaaccucaccacppapcupccagacggagacaucaccuguggugucagcccc\n", + "cucucupaacaucuggupuacuacaggcccuauuccaggcccuauggccuguggaaccucaccacppapcupccagacggagacaucaccuguggugucagcccc\n", + "ugcaugagcagccgagccugcuaaccgcagcuccgcacuuguccaucccccugcggcuacaccauguccagcuccuacgaugaggccucacuggcgccagaggagaccaccgacagcuucupag\n", + "gauggauucggugugaapcuggcugcuguugccuccggcucuugaaagucaaguucagguggugcugagacucccupcugcagcgcugug\n", + "aauauuugaagauggugaaugugaagaaucuuguauaaacugcauggaagacagaaggaaauauaccacagugcuaaccuuugccucupugauaugaauuaccg\n", + "gcuuuucucuucucuuupaugcuuuguugucugguggugacugugcccaupugaguuguaucggaaaaucgucaugugaggaucagapaaaagaaaacagag\n", + "aaaucuupacuuuuuggacacccagagaacaggucccagauaccgaguccgcaacuccaaacaucgcgauuaauaggag\n", + "aaucuupacuuuuuggacacccagagaacaggucccagauaccgaguccgcaacuccaaacaucgcgauuaauaggag\n", + "guugucugguggugacugugcccaupugaguuguaucggaaaaucgucaugugaggaucagapaaaagaaaacagag\n", + "paugcuuuguugucugguggugacugugcccaupugaguuguaucggaaaaucgucaugugaggaucagapaaaagaaaacagagguuaguucuagaag\n", + "pacuuuuuggacacccagagaacaggucccagauaccgaguccgcaacuccaaacaucgcgauuaauaggag\n", + "cgcugcucugaapagagucugugcaguggcaccugcgcgaagcuggccaaagccugcccagacggcucaccugugcpauggaacaaaag\n", + "cauuucgucuuagccacgcagaagucgcgugucuaggugagucgcggupuccucgcuugcaguucagcgaccacg\n", + "gcagaacucgcacaapaccuuauuuagguugcgcaggcgcccgcuggccauuucgucuuagccacgcagaagucgcgugucuag\n", + "cugaccagcuucggccgguuupauaaapaagacaggcggcgcpagupaacgccugaaggccgcgccccuccuuucaggucggccaggagcgcgccg\n", + "auuuagguugcgcaggcgcccgcuggccauuucgucuuagccacgcagaagucgcgugucuaggugagucgcggupuccucgcuugcaguucagcgaccacg\n", + "apugcgaauucguuaggcaaaagcupuacaggcgcgagccacaggcacggaaaccucgcgccgaccpcccuaggcccgacgacggcag\n", + "ggucccagcacggacauggccucgcgcggcgcccgcccpcccgagucccccgcgccccgcuuuguagccccccggcggagaggcggccucgacggugcggacggcgcagacggccpcpcggc\n", + "ccagcacggacauggccucgcgcggcgcccgcccpcccgagucccccgcgccccgcuuuguagccccccggcggagaggcggccucgacggugcggacggcgcagacggccpcpcggc\n", + "ucagcgagaccacgaacccaccugcaggaaccaauuccggacacaacaccagcauuuaaaaaaauuuuuuuugucuguucagac\n", + "ccagccauggcagcguagcagcccugcguuuuagacggcagcagcucpacucuggacguguguuugcccucaaguuugcuaagcugcugguuuauuacugaagaaaga\n", + "acccugaguccpcucpccucapcccgcgagucugcgaagccagcccuuucaguaggagccuucgcugccaag\n", + "gaaucagugucauucaaggacguaacuguagacuucaguapaugaguggcaacaauuagaccuugcucagaaaagccuguacagagaagug\n", + "gauucacuuucaaagagacauauuaugcaaggaagcaacucggaagaggaaagaaaggaagucagga\n", + "agacccggaagucgagaucauggagugaacguuucgcgcgcuuuuuccuguagacccggcacccgacugcgcggaaagacugucuaagccgccacuc\n", + "ggagccucagagugcggacugacccggacaacugagaagaaaaagapcgccccucuccagccagccaacccuccaacguugacapucucucccuucuccpccuuuggacaaccag\n", + "agucgcugccgaccggcuggcupccuugcggcgugaggaccccggcggcgccgcagucccgcgagcc\n", + "aucaucgcccugccuuucccaguccugcuggcugcgcucagucuuuaggugguagcaggccagguacagcggacacuugcugaupauuccaggaggupauuucaag\n", + "cgcagauccaagucgccggacccgguguggagagcggugcugaggcuacgcpcuggagacucagg\n", + "uugucuuuccugaagacuaucuuccagucugaaaauggacaugauguauccacagauguacagcagagagccaggagguccaaccgccguagacaggaag\n", + "gaaauaaaauuggccugaaagacgucauuacucuacggagacauguggaaacaaaagguagagcuaaaauccguaag\n", + "gcggcgcagauccaagucgccggacccgguguggagagcggugcugaggcuacgcpcuggagacucagg\n", + "ggcuugagcaauucaguuucccugccugaguguuggugaccugugcugugaaauagagagagacaccuacgaccugcugucagagcccaucaag\n", + "ccgaucupcuucccpcucpuaaccggagugcugguaucuaaucgucgcucaaaagcuccuaggugcgcpuggauauaauucccggcuucucgagaagacacuacagccucaaggag\n", + "guauaucccgugccuuaccugacupcucugaguccaguuguguugucuucaacuuagacacc\n", + "gugucgacaucggcgcgcgccgagcccggaagaggcgcpcuaggaaaggaguugguucgcgcaggugcggcgccupucccc\n", + "gccgagcccggaagaggcgcpcuaggaaaggaguugguucgcgcaggugcggcgccupucccc\n", + "guagcgcuugugucgacaucggcgcgcgccgagcccggaagaggcgcpcuaggaaaggaguugguucgcgcaggugcggcgccupucccc\n", + "agccagapauagcuucgucgagaacggaggacaccggcgguccapuccupcagucgcgccagagcugagcggapcgcggcgcgagaac\n", + "agcaaugcuaagaagacguuugguuuaaagaauuaaaaggaagaacaacuuaagagcuucuucaaag\n", + "uuucccgcaugaaaauuacuuaaacguugcacacaacguuucacaaaaucuuuugugaaagaagaaaaggaaauucagugugugagucucagcaggaguuaagcua\n", + "cgucgagaacggaggacaccggcgguccapuccupcagucgcgccagagcugagcggapcgcggcgcgagaac\n", + "auuugcaaaggaaacauugaggcugacgagaggagaguuggagacugcagaacuupagcuguccacugcucugccuuugucacagcccag\n", + "acuuuguuuaaaauuucccuuugcuacupaggaaauggaaagcaguaagauaacuucauuuguaag\n", + "cucucpapaguupaagcupuuggcupuugguagcuccuaccuacuguguggcaagaaggu\n", + "uugacugacaucuccgccccacaapccccuucucaccuggauccuaaagccuuccapccuccaaaguugcccucggcuugguacp\n", + "agauuuguccuucaaaccuuuuacagccaaupagcguggappcgagcpagapccauppapa\n", + "uacccauuggapcaaapuuapcgguguggcccccccuauuccauucguccccupuacagcagccpagccag\n", + "cuuguugaagaaucguggaaggaggaggaggaggcupcaucaucucucagccuggaggaggagacgccaugccpcupaucaccaugccccuugcccgucucgcaccuugcugcu\n", + "apcagucccagcuggcccaggcgccgcagcgcucccgapccgucgagcaaaggcpaggcgcagccpcugucgguggaccu\n", + "ggucaggccaggucgccgccugagcagaggcugcagccupcagucccpcuucugaggaggaacucuagcagacapccuggauaccucuugag\n", + "gupcugagacccpaggcuugapucggcugcuacccaugacpuupagguauuggugcgagcugagguggugcuugcggag\n", + "cccccauccuacacccaggcagcucguaacucucuuuccauccucucucucucucucucucugaaucucucucugcagaaaccacccaccuucacc\n", + "cccccauccuacacccaggcagcucguaacucucuuuccauccucucucucucucucucucugaaucucucucugcagaaaccacccaccuucaccaugucugacgaggaagu\n", + "ugauccguggaggcaguaacaggcgcggcgapagaagugauucccgaagaaucaaggcupccggacccgguggccuggcaacagg\n", + "guaauaagagaaaugaagccaacagguacagacccaaggaucuuaucuauagcugcugaaguugcaaaaagcccugagcagaaugucccuguuauacuguugaaguuaaaag\n", + "uacuacaaagugaucauuucuuacauuuacugcaagcugacaauguccaaauaggaucugcaguc\n", + "gcgucgcgacgcacgcugccccggaaggccgcggcgcuguagugcggcgupagccccagguucuuuaguggaagaacgcgaagcgaggaugag\n", + "ggccgcggcgcuguagugcggcgupagccccagguucuuuaguggaagaacgcgaagcgaggaugag\n", + "cgcgucgcgacgcacgcugccccggaaggccgcggcgcuguagugcggcgupagccccagguucuuuaguggaagaacgcgaagcgaggaugag\n", + "gccgcggcgcuguagugcggcgupagccccagguucuuuaguggaagaacgcgaagcgaggaugag\n", + "gcugaagaaaaagaugaauuacuacacuuuuuccaaauugugacugauucucucuucuggcuuuupaggccauguugaacuuauucagaaug\n", + "cgccuccaggccccuucccgcgucgcgacgcacgcugccccggaaggccgcggcgcuguagugcggcgupagccccagguucuuuaguggaagaacgcgaagcgaggaugag\n", + "accuccuuccccccccccgccacccgacaccuccuaauccuaaacuccuuauccaccccaacccuccpaaggcaggaguuugcacccuucgacacgccgcgugcaaag\n", + "capaucuauccucccuggccacaupccuuuggcugauggaaaggcupcuuugaggaagcugcauag\n", + "gagaguucuuuggaaggagagcgcgagcgapagcpcgagcuccgapugupuguapagagagagaaagagagcag\n", + "aaacuuucucugaucuccucucucucugugucugcuccaaauguagacagcaauugucupuaggaccagcuuauaaagaagc\n", + "gaguuucucugcacaagcucucuguuugccugcugucguccacauaagaugugacuugcuccugcuugccuuccuccaugauugugaggccuccccagccacguggaacu\n", + "guggcucucuaggaccggagaguucuuuggaaggagagcgcgagcgapagcpcgagcuccgapugupuguapagagagagaaagagagcag\n", + "apapccggccapuaggaaugcgcugcpcpcggcgcaggaggcgagcggcggaacau\n", + "gccccauaaaagcgacugucacucggucccagacaccagagcaagcucaagacccagcagupacagccagacagacggcacg\n", + "gaggccaaacuuccugcugaagcucuguggccucuuuupupcpuccaggcagaaagaaacugucugcugcucaagacccacaggacgccpaagacu\n", + "gucgucccauuccaccuacauccucgccuagucuccucccaucugcucagcugccuagcucccauaauccuccaccaguuagcugccag\n", + "uuacauccagcuuuuuaauugccuaagcggucupcuugcuucgucauuuggcuuugcuguggagcacuccuguaaagccagcugaauuguacaucgaagauccacccuuuug\n", + "guggcaaagugacaagugccaaaacucaggccugacuuuucugaaaacaucagcauucugccauaucuggaaua\n", + "augcuuuuccuucccagcuggagaaggccucagcugugucagacupacugcuggugauuuuucuguaguuagapaaacacaaaacgaagagcggcccacucccagcuuacgccg\n", + "uaggacuuugcuauaaaacacgugacccuapaaacuuuugaaguuagcgguauagagaguaccaccaccagacgccacc\n", + "gacuuugcuauaaaacacgugacccuapaaacuuuugaaguuagcgguauagagaguaccaccaccagacgccacc\n", + "cgcucccgcagcgcaguuaacguggacaagcupcaaccuggacgagcupcaaccugaucucggcugucggagupuguccucaagaaag\n", + "gagguacuccgcgaaugagaacauugagaauguguucggcauaacucauuucuuuguaucucccugcacucugugcupaaa\n", + "uuccugcucaccggupcuccpcacgcccggcapuccupcgcaggcaapacguaggcagagugcuccggccagc\n", + "agucguagcaagagucucgaccacugaauggaagaaaaggacuuuuaaccaccauuuugugacuuacagaaag\n", + "ggucucgcucugucacccaggcugcagugcaguggcgcaaucauggcuggcugcaaccucugccuccupcucaagugauccucccaccucagccucccag\n", + "aaucacgguggaaguaugauauuuuggcuguggaucugaguugaucaaucugcuuaguggacuugaguccccccacccccgcuugucugauupcuccupag\n", + "gagcggcuguuagugcgucgcagcugcuggcgauccggcgacccucggccggcaggacccgcpccacgcagccpccuucucaacgccucaguaccucggcpaccgcc\n", + "ggacugugagcggcuguuagugcgucgcagcugcuggcgauccggcgacccucggccggcaggacccgcpccacgcagccpccuucucaacgccucaguaccucggcpaccgcc\n", + "gcugcuggcgccuggcagccaccgccupagguuacuguaaggcccgcagcucccgccagcucccgcggacugcugccgccuccuuacc\n", + "gcuggcgccuggcagccaccgccupagguuacuguaaggcccgcagcucccgccagcucccgcggacugcugccgccuccuuacc\n", + "gcccggcuaaaagauggcugcuggcgccuggcagccaccgccupagguuacuguaaggcccgcagcucccgccagcucccgcggacugcugccgccuccuuacc\n", + "gugcccggcuaaaagauggcugcuggcgccuggcagccaccgccupagguuacuguaaggcccgcagcucccgccagcucccgcggacugcugccgccuccuuacc\n", + "gcccucuapuagaauccgccaagcuuugagagaaggcugugacugcugugcucupcgccagcucgcuccapagug\n", + "agacuccagaauuuguuugcccucuapuagaauccgccaagcuuugagagaaggcugugacugcugugcucupcgccagcucgcuccapagug\n", + "uccagaauuuguuugcccucuapuagaauccgccaagcuuugagagaaggcugugacugcugugcucupcgccagcucgcuccapagug\n", + "uggcacgaucucagcucacugcagccuccaccuccupuucaagugaucuucccaccucagccucccaaguagcupacuacag\n", + "ccgcccccgaaggcgagcugcgcugacagccggcggcpcupuguuugcaauacaaaggcggccacgcgcggcgccgcucg\n", + "guaacucugaagcgugagcugccagaauucaaggccaccugcuuaacagaagacaacuagaaaccucaucc\n", + "gucccccgagccccacpccaugcccggccggcccuaagcgcpccppcguccccuugcgcccpccccgcgcuggcgccccccpccgccgcccggcgcpcc\n", + "acagagucuugcucuguugccuaggcuggagugcaguggcaugauugcagcucacuguagccuucaccucccaagugcaagugauccucccacuucagccuccugagacupacuacag\n", + "ccugaacgacagagcaagaccaugucucaagaaagaagaagaagaaaaagauuacucaaaaugaaaaccugucaauuuucugagccupacucuccpuacauugaucuauauuag\n", + "uuugcuugccuaaacuggacuugaagcaauuuaaacuacuggagaucugccauuuuauaauaucacaauuggaaagaaacagauuuucaaaua\n", + "gugaggaugugccpugguccuuuccuccuccucuuccuccuccucccggcucccugccuagucuccauauaaaa\n", + "gacaaaagauccuucaucaccgaagugacguuuuagaaacagugguccugaucaacccuucugaugaagcagucagcaccgag\n", + "agacacagcucugcguccucgagcpacagauccaaguupagcagcucugcgugcpccucagaga\n", + "caacaccucuuccccaauuucaacucacaauuccauugcaaauguuccuuuaccuuugcuucauuuuucagaggacaugcagugaggag\n", + "uuagaucuugaccaucuuauaaaagauuauauccacuuuguacaucauuucuaaugaugccuucaaauacuacaaugauuccag\n", + "uuaccucccuggcucaaucauggagacauucugaucagcaguucucaaaaucugucuugcaucagaaucaucuppccuguuaaaacccccagcacaucagauuug\n", + "gguucuccuugaaggccacguagacauccuggcguucuuccccuapuguagcacacauggaauccagguggcccuagcucaccagaggacaguucaag\n", + "pcagauggccugucggagccagapcaucucucugaagcpucgcugugguggaagauuucuuugacaucaucuacucg\n", + "ccgcggcggcagcagcagcagcagcagcuggagcugupcugucaccgccgcccgccccgcucacucgcggaucccgaccgcccaucuccgccucgcuuccagcccag\n", + "gccaccaaguuguuacaugaaaucugcaguuucauaauuuccgupucpccpcpccaggcgcupcacggug\n", + "guuacaugaaaucugcaguuucauaauuuccgupucpccpcpccaggcgcupcacggug\n", + "acuuuugugauucgaucagauccuucugcgcucccagaguucaagcaggaguaagcaauuccuuugacgauauuupaaccucgcuauucaca\n", + "gacggagcucugguggccppaaagagcucuucuuaccaaauuacccgcucaucugauuuaauauuugcaaagauccuuuccuaag\n", + "ugccggcucggcggccgccpaggccgcgcgcaccugucccugcccgucucgcgccgcccgcggccgcucggacgcgcgcagagccgccccccgccgcugccgccgcgugcgcccgcgaac\n", + "cgacuguggcauugauguuugagcauacuucugaacuggcuuuuguugagacuaucaguauagaagc\n", + "gaagccpaagcaccgcagaaguagaagccpagccacagccuacguucucggaaaaagcaggcacuggaapaggccauugagcccggcacuagccggugugg\n", + "uuggagaccgugcuccucagucugcgguucccgcagauacagccgcugccccggaggupccagugcugcgaccucucuau\n", + "gacucacggcagcuguguucugauuucguacuacugcupcugccaccuccuccuccagacgcucucagcagacuugaguccugguccuucugcagaggccugagcag\n", + "gaggaagaggaggaggcccguuggcgucggaccaaugcugcaapugugaggagaggagccgcuguuuuucacugagcugccauaccccgaaag\n", + "caggauggagcuggagugagguggapccgcaagcugcugaccggcguguggaacacuggugguuugcagaucacugag\n", + "cagauuuaaagaguuucuuccuguuaauucgaagcucacugugccucuuguuuccgapaagaaggacugauuaagucaucuaa\n", + "acucggccuucupcgcgcgcgacgucaguuugaguucuguguucuccccgcccgugucccgcccgacccgcgcccgcg\n", + "uugacgucguccgagagucuuaaaauccugcucuggccggauuccagacucgupaaaggcug\n", + "aaaacuuaaagaacaagagaacugcauucaaauugagcuggaaaagaauauuuggacagucugugauugugagaguggaugagucuucuagcuaaaccu\n", + "uuuccaaggcaggaaagguaaagagacaaagaaagugccuuguacagaugcaaacggagguguagacugugcagcugccaaaguggugacaagcaauccagaggaccaugaaag\n", + "gcgcagucagauccgaggacauguugacgucguccgagagucuuaaaauccugcucuggccggauuccagacucgupaaaggcug\n", + "guugacgucguccgagagucuuaaaauccugcucuggccggauuccagacucgupaaaggcug\n", + "agccgcacucgccagcgacucaucucuccagcpuuuuuuuuuguuugucgugugcgauccucacacuc\n", + "ggagaccgagcgcgagcgaggcgcgcgcgcgcacacgcgcacucacggccccgcucgcuccgagauccccggccac\n", + "agucauacugcaccagcugagcaaugcauggaguggaccuguaggcgacuugcaucgucuucaac\n", + "ccgaguucagucauacugcaccagcugagcaaugcauggaguggaccuguaggcgacuugcaucgucuucaac\n", + "acgugcacauuuuuuguucucacucuaauaaugugauaaagcugaauuauuuccaauuuucugacgagagaggucaagagacuuguucaaggucuuuucucuug\n", + "agaccccuccugcgaggccapcuguggccauupaguuuguccccacggaccccuccucccccagapcacgccagucuugaag\n", + "cugaggcagagcucpcugucggupaccuugcaggapcaccccaagcccgcccggcccgcccaacccagccccugcgcgcagcccpccgaguaggaccccgcgcgccccucgcu\n", + "uauucuugccaugagaaaaagaaugugauaaguuauucaacuuaugaaauucaaguuacaugugaauucugccag\n", + "gupagcccguggccuuuaaagugccguucagccuuuuccuccapugcuuuguaaacacggcugugcucapcucgcpugaccgaaaggaucaugaacuagugaccuggaaag\n", + "gguacuagauggaaacuugagaaaggacugcuuauugauaacagcuaagguauuccuggaagcagaguaaauaaagcucauggcccaccagcuagaaag\n", + "upagcccguggccuuuaaagugccguucagccuuuuccuccapugcuuuguaaacacggcugugcucapcucgcpugaccgaaaggaucaugaacuagugaccuggaaag\n", + "gaugcccguccccucuacccgcccugccgaagacccgccuucuucuccuuaagccugacggaaucaccugacucggaggcgcucccucagaaggaag\n", + "gcuugaaccgcuggagcccccgapacgcpuucagagagcaagaggaaggaaccagacugacapucgccagaggcagucccagcacaaag\n", + "guucuccuuacuaugacaauguccgcccccucucuuacccugauucggaugcugugcugauuugcuuugacaucaguagaccagagacccuggacaguguccucaaaaag\n", + "auugagaaagaagaggauuggaaggccpcguauaaagccgcgcagagagcgugaaacaaagcagucggcucggaauuggacuupaggcgcg\n", + "gcagucggcucggaauuggacuupaggcgcggugaggagucaggcuuaaaacuuguuggapaguaaccagccugcuccucucgcucuccuccucgucugcgccgcguuucagag\n", + "gauaaaugagaaaaaggagagaguaauaggaagacaagcaagaaucacaaaaggaagcacgcuagguaauauacgauccucccag\n", + "agagccpugcacgcgccpagguagccaacagccguupacgcgacgcugguucccapagagccagccgcugccgcggcacugguucagacggccaggcccuapacccacc\n", + "gcgacgcugguucccapagagccagccgcugccgcggcacugguucagacggccaggcccuapacccacc\n", + "guupacgcgacgcugguucccapagagccagccgcugccgcggcacugguucagacggccaggcccuapacccacc\n", + "ggcggcggcggcggcggcggcggccpagaggccccuccuucacgcccugcuucucucccucgcucgcagucgagccgagccggcggacccgccupcuccgacccugcccaggcc\n", + "cuucacgcccugcuucucucccucgcucgcagucgagccgagccggcggacccgccupcuccgacccugcccaggcc\n", + "ucacgcccugcuucucucccucgcucgcagucgagccgagccggcggacccgccupcuccgacccugcccaggcc\n", + "gcggcggcggcggcggcggcggcggccpagaggccccuccuucacgcccugcuucucucccucgcucgcagucgagccgagccggcggacccgccupcuccgacccugcccaggcc\n", + "pcgaccuaggccgcpacccggacggagguagaggccapcagcgcguccpagcggaguccgcgcccgccgccgcc\n", + "aggccgcpacccggacggagguagaggccapcagcgcguccpagcggaguccgcgcccgccgccgcc\n", + "cpacccggacggagguagaggccapcagcgcguccpagcggaguccgcgcccgccgccgcc\n", + "guagcpcgaccuaggccgcpacccggacggagguagaggccapcagcgcguccpagcggaguccgcgcccgccgccgcc\n", + "agucuccauccccaggcuggagucuaguggcgcgauuuuggcucacuguaacuuccgccucuupuucaagcaauucuccugccucagccucccaaguaguupauuacag\n", + "gacucaguggccucugaggauguggcugugaacuucacacuugaggagupcuuugcuggauccuucccagaagaaacucuacagagaugug\n", + "ccaguggccccgguggcuccaccgcagcgucuggcgcgcupaccugcacaggccggagagagccguaggcaggaccccpacacccuggaagccaggaa\n", + "aauaagaaagccuugaguuuugugaaaaaccggagaagagaaacuaaaaggacaguagaaaaggcuuuuccaguuugcauaau\n", + "paguuucuggauucuuuauccggaauuucaapccgccggapcugucgcuucugcagugcguaggagcggccpcpaggcuccgcggagccgaggcguggag\n", + "gaucuuggcucauugcaaccuuagccucccagauucaagugauucucgugccucagccucccaaguagcupauuacag\n", + "auuuuaaguuucuuaaggauacggacucugccucagcagccuuuuucuugacaaugacuauccaaguuuuugguaccaagupuacucgccuuguugaaugaaaag\n", + "auucuuuauccggaauuucaapccgccggapcugucgcuucugcagugcguaggagcggccpcpaggcuccgcggagccgaggcguggag\n", + "cuuuauccggaauuucaapccgccggapcugucgcuucugcagugcguaggagcggccpcpaggcuccgcggagccgaggcguggag\n", + "ggagcgcuuuaggcuggccggcggcgcupagguggagucguugcuguugcuguuugugagccuguggcgcggcuucugupccggaaccuuaaag\n", + "uauuauuuuggcgacuucaauuugccacpacaaguuucuaaaggaacagauaaaacuggaugaaggcupuaccuuuggagaua\n", + "aucuucuuggagcgcuuuaggcuggccggcggcgcupagguggagucguugcuguugcuguuugugagccuguggcgcggcuucugupccggaaccuuaaag\n", + "gucacucggccgcgcgupcpagccggagcggcgaauguagcaagagcggaaucucccaaugugacagcgcp\n", + "acucggccgcgcgupcpagccggagcggcgaauguagcaagagcggaaucucccaaugugacagcgcp\n", + "uucucguuuuuguucuuaaaaccuguaguguaaccuauuugguguaaggaguuugaagcaaguaugaugaguuuuuacuuuuuuuuuuuuuuuuggcagguuaaacccauccagagua\n", + "acauuuccuuuucagcaucauguucagccagacacagacaagcuupaagaggauuuaauguuguuucuuccaacucuggaaacaauuccacuagaaggcucaauaguucag\n", + "auauauuggaugaacugaaaaaagaauaccaagaaauagaaaacuuagacaagaccaaaaucaagaaauagucaaccugauuucacauaaca\n", + "aaaguauauaggcaacaacagaacagcaauauauucuuucuugcagaccgaacagaaaugcugucugagagcaaga\n", + "guuuaauauaucuuugccaaguccaapuacaaagauuuucuccuguguuuucuucuagaaguuuuaucauuugauagucugugauccauuucaaguugauuugcuaucuggugugag\n", + "gcauucgcuucaagagacaagcaguuuagaaucaggcagaacuggauugcaaaauuuaupcagaccgguaugugugcag\n", + "gcuggagugcagugcuaugaucacagcugacugcagucuuaaccucccaggaucaagugauccucccaccucagccaucugauuaccupacugcag\n", + "gcgcgcucccggupcgcgccugcgcauuaugcuggucuccauggcpccucggagccaagacgag\n", + "acugcucugcgcgcucccggupcgcgccugcgcauuaugcuggucuccauggcpccucggagccaagacgag\n", + "gcauucgcuucaagagacaagcaguuuagaaucaggcagaacuggauugcaaaauuuaupcagaccg\n", + "ggacugcucugcgcgcucccggupcgcgccugcgcauuaugcuggucuccauggcpccucggagccaagacgag\n", + "acggagucuugcccuguugcccaggcuagagugccaaggcacgaucuuggcuuacugcaaccuccacuucccagauucaagcaguuuucgugccuuagucacuugaggagcucugguuacag\n", + "guggccgauagugguccuacugucgupacugcucugcgcgcucccggupcgcgccugcgcauuaugcuggucuccauggcpccucggagccaagacgag\n", + "gacgguggccgauagugguccuacugucgupacugcucugcgcgcucccggupcgcgccugcgcauuaugcuggucuccauggcpccucggagccaagacgag\n", + "aaaaaaacucuguguccuggcuacaucaaaaucuguupuggaucuuggacucagcacccapauucugauaag\n", + "cuupacaaagagcaagagcuguagagucuagcccupugaggaugccacggcuacccggcu\n", + "cuuucuuggacuccguacuguugguguaaccaaggccuggaggucupuggcucagguuuccugcagcc\n", + "agaugcauuuccuaguucacaaauuguguaaugauucuugucapcacacuuuucuuggcugcuuaccuagugccaagucgugugccuauugcuguaagacauacugagaugu\n", + "gaaccaaacaacaagaaauuguuguuucccgupaagaucuuggagcugcuucgcccagaccccaacacuggcaaaguacauacccuacucacuguggaaguauucgguguuauccggucacuc\n", + "gucccugucuugaggucuaauggcggacgccaguauguuggaguuggugguggcuuaaguuuugaapagguagcauccguuggauauccacaccauccuucucgcugcagg\n", + "gacuuuacuccpuggcggcgaggacgagucugugcuccaucagcugccgcacccgccgccucccgcccccaaaccccauccccgcgguugagccacg\n", + "gcgaggacgagucugugcuccaucagcugccgcacccgccgccucccgcccccaaaccccauccccgcgguugagccacg\n", + "acuaccugcacuuucccgcuuccuggcuuccccuacuggaacuguucccuccaccugaguugcccaccucucucccccgcugccuuugaaguccuucaagcccagcacaa\n", + "gagucugugcuccaucagcugccgcacccgccgccucccgcccccaaaccccauccccgcgguugagccacg\n", + "gaggugaagcauuccacagauaaucagcuacucuauucapaaggaguguaaacaucaccacuuuuugcauguuugcauaaaaaaggcccacugaaucaguuaaag\n", + "acgaggaagaggaggagaaagagaaagaagaggaagauguupcaacauuuauuuaacaugcuccacagcccggacccugg\n", + "agauccgagccpcuggcugcagagaaaccgcapagagccucacugcugagcgccccucgacggcggagcggcagcagccuccguggccuccagcauccgacaagaagcuucagcc\n", + "cuucaagaacccuacggagagucggacugcaucuccgcagcgagcucuuggagcgccgccggccpaggcgaagg\n", + "gcugauggaccccggccggucggcucagucucccuuuugcuuucaaacgaggccapcapcagaapuuuugacagccagap\n", + "uugugccagcagacgauccguggauccauuuuauuuucccugcuaggaguugcuguacauaacacugg\n", + "agacpuccuacauugccuaggcuugucucgaacuccaaaguucaagugaucugccugccuuggccucucaaagugcupauuauag\n", + "acaaaaucucgcccugucacccaggcuggaguacaauggcaugaucuugguucauugcagccuccaucucccagguucaagugauucuccugucucagccucccaaguagcupauuacag\n", + "gacagagccacagapcugugagcuugcccggccccagguaacgcuggcggupupccuccagcuuggagcagagaccccccgaggcaucugcagacagaacuggauggaccc\n", + "acagapcugugagcuugcccggccccagguaacgcuggcggupupccuccagcuuggagcagagaccccccgaggcaucugcagacagaacuggauggaccc\n", + "agguaacgcuggcggupupccuccagcuuggagcagagaccccccgaggcaucugcagacagaacuggauggaccc\n", + "gagaagaaggaggaagcapuggcggcugcugcggcgguugcggcpccpupcgccgcgguccpccpcagugaggcgcpcggccg\n", + "gucaauuucccaaggaucuucauaaguaauauugugaaaugaagcccuggaccupaaccugaauuugccagcuaaguuucccaaguagacuauaugucugagugaauaa\n", + "caggaagcuagcagaguuugcuucugagacgaauucuguuacaguacauggcauuuaugaggaucaauguaauu\n", + "aaaguaggccaguauugccagagaacaggagaggaggagaguaugguauaagcauguccagaaau\n", + "gaaacucguuuguacuggcagaugcuauaagaagagagcccugacuggaaauaagcuagguucagguguguuggccag\n", + "gcaccucpccgcgccgcccagcugcugacagccucccggcgcgccgguccaugcuggucccggucuuuguucupccggcgccgagacaugcgcggcugacg\n", + "aaucaccacuucacaucuguaagcagagcgcuggcuaacucuguggcuuaagcagaggucagaacaucugaagugaucugcagauauccug\n", + "aauppcuccaguuggccupacacggcupcaggccagaggccuccacaguggauguaggaucccugcucccccccag\n", + "acgccuguggauuggcugauggagcugugagccggcuguaguugagcpaacccgagaccuggcagucgcc\n", + "agaacgagcggcccuagguuuucggaapaggaucapauguuugcgagcggcuggaaccagacggugccgauagaggaagcpcucc\n", + "agaaagaugcugguuucgaguuuuggagauccuuguuuuuuauggaacacaguucuguaaaauuuucauaagauuccuuggcaauaacauacgcuugug\n", + "aggcaguccucgauccgcucgccgcgauccggcggaggaggaggagcagapaggcgagccgcagcgcugcggcgaggagcccapag\n", + "gucugucggcgcccgccguucucguggucgccgucgccgucgucguggugguagucuccgccgucgccupcc\n", + "gugaccggaggcgagaaaccccgccucggcacccugacgcagcgcaggacccgccccgcgcgugacgccagcgucaggccagccccggc\n", + "agucagagguuccgguugagaucaaguupagacacacccuuguucauucuccuugagaagcagcuauuaucaacagaacauugacagaaccuguguuupaaaggacug\n", + "uucuuaauggaauccaagccucuaagccucacaguccaggcccuccaccagccugccucacccuauccucauuucaucucccgcaaccuggcuccg\n", + "agucuagupauaccaggcccugagagaccccuacgaucccaggacacugaugupuaacuaacacccacuggaagucuacgcugaguucacaggcuau\n", + "aucucupaaagguaaaaagcgcucaccgacucuggcccuccpagaccccguaaaugcagccguccgcucgccgccguuaucccag\n", + "agcgucccgcccuccucccgcggagucagupugapucpcuugaagccauagcugcpaccguacucgucucccccgacgcagacc\n", + "auacugcgccggacagacccaguugccuggugcugcggcccggcgupccucgupcagagccagagccagagcc\n", + "ucuagaugcupaaguccaagaucapugccggcauggucaguuccuggcgaagccucucuucuagguuucagacugcccucuucuuuguuguguccucgaauggcagaaaaagg\n", + "gguggcuguuggaggaapaggagaguaaaugaagagaaagaacuggaauaaccccuugcagaaaaaaaaaaaaagg\n", + "caagcuuagcuguacacccugagucuugcaaaagcugcagccccacccaggagcapugguggcupcgaugguggacgcccugaagauguccc\n", + "gaagcaagcuuagcuguacacccugagucuugcaaaagcugcagccccacccaggagcapugguggcupcgaugguggacgcccugaagauguccc\n", + "caagaucapugccggcauggucaguuccuggcgaagccucucuucuagguuucagacugcccucuucuuuguuguguccucgaauggcagaaaaagg\n", + "accugagaapaagcagapugcgguggaaacggcugugucapacagcapaaggaagauagccaaggcuuacugaggcugguggapagccacugcupcucacc\n", + "pcugugaaacpauuguacuaucacuggcuggucugagcccuuuccaccuuacccuguggccugcccugugccucuggagcugcuggcugaggag\n", + "gaaucuuacuucuccacagugaagauuaucuacaccgupccauagcaucucuauuguagcccucuucguggccaucaccauccugguugcucucag\n", + "gaggcuccacugcccccggaacuacguccacacccagcuguucaccacuuuuauccucaaggcpagcuguguuccugaagg\n", + "ccccaccggcucccgcgcgccuccccucgcgcccgagcuucgagccaagcagcguccupagcgcguc\n", + "aacuuuccccccucggcgccccaccggcucccgcgcgccuccccucgcgcccgagcuucgagccaagcagcguccupagcgcguc\n", + "cacaaggacgaauccaagccaguuaaaugcgguugaauuucugupacccagcaaaacgcaccucugcuuucauucag\n", + "gacgcgccagcggagcuccggcuccuucgcccuggacgcggaggccgcggugugcpcgacggcgaggccggaag\n", + "agaacuggcaucccgagaagccaggaagcagugagcccaggaguccucggccagcccugccugcccaccaggagg\n", + "ucccgagaagccaggaagcagugagcccaggaguccucggccagcccugccugcccaccaggagg\n", + "agagaaccuagagcccaagguucagagucacccaucucagcaagcccagaaguaucugcaauaucuacg\n", + "uugcagucagauguuggcupaccacagucaucuaaggauacugcucaagcuggcuguugucuggaaacucagcupcuacugaucagagcaccugc\n", + "gcauuuuccccaauacaucucugcucaucugacucuuaucuuggcaucugcuuccugguggaucugaacugacccauaagccacgcuuacuagugauuuuccag\n", + "cagguagugcccgcuggagcucgcgcgcucauccggcaccacuccapcuccaggcuccucpcuuccggagucgagacgug\n", + "ucccgcagcguggacaagcagcaugccgucaucaacuacgaccaggacapacgagcacupugaaggaccupcagccucaaup\n", + "aaucgccaaggaccgccgccugccugagcagcccpugucugugccuccggagcccgagaaccupacccaggccagccagag\n", + "cugucaaccccacacgccuuuggcacaaugaagupuaaccuuuauuucccuucuuuuucucuuuagcucggcuuauuccapuguguuucgucgagaugcac\n", + "gguguugauugccuuugcucaguaucuucagcaguguccauuugaagaucauguaaaauuagugaaugaaguaacugaauuugcaaaaacauguguugcug\n", + "aguauauuagugcuaauuucccuccguuuguccuagcuuuucucuucugucaaccccacacgccuuuggcaca\n", + "aaagapacaaguggcuggugcuguggacagagaagcuuuauuuuuaguaugagacaaccucuauuuucuuucaggagapaaguuggauuaucaauucuuuuguaa\n", + "auaaaaagapacaaguggcuggugcuguggacagagaagcuuuauuuuuaguaugagacaaccucuauuuucuuucaggagapaaguuggauuaucaauucuuuuguaa\n", + "gcuucauaaaaagapacaaguggcuggugcuguggacagagaagcuuuauuuuuaguaugagacaaccucuauuuucuuucaggagapaaguuggauuaucaauucuuuuguaa\n", + "uggagapcgcapacccgcapagcccaggcuuaacgugcauucugcgguucucucccccaccucccgccugcccgcgcaggugccgccgccggacpacuuuaag\n", + "cauacaggccaaaagucuccaagucccugcuaacuucuugcucucgcaacagaauaccuauuuaggupaagaaugaggugupcggcaggcugg\n", + "gugccgccgccggacpacuuuaagaugaaguuaupaugucguggcugucugccuggugcugcuccacaccgcguccgccuucccgcugcccgccg\n", + "ggcacaggaagaugacuugaugauuuaagagaagauugaugacggucauuucaaauguagccgagacauucagccaagag\n", + "uagcccacaccuugacaguacauucagucacuggaugauuuuguauugaagucuguaaguucaagaacuaaaacaauccaaaacggcuacuacaggugaaguugagagca\n", + "aucugaacagaauuaagacgaacgagcuuucacaauugcagcagaugaagauccauugguaaauugaucaggauuuuuggccuacccuccaaagaaaag\n", + "gcuggagcgcaguggcacaaucguggcuuacugcagcguugaccuccuggccucaagcaguccucccacugcagcuucucaagaagccpauacag\n", + "gacuccucccgcuuccgcugccgcagccggucguaaccaaguuguguccugucagccgcuguccccuucgccgcg\n", + "gaaacugagaaccagcucucccgaagccgcpucuccggccggcggcggcggcggcggcggcggcggcgcag\n", + "apaaggcggaguccaapaaaacgaaacugagaaccagcucucccgaagccgcpucuccggccggcggcggcggcggcggcggcggcggcgcag\n", + "guuugcuucucuggcggucuucagaaucaacauccacacuuccgugauuaucugcgugcauuuuggacaaagcuuccaaccag\n", + "auagcucucgcugccaccgcugcugccacuaucgcugucacugucgcugcugccucuguccagcugaa\n", + "gagccgcugcugccgccgccgccgcgcagccccacaucaacgcaccpuccugucaccgccaccgccaaaaaagucaccgccgcuapucgccguugcaucggugcapcaag\n", + "gguguccuccauacaccggccguuuucuggagcccuugccaucuucugccupcuupcacaugaggauggagagagccccccucacggcucugcuacacccgguauccccag\n", + "uggcggcggcggaggcpaucccgcggcugcggcgacgguggccgcgguggagccacpcpcuuggcuuggugugacggcggcugcggcggcgguggcggccgcgaccag\n", + "cuacgagaguacaagguagupucgcugccugcccacccccaaaugccacacgccgccccucuaccgc\n", + "gucagugcaggagcccagccgcugagccaugccpccccpcggccugcagcgagcccaaccccugcacccagguaguc\n", + "aucucaaapacaggaaaggcagcagcagccacccucucucccagucaaguggucaccagcaggacugaapacagccccuuugcaguggcucggcgaggagaccccugcacccuagg\n", + "ggacacccggacucuggcugcgcccgcupacccacaacaggcccacaugucccagaaguuucugcugugugcugaucugguugugguacccggaagccccugg\n", + "cacgcccuugcccggccgugcacuugucuucgcgcucpcapcgcapacuccggcugcggcggccgacuccggccg\n", + "capacacccggacucuggcugcgcccgcupacccacaacaggcccacaugucccagaaguuucugcugugugcugaucugguugugguacccggaagccccugg\n", + "gaggaacacgguggucugagcuggagccacgcuuucuguuggapcagcugaaggagaacagcaagacauauccggcggcccuacggacucggagagcuggapaccccggag\n", + "auaccpagaccacgacgcugccuccupcgccaugaguuccuguucagcuuccagcugccccc\n", + "gcaccucaagcpcucpaaaagguugcccgauccugguacuguaaccguggccuagucucccuuucggccaagaucgaccgcaapcuacaccccag\n", + "gagaggucaucccugucuuugccgagaucgacaacggcuccacacguccugugcugccucpcagccguggugcagacacagacguuc\n", + "gccuggaacagucauaggcucucuggcccucaacupcgagagucccccgccccaaaucpcuggacaugccucgagucacgucaacgapcggcug\n", + "gcuuggcggaggcpaaggcccgcaggcggcgccucagccpuuggcgcugapagapcpaaaagguggcgaauugapaaagupapcpaaapcggucggaac\n", + "acccggcgcuccauuaaauagccguagacggaacuucgccuuucucucggccuuagcgccauuuuuuugg\n", + "ugccpapuggccgaguggacgcuucucpaguccggccccuccccagcgccuaagaaggccggucapaggaggaacaggag\n", + "gaaauggagguguucugaccuaugaucagacaagguaggucagaaaccagcuccagaaaccaggaaaaaguuccugccuupagagaaagaaauaggugaaaggapcagaaaag\n", + "gagcccugccuguuuugcucguuguugccucacuagcccauaccagagugcapugcgcuguaagccgugaccgcaucacagaucaucagcaugcagag\n", + "gucuuuaagugcguuugugcagccgauuucaaggcuaagagagaaagacugccucugaucccugaag\n", + "aguugcagucugguaguugucgcuggccgugugacggcucgcuguugcccugaaggcaggcgagccagcugcccaggaaagguggaaagugguagaagcugaccccugagcccuggcag\n", + "gagcucaagaagcagagagucuaccugcccgacgcguucguggagaggagcagcgguugcuguuggaggag\n", + "aaacaggaaaaguaaggcagcguuggacuupcupapcuuaaggccagacagacguuuucauccugauccugugaccugcccuauucaucug\n", + "ucggccpcupccaggcugcaggcgupaapcgucuccpagccccpcugugcapaggccgapcgaccccgcug\n", + "guagcuggugucacuucggugugguuggaagaagacuuucuccccagcugcauucccggaggcgcccuuucgaccuggaggccp\n", + "ucugcuggccacapcugccgcacuggcupacugccagcupccuggagacgcugguggcuguggacuccccagcuuggagcagucccucuuug\n", + "ggacccgcccucaaguucuggacaccccpugaagacuguuaacgcggcpauupcgccugcggcagcuugupcgguacccgapagaguucgaguuuuuauug\n", + "gcuggagugcaauggugcgaucucggcucacugcaaccuccgccucccpuucaagugauucuccugucuccupuucaa\n", + "uuuguugugagcugcggcagagacugguggcuggaggagacgccggcgcuggagagugcgcugcgccgcccgccgcugapaccgcpuuagccacugcuggcugcuuccaguguucgccgagag\n", + "gaagcccpagugcgaccgccucaaauccagccuucuuguuuggupacgaccgucgguucuguccpaggaaugacpucaag\n", + "guugugagcugcggcagagacugguggcuggaggagacgccggcgcuggagagugcgcugcgccgcccgccgcugapaccgcpuuagccacugcuggcugcuuccaguguucgccgagag\n", + "ggcugcgcuucggucccggacccpccacccacpuagupugcuccucggccccggacauugcaagccccagaag\n", + "ggcagcgcucuccuaagcucucgcggcugcgcuucggucccggacccpccacccacpuagupugcuccucggccccggacauugcaagccccagaag\n", + "aaacaccauuuuccugupuagaggugaugcagugcugaagaccupccccugcucagugccuuugcucu\n", + "auguugaaguugcuuuuaaacacagcuuuucugcuuuaccuguccagguagccucuguuuucauuucagucuuaaugaaaacuuucuaacuuauaucucaaguuucuuuucaaagcagu\n", + "uuuucugaguuuaaccaguaaugccauucaguugccaaucucaagcaaagcaaacauaagccaguuuuaaucuacuuuuuaagaaaagugguaguccuuuucacagugccugacg\n", + "uguggcagaccuuaagcaugccauucaaagcaaauacaagauugcuauucaacaccaggugcugguggucaauggaggagaaugc\n", + "ccccccagagcacagcugugucugcucccagacuaupcuccuugapcaggaccugguuupucccagagcagccapuuug\n", + "accuugccucugugugcucacagccccccagagcacagcugugucugcucccagacuaupcuccuugapcaggaccugguuupucccagagcagccapuuug\n", + "ugcapacuucacagcccacacpcuacgaggugcugcugcagcggcuucuggauggcaggaag\n", + "gccuggaaauccacgcggauucccggagacggcgccucugcucugcpuucguggcgaggaaguccacccacugcucccpcgcaggucugcagguccgcgcccacugcccgcggcgccacugacc\n", + "agugcgccgagccapcaccgagugcupaauacaggccguccaggcgcggcpcgcpagacggaggcugccgga\n", + "uaguagaaaacgaaauccaagcaagcauagaccagauauucagccgucuagaacgucuggagauuuuguccagcaaggagcccccuaacaaaaggcaaaaugccagacu\n", + "ggaaaccggaappcugugaggacguguuccgaggaagccagagccggagccguggccugcpccggcgac\n", + "gaggacguguuccgaggaagccagagccggagccguggccugcpccggcgacauggauccccuguuccagcaaacgcacaa\n", + "gcgacauggauccccuguuccagcaaacgcacaagugapccggucpagcpcapcuagacgaggcgaggccag\n", + "ppcugugaggacguguuccgaggaagccagagccggagccguggccugcpccggcgac\n", + "gccggcapapapuccugcgaccggaagccggaaaccggaappcugugaggacguguuccgaggaagccagagccggagccguggccugcpccggcgac\n", + "aaccggaappcugugaggacguguuccgaggaagccagagccggagccguggccugcpccggcgac\n", + "gcagguccacgagauccagucuugcaupacgccuggagacggcagacaagcagucugugcaca\n", + "gguucaucuauauuguagccuguuaccagaauuucauucuguuuuaugacggaauaauauuccguuuu\n", + "gcccuggccggcapapapuccugcgaccggaagccggaaaccggaappcugugaggacguguuccgaggaagccagagccggagccguggccugcpccggcgac\n", + "agagccggagccguggccugcpccggcgacauggauccccuguuccagcaaacgcacaagugapccggucpagcpcapcuagacgaggcgaggccag\n", + "guuccgaggaagccagagccggagccguggccugcpccggcgacauggauccccuguuccagcaaacgcacaagugapccggucpagcpcapcuagacgaggcgaggccag\n", + "gaguuugaagacuggcpaagauguccgcagcuguugccaggccapuucucccgagapaggacgcupacuguggcuugcccugaucggccgagaagaguuugcc\n", + "uuagugcgcaagaagcacauguuguccugcuuccaagaugcccuugugaggcauaccucccuggucacgcaacuggugucucaggaucagagagucugcauccacuucauaagugugcuuuuug\n", + "uccuuauucagaucacaacgcagcugaagcuggagcagacuauccguugccugcuggaugagugccacaaagag\n", + "cuguguaacaugcccuccaugcgaggcagccuggccacccugacccuucuuggcaaguugguggaugccaucccugcucuggcagacgagcuuguaauggagcaug\n", + "aggacuugaguugccuugucugguauccuuaugcagaaugaacugaaauaaucaucaaucugaaaagcuacucuuaaacag\n", + "gacuugaguugccuugucugguauccuuaugcagaaugaacugaaauaaucaucaaucugaaaagcuacucuuaaacag\n", + "ucuuuagaggaaccagacuagcauuucucagupuuccaguaugcagccgauugauaccugugucuccuacccaaggacapacapcucugucucgcacuucccag\n", + "caaaaggaggacguagaaaapacaccggaaacucacucuucacccggaaaugguuauugaggaac\n", + "agacgguaaagaacagguccaagaaaagcucaaagaaagcaaauaccagcagcagcaguagcaacagcagcaaguugccaccaguuuguuaugaaauaauuaccuugaagacuaaaaagaagaag\n", + "ugcgugcpugcccgccgagcccgccpcgcuggaucuccgagugccccggccpccugaggagcpcacapcaaggcggcggacggcugcgucgcccgaggcgaggaggagcgcuggcg\n", + "ggagguggcggagguccaggcapcgcggucpaagccucggcgccuagcagguggcpccgcgccccucucccpaggcgcgcggupaagcggagcaaacuuccccuaa\n", + "aagugacapuugucuaupccauagaaaaupaaccuuuuauuuguccuuagcuuuauuaaaa\n", + "gagugccccggccpccugaggagcpcacapcaaggcggcggacggcugcgucgcccgaggcgaggaggagcgcuggcg\n", + "ggcapagucagcagaggccucgcucpcgcccagugguccugccgccuggucucaccucgcu\n", + "ggucacguguguacacapcccpcggcgugcgcgccgugagccccgccgccuccgccagcccgagcugcccgcccggcggcgacugcgccggccgccgcccagcaagccg\n", + "aaaaugaagaugguaaccaggcaacaugguucuucuauaguuauuaaaaauaaaacgugaagcuucuacaaugcacaauaauuuucugacaaguuugucuggcuuucuuucugucauugccuggagaa\n", + "gaaacauccaugucugauuagcaugaagguuaugaggagaacgugaucacagccaagguagucuucucaaaaag\n", + "aucccccagauuaguuaugcaucaacggcacccgagcuaagugaugaccggcgcuaugacuucuucucucgcguggugccacccgauuccuuccaagcccaggcc\n", + "ggagccgagcggcgugcagaggcuacaagugccguagcuggugauupacuuucuccpaaccgugccpagagcgcgcggugcuggagccgcaccpuggccgaagcagaag\n", + "aguucugugcguguucacuguuuaguaguacucaaaacugccagugugagaggauuuggaaaucacuggaucugcucaauacaaaa\n", + "acuguuuaguaguacucaaaacugccagugugagaggauuuggaaaucacuggaucugcucaauacaaaa\n", + "agaaucaguucuugcuguagguaapaaugcuguguuuauaaagcaaaugacauggcaacuggaucuugaaggaugaguuag\n", + "gugcguguucacuguuuaguaguacucaaaacugccagugugagaggauuuggaaaucacuggaucugcucaauacaaaa\n", + "aaggagaaucaguucuugcuguagguaapaaugcuguguuuauaaagcaaaugacauggcaacuggaucuugaaggaugaguuag\n", + "aggcaguucugugcguguucacuguuuaguaguacucaaaacugccagugugagaggauuuggaaaucacuggaucugcucaauacaaaa\n", + "ggcccuuccagagaaauguacugaaaaagucuacgcaaugucupauuugcuaaacaauaccuggaaagcagacag\n", + "ucuaggucuuuuugccauuccuccaggacauccaccauaaggaaaggagacccuggaccaacauucucuaag\n", + "aaaucccucugugcuguuuugagugaaacapaaccagcguccgccaucugacaguuccuccaggucuuuuaag\n", + "gcucuupucgucucaugagacccapcauguuggaaagaacugagagaaagagcaacaaagcggcgaguggugugagapcagcacgcgcugugg\n", + "agagugaaacucacccagcuuuaguaaccaacucgauugcauagacuuuagauaaccaugugaap\n", + "acugcaagcaguggcgccggcucacgcaccccucggccgccucucgcgcggcuucccgcgccggcagcccgcgauggccccacgugaccgcgugucug\n", + "uapacaagccugagcgucacaggcuccccacaaacaaccgcgugacccpacuuuccccapugugcaaaagcacaggcacccccucaguucupugaag\n", + "acaguucgcaguugugacucuguaggcggaagcauapacaagccugagcgucacaggcuccccacaaacaaccgcgugacccpacuuuccccagg\n", + "agapagcgcagccgagccpcgcaccagcpacggcgcapccapcgcugagaggacpccacupccgcccgcgcuggccgcg\n", + "auaaggaaccugauuaagugucgaguaguguacucagcaccapuaaagauggcagacacaguccc\n", + "guuucaagaguaaaggagaacaaaguapugaccuagucugaaggacaggcgcagaacagucaguggaacagccagagauagcagcgagagaggugagaagaggaccaggaguaggugguaga\n", + "gucgaguuugaguggcugaggcaguuuugguuucaaggcaaucgauacagaaagugcacugacugguggugucaaccc\n", + "agapagaauagcuccagacpagcaggacgcugagagaacuacaugcaggaggcpuccapcgapaucuacgcagcuugcgguggcgaaggcggcuuuaguggcagc\n", + "uaccuggugcagagcuugagucuggccagcpucaggcucuugcuagaucagcaccggagguggaagacug\n", + "agugacgcuccggagccgucgccapugguaauaccuggugcagagcuugagucuggccagcpucaggcucuugcuagaucagcaccggagguggaagacug\n", + "cuccggagccgucgccapugguaauaccuggugcagagcuugagucuggccagcpucaggcucuugcuagaucagcaccggagguggaagacug\n", + "cuuuccaaccucgaauucugcucagcucgcuuuggcagcuuggupcggupcgcpuggcggaggcgauugaagcugcuggcccagc\n", + "agccucacucugucacccagguuggaguacaguggaacagucucagcucacugcaacuuccgucuuccaggcucaagugauccucccuccucagccuccugaguagcuggacuacag\n", + "uauguaaagaauucuugaaccgauucuacaagucacugauagacagaggaguuaacuuuucgcuggacacuauagagaaagaauugaucaguuuuugcuuggacaccaaaggaaaagaaaaccgccug\n", + "acuucccagcaaccauccauuggucuucaccaguaguucugcagupaucugcacuucupcuucagcacacaucagugugguucacguguuuccugcuguuaugaaagagauuggagag\n", + "aaccauccauuggucuucaccaguaguucugcagupaucugcacuucupcuucagcacacaucagugugguucacguguuuccugcuguuaugaaagagauuggagaggugag\n", + "aaacuggaagugaguccacacuuccauuguagcccguccagacugcuguggacuggcagugcacupacguacagagcugccgupcacgucag\n", + "gcacuucupcuucagcacacaucagugugguucacguguuuccugcuguuaugaaagagauuggagag\n", + "aauuuugauuuggcugcupcugcuaccuugaaauccaagcccuaaaaaugccagcuucuuuggacuuagaagaugaccuggauaaaugauaaaaauuaagaaagagauuuug\n", + "guccupaggaauggagapucccacugacuaacuuuucugagaguggucagagaguucuuaagcag\n", + "ucuccugccaugcaaagaaggcucauagaguugcuuuggaaguggauucuuuguacagccuggaagaagacgcugu\n", + "ggacgcguaucccacgugugaggugguugaugugcagcugugcuacaacguggccaaacugaucuaccugugcaaggagaa\n", + "aaagaagacugagaagagccugaccuauuacacaaaccugcaggugaagacaggccagcggacccucaucaaccccaagcccuguggccaguuuugcugcugugaagugcupcugugagugg\n", + "gccuuuggcucugccagcacuggupaaccugcaagaaauuugagcccugaacgucugccuuguccuguuguccugugcuccapaagacaggcgcg\n", + "aguuucacuuuguaacuuuuaaguggucggaacacgccccgcgcugcupucccgccagacacgccgccgccgcag\n", + "ugugcuucuacugcuuuacupacuaugugacuuuuaugcuuuuauguuucagauuupaaccaaucc\n", + "ggcucuggacuagacuuucaggaucuaaggcugaauccuacacaguccucccucupaaagugaugaaaccugugagcucuccuagcaacucugcagucuuccuucaag\n", + "agacucaccucugacgccgcucuucgcgcuccgcuggugaauggagucgcguucucuguuuugcuguugcugcugccuuugugacpaucgcuuucucccaucgaaccuucuaguugcuuauugcag\n", + "gaaacauuaaagaaugugcuucagagagaaaggaaaugaaaccaaauggaaaucuggaucuacacaaacgaguaaacagcacuggcgaaugguaacuaccuag\n", + "gcaaugaguagacagacauucucapcuguagaggauaugaaaaagaggaauauacuuupaugcgauuagaagupuacaaaagauaaauaaccaucucucucaucuggcagagguaaagu\n", + "pcpcucacgcgaggcgcuggaacgguccpagauucucgcucugcugcuuuagcuucggaguguuuggcg\n", + "ggaagaaggccccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "ggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccucauggcggaggugaaggugaaggugcagccgccugacgcggauccggucgaaauagaaaacag\n", + "ggucaguuggaucucuuaaggagcaauacpccuuuuauauagaauaaaggacucucagaaugcugg\n", + "acgaggaagaaggccccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "gaagaaggccccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "gcgacacgaggaagaaggccccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "aggccccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "ggccccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "cccucggccucagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "cagcagagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "agagcgcuauccuccacugguuccccpuuccccggcuugcuaccpcugcuccgugcaucuuuccccccaggcgucaggaacugcgcccuc\n", + "cagguggcagccaagagccuccuggcacagcggcaccaggcaggugacgccuauuggaccccagag\n", + "augucuacggaugaggaaacugaggccuggagagguuaaagagacccguucagaguccuacaguggcagguaauggagccaguacuuugacagcagguugcaaa\n", + "agacpuuuugccauguugccuaggcuugucuugaucuccucggcucaagcaguccgccugccucugcugcccagaguuuacag\n", + "gucucucgcugcaucuggagcucuaggucgccucuucgcuacucuguguccucugcuccuagaggcccacccucuguggcccuguguccuguagguauupagauccacagccaag\n", + "cuggagcucuaggucgccucuucgcuacucuguguccucugcuccuagaggcccacccucuguggcccuguguccuguagguauupagauccacagccaag\n", + "cccgcpcggucgcggccgugacggcggcuccpcccggcuccccuuccgcgcccggcuccccuuccgcgccccucccgccggagaugapaag\n", + "aucugccauaugacccuuccagucccaggcuucugaagagacgugguaagugcggugcaguuuucaacugaccucuggacgcagaacuucagcc\n", + "acacuuuguauggcaaguggaaccacuggcuugguggauuuugcuagauuuuucugauuuuuaaacuccugaaaaauaucccagauaacuguc\n", + "cauaaccugccuuugcugguguguggcgauuaggccugguggaaccaccaucaauaaaucaagcgugaucagg\n", + "cuacugccuuccucaucaacaaagugccccuuccuguugacaaguuggcaccuuuaccucuggacaacauucuucccuuu\n", + "acauuaggaaugccuuuuagugccuugcuuccugaacuagcucacaguagcccggcggcccapcaauccgaccacauuucacucucaccgcuguaggaauccag\n", + "uuuuagugccuugcuuccugaacuagcucacaguagcccggcggcccapcaauccgaccacauuucacucucaccgcuguaggaauccag\n", + "cauuguugcaaaacauaaggaguuggapaccagccaggcuucagcugaauaccaaguuuugcagauugugucggca\n", + "gugcgcccuuccccgcgcgcggccccuccugcupcupucuguggcugacguccgcuuuucccggaacggcaaag\n", + "agaagucauucagaauucaaaagaaguucuaaguuuauugcaagaaaaaaacccugccuucaagccgguucuugcaauuauccag\n", + "gaggaagcgccagguccuucccgccgccgccgccgccgccgccgccugcuccccuggcacgcgccccgccgcccucggcagccgcagcuccguguccccugagaaccagccgucccgcgcc\n", + "uccuucccgccgccgccgccgccgccgccgccugcuccccuggcacgcgccccgccgcccucggcagccgcagcuccguguccccugagaaccagccgucccgcgcc\n", + "gcggcccggccgaccucgcpcuupccupcpcaccgacggagcggcccuggcugcagccucccggcgccagcgaagacag\n", + "gcguuccuugcggcccggccgaccucgcpcuupccupcpcaccgacggagcggcccuggcugcagccucccggcgccagcgaagacag\n", + "acuucuugcugccucacgguugcuguugcagacccaggagucucugaaggcuuccgcggcuuupccgguugugag\n", + "gcugccucacgguugcuguugcagacccaggagucucugaaggcuuccgcggcuuupccgguugugag\n", + "gaggcggugcugagaggcgcguacugugcuugcuuuuugcaguaccugcugcggccgcuuucggc\n", + "agcgcgcgccccuccuuucccucccpcacugacacuguucucuugcuugcuguuuguucuuugcappcuauuuccuapcgccgaucaagaauacagugcauuucgaguap\n", + "agapuccgccauguuccccggcggcgccgccgcuuggcucugguagccgccgcccccgcccccaaccccgcccggcccagagccuagccgagccccpcccagc\n", + "gacuugaacgcaacucccaauugcagaaaauuggcaacgucucugaagagcccuugcuuuugccuggacccccagcauc\n", + "cagucgcpccgccggccgugcuguucccgccaauuccugugguaauccuuaccguggcgaguuccgcgcuca\n", + "gcagucgcpccgccggccgugcuguucccgccaauuccugugguaauccuuaccguggcgaguuccgcgcuca\n", + "gccgagccgcgccgagccgcgccgaucgccauccggccucggcacucgcgcgcgaucccggccggcggcgcggcccggcpccaggcggcgccacagccc\n", + "gauuggucccgcccccguacuucuuugagcgaguccccagcuppcpaaaaaaugaagaggaagacuaaupaagacggcgcpagcuucugcccggugauuggucaaaugag\n", + "accaaucacagcucapcgugauugucucguccupaucgcgagapuauauacapaggccaggcagccuggaguuagccgaccguugcgagacguugagcugcggaag\n", + "auguggacacupagaaggaagugagauggaaaaguucuuugauugcauccaagaagugaaugguccucaag\n", + "guaacaacucucagaggagcauugcccgucagacagcaacucagagaauaaccagagaacaaccag\n", + "guugugcccgcuuuccuacucagugcaauuguuccagguuugcaggucccagguuccaagacuuugcggucuucuuuuguucacuuggaaccgauaucuuuuggaggug\n", + "capaagcuccagcugucccucccgcaguuggcccugugguguuccgaagccgguuacguacggccugapccaggcgaaccucaggcucuuuguccuacuaaaaagcgcag\n", + "acuuccgguuugucguugcuauaggaaccgcuacggcguuugaaaguguccpuugcuuaggaucccuacagguagcgccucuggauacaugcguggucugcugacccagagagaaacgaaag\n", + "cgccaccupcgcgcggagcuuugcucguuuacuauugaaaaaguuccagcgcpaaacugaacccggagcuuugcgcacgcccgagcccucaaguaau\n", + "caggucucugaggcugugguugcuacapucaccacgagcuuggcuuacuugucucauccuucccuugccugguaucauuuucucaguucucccaaaagcc\n", + "ccupcgcgcggagcuuugcucguuuacuauugaaaaaguuccagcgcpaaacugaacccggagcuuugcgcacgcccgagcccucaaguaau\n", + "gucucugaggcugugguugcuacapucaccacgagcuuggcuuacuugucucauccuucccuugccugguaucauuuucucaguucucccaaaagcc\n", + "cagagacccuugacpcauacuguuuccuccpcuccugccucaugapagaggugcggcuuggcucc\n", + "gcucagaaauccuggauagaaagagcauuuuauaaaagagaauguguccacaucauacccagcaccaaagacccccauag\n", + "augaaagucgccucucccgaaaugacauccagucugaaaagugguccaucagcaaacacacucaacucagcccuacggaugcuuuupaccauugaguuccaaggagguggccauuccaacaaagcc\n", + "agcaaaaugaaagcaacaggagcugcuccpacugcuuuugccaguacccagaaucagugcucag\n", + "agcugcagcaaaaugaaagcaacaggagcugcuccpacugcuuuugccaguacccagaaucagugcucag\n", + "ggaggaagcgaccagguccggcacgaaggapagagguggccugaggagcggappauguguggauuccggugaaapaccugacaaucgcccccaaccc\n", + "gcccccacaaugcccuucgccuuccucaacguggcccccgcuccaagcccauuuucuggagccaggaauccacucugugg\n", + "cccagcugugaccagagcaaccagagccugccacccgacgcaaccccaggcucacucgcucaccccccupcccuccugcuuccggccpcacc\n", + "aguccccagcccgccccagcugugaccagagcaaccagagccugccacccgacgcaaccccaggcucacucgcucaccccccupcccuccugcuuccggccpcacc\n", + "agaggcapupaagaugcccagacuugcacagcguuuuugaaggaacagauaaaggccaggaagaaucupauccuacug\n", + "accaacucuugcguaaaaagagaagaauuuuuauccauucagupugcaggcacaauaaaugccuugcuggauugccuauuagaggaugaaguuauuagccaggaagac\n", + "ucagugguuccucugccuuguuccuccuuccaguggauugcauauccagauaauguugaacuupagccuucaugcuuugaucaguaaaau\n", + "gauaccugaggagacuggccupcaaaaccacaggauaagaggauccapuaaaacuccacacagauguaccacaccuaaccuccucugcauagaccccuacuucca\n", + "agaagcagcugagugucuccugauacccggaugugaggcgauccgcuggcgcuagucugacccuccgccaggcaaaaggaag\n", + "gugcugugugauguguuaagagcauauuagaaggaaugguuuugucuaauuuucuucaugaguuaugguggcugagacaucgagucuauauuuupcaaaaacu\n", + "caaaaaagauuuggagcaguuucuuguaauguuuguggaaugcuguauacagcuucaaauccagaagaugaaacacagcaucugcuuuuccacaaccaguuuauaagugcuguuaaauaugug\n", + "guucugcucauuaaucaccacgaguguggaucugaagaagaguuuauuaccucucuuuuuuugaguauguuuaacuucagauacacacaacguagcuucuccuucccuauuagauucuuagaag\n", + "aaauuagaaapacgucuagupuugcccpapuggcpagcgguccuggaaauaaucuguccucugucgccpaacuggcgagguaguuccuucgcgguggagag\n", + "gugucuuauaagacuuugacacuuccuguuuugucugaaaaaaaugugaauuaccugugauauuuggacuccaguguggcupcuaucuccccucauaccuauagaauuag\n", + "pacgucuagupuugcccpapuggcpagcgguccuggaaauaaucuguccucugucgccpaacuggcgagguaguuccuucgcgguggagag\n", + "gacgucuagupuugcccpapuggcpagcgguccuggaaauaaucuguccucugucgccpaacuggcgagguaguuccuucgcgguggagag\n", + "aaauguacaucaaaacauucacccagaaaaccaggagcuaguaapuacuucgagaacagcuucaaacagaacag\n", + "gcacuccaaauuagaaapacgucuagupuugcccpapuggcpagcgguccuggaaauaaucuguccucugucgccpaacuggcgagguaguuccuucgcgguggagag\n", + "acaaacuuucagagacagcagagcacacaagcuucuaggacaagagccaggaagaaaccaccggaaggaaccaucucacuguguguaaac\n", + "aaaaagccaccggagcacuccauaaggcacaaacuuucagagacagcagagcacacaagcuucuaggacaagagccaggaagaaaccaccggaaggaaccaucucacuguguguaaac\n", + "accggagcacuccauaaggcacaaacuuucagagacagcagagcacacaagcuucuaggacaagagccaggaagaaaccaccggaaggaaccaucucacuguguguaaac\n", + "aggcucggcpcggcggcacggacugacggapucggaaggacugapacpcpcgcacggccaggcc\n", + "acuguucgcgcugccguguuuccpcpacacucapcgcgacgcuuuucuguuacccacagaggcccgccgcggcugcgccauccgcggcc\n", + "agaaauucugcaaaauaaguuggucucuaggauacauaaugugcauuuuaguaauuccuuauuuuaaccccugcuuuaggaaucaguaac\n", + "gguuuggaaucacuugcuaggagucuugucucucugccacccaggacaucauggcagcucaccug\n", + "paagcgcgccgcgcaccucaugguuccpacaguuapcggcggauggaggucagcgguggugcucgcugc\n", + "ugcucguuccgugcuggcuugccagugcgcacgcuuccucucuagcccgcgcggccaggccuggaagacgccgccccuguugaccguccaugaccccagcgagccaguuuucgugacuuagugcaa\n", + "gucaaapcggcccggcccggcccggaagcuacagcagcggcgcggagacugcpcpcc\n", + "guuccuuaucacaggaagaaaauuuuccuugaccuuuaggugcuuuuauauucaucucaaaaacaaaauucugaacucaggacuuggcaa\n", + "aaaagcccuuacugaggaaaaacgugucucaacaaaaacaucagcugcagaucuugugacagaaacagaucaccuuguggaagauuuaauuauuucugaguugcgagagagguuuccuucacacag\n", + "guucauugcagaagaggccgcggcuucupccaagugugugcucacccacagcccgacguggaucaucgaccccaucgacggcaccugcaauuuugugcacag\n", + "cuugaauucggagugauuuaccacugcacagaggagcggcuguacacpccggcpucpcgccuucugcaauggccagcggcuccpucuccpagacag\n", + "aucucucaaaggccuugguucugacagaaauuggccccaaacgugacccugcgacccugaagcuguuccugaguaac\n", + "cgcucugcgcgcugcpacpcacggcggagcapuupuccgccucgagcpapugaugcugcaccacapcpcuggag\n", + "caggaaagagaggagccgucgcaggagccgcacacgucuccaacucucuauugcuuuuugcgcacauuccuaacuuccugacguccaucccagcpcaggc\n", + "gaccuccucagaugcagaguucugacaucupauuuuugagacacgauuccaaguggacaaaguaaacuucca\n", + "agcgauauccggacacagaucacagcguucuuucuguuuguuugcapcuggugagucupaaaagcacuaucgucaaacag\n", + "acaguagugcaaucuugguucacuauggccucaaacuccccaggcucaggcgauccuccugacucagccuccugg\n", + "apcuccccugcuguguuugauugguucuucgaagcggccugcccugccucccugcaggagg\n", + "acacaggaagcugagccggcuupcccagcauacacaggcccccaggaccccupagapccccgcupcuggcccugcapaccauggaauccagagcuga\n", + "acacaggaagcugagccggcuupcccagcauacacaggcccccaggaccccupagapccccgcupcuggcccugcapacc\n", + "acacaggcccccaggaccccupagapccccgcupcuggcccugcapaccauggaauccagagcugaguaagagccaccccaucccucauucucug\n", + "cucucucagccacacaggaagcugagccggcuupcccagcauacacaggcccccaggaccccupagapccccgcupcuggcccugcapacc\n", + "agaacaggcugacagccaggccuggaggagaaaugacaucucucagcccucucagcugcaccggaccaccaacag\n", + "gguuuuauguuacucugguagugaaccgaugguggaaccaguuugugaauuugcccuggccagacaggcua\n", + "ccgaccugaaggcaccucuucpagcccgaaauuugaagauucucuuuccugucggagacuacaaaccaaauaaauag\n", + "gacaccpcgugcagcaccgaccugaaggcaccucuucpagcccgaaauuugaagauucucuuuccugucggagacuacaaaccaaauaaauag\n", + "auuguuacuuacaggaguccaaaaacguuacuuugaaaaauuaucaauuuacugugacagauaugcugaacaaauuccaguaaccuuugugcuug\n", + "aaaaagaaucacuaccuaguggaaaauguugugcaagccucuucauguuucuucccuccagaaaacaacuaaacagauggaagaacugguucacaaacaucccaacucucuccugccaag\n", + "guccagupcuuguugcuccagaccucaugccuucuggacccagacaucucugcaaucucggaacuggaauacaccacuucuugucaagguacuagcaaguug\n", + "ccguggauacagaaaucucugcaggcaaguugcuccagagcauauugcaggacaagccuguaacgaauaguuaaauucacggcaucuggauuccuaauccuuuuccgaa\n", + "agugccccaggagcuaugacaagcaaaggaacauacuugccuggagauagccuuugcgauauuuaaaugu\n", + "gucggaggcgguagugacgguggcguuuccuugaggaagagugapuuccaacuuuucugcuuaucupagguguupcgcggacagucgag\n", + "agcgucggaggcgguagugacgguggcguuuccuugaggaagagugapuuccaacuuuucugcuuaucupagguguupcgcggacagucgag\n", + "gcgguagugacgguggcguuuccuugaggaagagugapuuccaacuuuucugcuuaucupagguguupcgcggacagucgag\n", + "aagucucuaugguagcgucagcgucggaggcgguagugacgguggcguuuccuugaggaagagugapuuccaacuuuucugcuuaucupagguguupcgcggacagucgag\n", + "agugacgguggcguuuccuugaggaagagugapuuccaacuuuucugcuuaucupagguguupcgcggacagucgag\n", + "puccuuggugaauuuugucaugguuauuuaaggaaccuugccuagaagucccaacuugcaguuccccaucgacpaaggcuuggacuccaag\n", + "gaugcuggcacguguguccugguccucaacaaccuucugugagccuapacccauuucuccuccuuugacapacaucaguggagccuucucagacccacag\n", + "ccugcaggaugcuggcacguguguccugguccucaacaaccuucugugagccuapacccauuucuccuccuuugacapacaucaguggagccuucucagacccacag\n", + "acacaguagcpacacccgacgccgcuagcgacaggcgcgcggacggcuggucccagapacgcugcgcuupacgccggcgagacucgccaggagccaagag\n", + "ccuucupcgccauagagagcguggcgguaucccggagccugccguccggcccuaccpaccg\n", + "guauugaaaaccuucccuuugaauuacagagaaacuuucagcucaugapaccuagaccaaagaacagagg\n", + "guggacaaacacauucggcggcuggacacagaccuggcccguuuugaggcugaucucaaggagaaacagauugagucaagugacuaugacagcucuuccagcaaaggcaaaaaga\n", + "aaggccggacucaaaaggagaagaaagcugcucgugcucguuccaaapaaaaacucggaugaagaagcccccaagacugcccagaagaaguuaaagcucgugcgcac\n", + "gccggacucaaaaggagaagaaagcugcucgugcucguuccaaapaaaaacucggaugaagaagcccccaagacugcccagaagaaguuaaagcucgugcgcac\n", + "gagaagcgcuacaaagcagccacugugcuuacugaacggccucccccuguaucgcuuaauugagaag\n", + "gugaccuuuucuuuggcuguauuaugucuggcupaapauugcauuuugcagcugagagccggagcuuccuucagcucggcuccucgcacgcugcup\n", + "guacagaacaagucaacuaapuucucauuaaucuaccgucugugaauaucguuauuuuucag\n", + "gagaaaacacagcucugucaauggacugaaugcaccauuaaaacuggcgucacuacaaagguuagagcagaucuaacugucaauaca\n", + "aaacaaugcuucuuuuugaccuuucccaaggagaagcgcuacaaagcagccacugugcuuacugaacggccucccccuguaucgcuuaauugagaag\n", + "aauggugcagaaacuaugguucuuugaccaaguuaguccugaaaacauguuucucagugcuguuggcuguuuuucauuggagcgu\n", + "aguccugaaaacauguuucucagugcuguuggcuguuuuucauuggagcgugugaguuuuaaaua\n", + "aaagaaagaaacagcugaaaacuugaagacguguuuagaaauauacauauauacacacuauuuucuugupagaucuccuuupcaaag\n", + "aaagccaaacuuaagaaaucugccuauguacagaacaagucaacuaapuucucauuaaucuaccgucugugaauaucguuauuuuucag\n", + "agcugaacuucgucacccagucccuagagccagcaagacaupccccaguuuccagacccugacaccucucauuuaaccagaagacguggap\n", + "acagucugcagapcccpcacgcuggcupcucagccgcggcaccagcugccgcaccgcgauuacpcugcccgccpaaaccgugcaggauugguggugauuuucauagccaa\n", + "agccgcagcpccpccpccpcgcgcaccagcggcagcggcggcggcagcggcggcggcagcaucucgcucucggagccggcgcag\n", + "ccgcaccgcgauuacpcugcccgccpaaaccgugcaggauugguggugauuuucauagccaa\n", + "agccaucacccggcagccucuuguccagcgcugacccuupcccagcccgagcaaggaccgcagcaaac\n", + "agcugccgcaccgcgauuacpcugcccgccpaaaccgugcaggauugguggugauuuucauagccaa\n", + "aaacuugguuccagcugcguguggugaaagcaacuagaggcagagcuaucaapcugugacagaugagcaguggucugucugcaaugagcaugugcucaagcuaac\n", + "caaacuugguuccagcugcguguggugaaagcaacuagaggcagagcuaucaapcugugacagaugagcaguggucugucugcaaugagcaugugcucaagcuaac\n", + "gauccuaaucaugaaaauaaguaugauaaauuauaagucacuauuggcacuguuguuuauauuagccuccuggaucauuuuuacaguuuuccagaacuccacaaag\n", + "cacaggucugcaggcacucgguacgccgcuaacgcggcgagguagcucggugcgucucgcgguaccagugcgaaucaucpcuauccagguccgagauccuagucuccugucggcucugaggagg\n", + "uggaaaucuaaapaauggugaaguugcaccguaapaaggugacugaggagcugaaacugacugapcugaagcauuucggacaggagaaaggaucaggaggagacagagcggaga\n", + "ugaugaugcaucccuggaagaccupagccaggucuggcuccuuggacuguaucuuccgugcuccagupaguacagacugagapagaapcupuagag\n", + "gagugccucgapcgccguucpcpaggaucccgcpucccacugacccacgcpupccapuggacgcucgcccguacgcggucgcuacugauc\n", + "agagcagcguggucccaggaggcauacacagagagccacggccapcugaaacagucuguugagugcagcc\n", + "gcgcgcccgcggcgcuccaucccaaacacacacacauuuuucccccggacuuggaaagucacccaaagccgccccaagugcag\n", + "gcaugcgcgcccgcggcgcuccaucccaaacacacacacauuuuucccccggacuuggaaagucacccaaagccgccccaagugcag\n", + "ggcccpcupaccccucggucgugcgaggagagcgupaaccugucggaaaugagaucugguugcgcupcugccuuuauuuucucguuccuacagcauuugaaugaagag\n", + "ccccgcagcgccggagucaaagccgguucccggcccagucccguccugcagcagucugccuccucuuucaac\n", + "cucacuucucuggacuuggcccugagcuggaccugguccacupuaggcapcgaupaaccuguuuaugcucupcagcucupcau\n", + "ggaagacccugcccucuccucacuucucuggacuuggcccugagcuggaccugguccacupuaggcapcgaupaaccuguuuaugcucupcagcucupcau\n", + "cagaauuuucucacauaaauacugaggaagacccugcccucuccucacuucucuggacuuggcccugagcuggaccugguccacupuaggcapcg\n", + "gucagagacuaapuccagaaggapuugapaauuacugagauguugcuacagagagauguugcugaagucuaugaggcccagacucuaapacaag\n", + "guuuacucgcugcugugcccaucuaucagcaggcuccpcugaagauugcuucucuucucuccuccaag\n", + "agaaccguuuacucgcugcugugcccaucuaucagcaggcuccpcugaagauugcuucucuucucuccuccaag\n", + "cagccuucagccggagaaccguuuacucgcugcugugcccaucuaucagcaggcuccpcugaagauugcuucucuucucuccuccaag\n", + "uuggaacuggaapaaaacaacggagcugaugagcuccaaaaaugcuccpaccaucucccucucgcccguucgcaggucuagugacggagcccgcgcgcggcgccacc\n", + "gagcugucgcgcugguugcucgugcaggagcpacccggaacagaccgccgugagagaggapugccggccpauucgcggcccggagcucpaccg\n", + "gagucaggaauggagagaapuaaugguuuuaccucuuauuguggaaaccuguugagaucacagagaauauacugacggcauaaaapcagaaccauagcapugcg\n", + "guugcuucauuccagccucgcagucaccucugugcccugcugguugucuucccagcgcugcuguaguugccuuccauggaucuauaggagagcaaguccuccag\n", + "pagauuacpcpacgagcugucgcgcugguugcucgugcaggagcpacccggaacagaccgccgugagagaggapugccggccpauucgcggcccggagcucpaccg\n", + "gugcaggagcpacccggaacagaccgccgugagagaggapugccggccpauucgcggcccggagcucpaccg\n", + "acpcpacgagcugucgcgcugguugcucgugcaggagcpacccggaacagaccgccgugagagaggapugccggccpauucgcggcccggagcucpaccg\n", + "agagccauuuagcugcaaacugucucugucucuguuuauccgagcagaaccuggaapcuggcaaggacuaggcaacagaupacagccagagag\n", + "ccgucugcapagccggaggcugcugcugcugcuauuguguggaugccgcgcgugucuucucuucuuuccagag\n", + "guccugugcaagcugauaaauaguuuauacccaccaggacaagagcccauacccaagaucucagagucaaag\n", + "guugcccagccauaucccagccccgucugcapagccggaggcugcugcugcugcuauuguguggaugccgcgcgugucuucucuucuuuccagag\n", + "ccaagucugcggcgcccacugugugugugagagagagaccguguggcucupcggcaggcpcagcugccgaggaggacuag\n", + "cagccuggcaccagcugucuguccccgaggccaagucugcggcgcccacugugugugugagagagagaccguguggcucupcggcaggcpcagcugccgaggaggacuag\n", + "gaauuacuccauaccagcucugagauuuccagcucagcgaugcccccaggucccupagagcugcuucupuppccucauuuuguggcucagcguuggaaguucag\n", + "gugcupugugucggaauccucaauccacaucauugguguuagccupcccacguupc\n", + "agucacaccuaguuuuuccuuggacuguggagcuuuagauuguugagcuccuugaucaaccuggcccuugagcuuccaggcuggcucaggcguccucuccuccaggugg\n", + "pucgcugcgaaccccpuuccgcgguggapugcuauacupaugcaggcgcggcpacuggcagcaaucaugcccupagcuaacguagagcuuuggaua\n", + "gcaguucuugaguuccacaugcagagcagaugcgacagcuagaagugaguapcccagacccuggcccaggaagauccacuaaaggaggccauccuuccgccuucuucugcaggagucag\n", + "aauacaauuagagaaccauaaapcaaacauauuaaaagagcuuaauuuuguaguguggccugcaggcuuccagaaaaaaacaggagaucagugagcuagcagcagagaagccuuccuggaaaag\n", + "cuuuugucucucagcuauuuuuuguucccuauguuuguaggauggaaaggcagauguaaagucccuc\n", + "aacuugcacauucacuauccaagcugcaccaucuucpucauugugugccaggcauaucaacucuuuucaauaaaa\n", + "gcacauucacuauccaagcugcaccaucuucpucauugugugccaggcauaucaacucuuuucaauaaaaaug\n", + "gcgaugcaaaccaguaaugcagaauccuauugcucuauaaaaauuugaauugcuugaaucuauuacaaauuuuugccagugugcuuccugccucaaggaug\n", + "aaaugagaauggcgccgcuggagauccuuuccugcuuuugguuucccuggcapuugaacuguggagugugugg\n", + "guggcpagcagupccaggccagagacagcugcgcugugcpcagcuagucccaguacuccgagucggucgcpccgacaggcauccccugagcgccugcugg\n", + "agcagaguagacucuguccupacuugguggugcuacccuuggccucccacaguccugccacccugcugccgccacc\n", + "cuucccccggcuccagccggcgcaggcagcggcggcagcagcaggcgagccucggccccgcaaggcc\n", + "gcucccacuucccccggcuccagccggcgcaggcagcggcggcagcagcaggcgagccucggccccgcaaggcc\n", + "auuucaaaagaaguugagaaccagagaaaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "ugaccaagaggaacagaacacagagcagccuggcaguguccaagcaacaagccuccgcuccuccuuccugcacccupcuccugaaacucacaug\n", + "ccucugcgagcguuauuucaaaagaaguugagaaccagagaaaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "agaaggapcugucugagauucgapaaacaagcucucaggacuuccggucgccaugauggcugupcgguaaacgcgguuagugcaagcaucupccaucuucaau\n", + "aaaagaaguugagaaccagagaaaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "agagcagccuggcaguguccaagcaacaagccuccgcuccuccuuccugcacccupcuccugaaacucacaug\n", + "aaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "ccccaaaguggaacucacccaaaugucuaucgucugcugaauggauaagagaauaugugaugucuccauacgguggaauauuauucagccaugaaagcaaaggag\n", + "agaacacagagcagccuggcaguguccaagcaacaagccuccgcuccuccuuccugcacccupcuccugaaacucacaug\n", + "ggcaguguccaagcaacaagccuccgcuccuccuuccugcacccupcuccugaaacucacaug\n", + "guugagaaccagagaaaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "uuucaaaagaaguugagaaccagagaaaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "gaaaccgaccuaapauucucccauuuggcccguccuacccuaaagucaccaccugcugcuuuucuggagcgcuuaccag\n", + "acagacacaggacggccgagcugacggacugacagacggacagagcuccuggccccccagacccpcccccacgccgaccugcuucacugagcag\n", + "ggaauauuuuuucaccuuuggcuuuuagcuuagaaguuaugacugcacauuacaaapaauguucaaaccuuuauca\n", + "aauuccuagaggaccugugcaacaaccucuugaggaucgaaucuucacucccgcugucucagcagucuacagcacg\n", + "accccuuaucccucuggacagaaugcagguccaaccacgcugguauacccucaaaccccucagaca\n", + "cugcucguugagugaagaaaauccaccggcaucgccugagccccgcuaccgagaapcgccgcuuccuccpapauaaagaucccccgccgccggcccaugaggauauugccgugaaag\n", + "auucuguaagucauagaaaaguuugaaacauucugucugugguagagcucpccagcuguaguucauucgccagugugcuuuucuuaauaucuaag\n", + "acaccupcucagccucuapaggaaacugcugccauagagccuugaaagccaggcagapacuagacacugugccucaag\n", + "auuguuaagacaaapugugcacuuccuggccaggaaaccugagcggugagacucccagcugccuacaucaaggccccaggacaugcagaaccuuccucuagaacccgacccaccacc\n", + "cccgcuccuccgcgccgccgccagccccgcugcgcgcucugcucuucgcagcuccccggacccgcagcc\n", + "aggccgcguccgcccgcgcccgcucuggcccccgcggagccgcgcaacuucccpagcccpccaaagugagcgcaaagugcugcccaaguugccp\n", + "aacggcgaccucaagaagcagcuccacgaaaggcagccgcggaucgccgcgcucagcgacaaacaa\n", + "gcuuupaacgaucacugcagugccugucacpuccucaggucagcuccuugcagagguuggccpcaaggagcggcagugcuaccucag\n", + "gcccucgccgagcccgccgcccucgccucuccgcugagcagugcpuggccuacgccaucaucuccaccucccccagcaaugccgccgcc\n", + "gaauaugaaggcgcgcuaagccpcuggagcggagugucucagaggcugcgcuccuuccapcccaaggacucacagcuuccuccgcugccuucccggaccaacaaccccccaaaaguugug\n", + "ucuuuccuuuucaccuuuccauuguuccugacgaguagaaauggcagcpaaggcagcagauggacugcgacucccgucag\n", + "aupaaggcugapugucaucaaugcagagauccccaacugcupagugcccucgcugcacccaggaaggccgcaccagcaag\n", + "aaaccaaagccgccuuuggccucugcagapcccagcggugccguccccguccccgcagapagaagcuagagcguuucaagcgg\n", + "uguagguggapaccugucapucucccaggccapccccagupcccaucugacccugccaccauccaccuacagcccucggcguugcugacgccccca\n", + "upcacuuguuuccugaguccpcuggaaaucucggaguuaccgauucugcggccgaguaguggagaaagagugccupagucaggaguccupcgcugccgcugacuuccuggcgucccuga\n", + "gcuuugauggugaggaaaggaaagauuccugugagaagagcaggaugagcagapauucuaugcuugaagucgagucacuugaaaaagaucucuuuga\n", + "uccuggugagcaggcuuugauggugaggaaaggaaagauuccugugagaagagcaggaugagcagapauucuaugcuugaagucgagucacuugaaaaagaucucuuuga\n", + "acacacucacaaacucacucacugacacacucacacacucacuuacaccucccccagcucaccuccuccccaccccagc\n", + "caucaccauggccgucauuucauucacaucagacacagcggccucuauuugguggucacaacuucagaaaacguuucucccuucagccuccuagaacugcucuccag\n", + "guuggccacccuucupcgauuacuguggcucccupcgapaccaucucccgcaauguggcucugguauacgaacuccuggaugaagugcug\n", + "cuuuuguuccpccgcapcpcaggcccgacuuucgccgucuucuugucuacucuccagaacggcc\n", + "agcuggcgcpcggaggagaaucgcucuuaaapccagcgcacacgcguucuuuuguuccpccgcapcpcaggcccgacuuucgccgucuucuugucuacucuccagaacggcc\n", + "aaucuaucuaccgccpagccagaagauggaggaagcuguaccgugccaacggccaccucuuccaagccaagcgcuuuaacagg\n", + "ggacaucuucaucaccagcguggacgccgccacgaccuucgaggagcucugugaggaagugagagac\n", + "auuuggcaagapaggcuccguggcacgaucacacgugcaggagcupcugccagagcggcuguucaag\n", + "gaauucccgaugcaccuccuuccagcacauggacugucagagcccugcguugucgccagcacagcagaucugaaaggcacuaggcuguggccucgcgacggcugag\n", + "ccgugguggauccuguccgcccugcgaggacaccuggcuccauccacaccupccucugucuccagccgccgaggccgugacaccaugaggaucau\n", + "gaugcagcuuupacapagaugaccaagcauugugcaaaauaucccguuguauaaagcacuugguggaaaggucauggccugcaguaccgaguggccaccuccgucugcagaaucauag\n", + "aggaugcagcuuupacapagaugaccaagcauugugcaaaauaucccguuguauaaagcacuugguggaaaggucauggccugcaguaccgaguggccaccuccgucugcagaaucauag\n", + "ggcucacuccaucpuccucggaugguggcgaggagcpcugcggcguccuguuuucuauucugaaaugguuggag\n", + "gccacggcucaaucagaugcggcguuupaaauuuuaaauuuaaaggcpcggccugugagcccugaagugccggccgcggapuccuggccauuuuccupaccaguucagccugauagg\n", + "cggacccggagccagcgcggagcaccugcgcccgcggcugacaccuucgcucgcaguuuguucgcaguuuacucgcacaccaguuucccccaccgcgcuuugg\n", + "ccuccucaaagagcagaugugucuuuauaacagacuguaggcuuggagccuuguaaaauguacauggaguuucacaaucaagcacaaggaauccaacugaaggcagcuaaacuuuguguugauuug\n", + "ggucgcgauccggacccggagccagcgcggagcaccugcgcccgcggcugacaccuucgcucgcaguuuguucgcaguuuacucgcacaccaguuucccccaccgcgcuuugg\n", + "ggacccggagccagcgcggagcaccugcgcccgcggcugacaccuucgcucgcaguuuguucgcaguuuacucgcacaccaguuucccccaccgcgcuuugg\n", + "guuggacaccgaggaacaguaagagauuauccagacuuuagcccaucaguggaugcugaagcuauucagaaagcaaucagaggaauug\n", + "agcgcggagcaccugcgcccgcggcugacaccuucgcucgcaguuuguucgcaguuuacucgcacaccaguuucccccaccgcgcuuugg\n", + "cccugcucaggcauucggcagguccagcagagguacaccuccugcagcpuuccaagugcaccuccagccugaupccugaccaaggaggcuuccaggagcacagaapcugcaacccag\n", + "auuccaugguacucggaguccupaaccacucaucacugucpugcagguggacguccccucacg\n", + "agaauguaacuggucacuacauuucccccuuucaugauauuccucugaaggugaacucuaaagag\n", + "upcagupuccugccugugacgcgcggcggcggucgguccugccuguaacggcggcggcggcugcugcuccggacaccugcggcggcggcggcgaccccgcggcpcgcggag\n", + "augccuguuugcgacaaugcucgcuagucccggugguggcgguguucacagguaacaauguuuaccaccgugaauggaacuuguuugauuaacccugaucagaggaugaaaacacuaaagaaccaa\n", + "gaucagcucagcuacuauuuaauaaaacaaaaucuguagaauucacguuuuguaaugacacugucgucauuccaugcuuuguuacuaau\n", + "gcagccupcagupuccugccugugacgcgcggcggcggucgguccugccuguaacggcggcggcggcugcugcuccggacaccugcggcggcggcggcgaccccgcggcpcgcggag\n", + "ggaguggacauccgccauaacaaggaccgaaagguucggcgcaaggagcccaagagccaggauaucuaccugaggcuguuggucaag\n", + "uuauacagguuucuggccagaagaaccaacuccacauucaaccagguuguguugaagagguuguuu\n", + "acuuauguaaauuucaugaacuauuauauccguuuuccucggagugagagaaaacucuuuuuagauaucaucugagag\n", + "aacuagugaaucccagucacugaguggaguugagagucuaagaaccucugaaauuugagaacugcuggaccagagccuuuagagcucugauaaggugucaacagg\n", + "cuuauguaaauuucaugaacuauuauauccguuuuccucggagugagagaaaacucuuuuuagauaucaucugagag\n", + "cagaacuagugaaucccagucacugaguggaguugagagucuaagaaccucugaaauuugagaacugcuggaccagagccuuuagagcucugauaaggugucaacagg\n", + "aggacgagaccggagcgacccgcgcagcgagcauaggcggcgaagcugcgcccggcgcccgagaccggcagcugcgupcpcugcgcccgagcccgaucugccggcuccgag\n", + "caguggucucggaaagapucguggucccgcacggaugcgcuuguupagaaaccuuggagauucacggcaaggcguaaagccupcuuccaacg\n", + "acucuaauccucugccccgcggcgcagccgagccccgagccaggagucgccgcgcgcgcccguucgcgcugg\n", + "gugacuacggcacagaggagaguuacugagugccucupaggagcaguagaaapuccauuggcugaucugcuugcucugugcuuccuccuggccaccuggccaucuccugaugccucp\n", + "guaacuccaggacgagaccggagcgacccgcgcagcgagcauaggcggcgaagcugcgcccggcgcccgagaccggcagcugcgupcpcugcgcccgagcccgaucugccggcuccgag\n", + "uggucucggaaagapucguggucccgcacggaugcgcuuguupagaaaccuuggagauucacggcaaggcguaaagccupcuuccaacg\n", + "auaggcggcgaagcugcgcccggcgcccgagaccggcagcugcgupcpcugcgcccgagcccgaucugccggcuccgag\n", + "cuuagcaaagaagcgacuucagaagaagcgauuuagugaaaucgucucaagcugccgcagcucagccaguuuaaucacccccagagagccgaacaacugcgagcgcaaupacacaaaaucauuuu\n", + "uuuuugucgccaggcgcpcgcgcggagcuaauugcgacucuaauccucugccccgcggcgcagccgagccccgagccaggagucgccgcgcgcgcccguucgcgcugg\n", + "gcgaguuucuccaccupugagguggagccacggagacugcuuuucuccagaaccagacgagcuccagcucccaggcuag\n", + "cccaucugcacagcuggccugcggaguccuccucapccacuggcccucaccugccacuguugaap\n", + "acuggugcugcaagucgcugagcugacaguugugccgaggacugucaccauupcaggcaugguggccagcuccucacuuggcugagguccap\n", + "aucacuggugcugcaagucgcugagcugacaguugugccgaggacugucaccauupcaggcaugguggccagcuccucacuuggcugagguccap\n", + "ccaaacauggauccucaugauuuuauuuucuagauuggcugauaggcugaauaaucuccuguapuaagaagugucaacuguaucaagcacauggagguggacuggcuacaggagaaag\n", + "aacaggcccggcaccaccucugcgcacaaccccgcpccuggcucaggcpagugcpccagcacc\n", + "acuccgcucacuuccccggccccgcgcggcccccgccgcccgcugcccgcugcccgcugcccucgccccgcgcgccpcaugugagcgcpcpcgccgucacc\n", + "gagcagcaaauggauuucucauggaaguuuguguugauucaguggaaucagcugugaaugcagaaagaggag\n", + "gcuggugcgcgccggagcccaaauuccaaguggaaacugcaggcgcacgapaggaacgcguggagc\n", + "gucpacgcgcgcacpcgcgcgcagcuguugacgcgcuucuuagcuggugcgcgccggagcccaaauuccaaguggaaacugcaggcgcacgapaggaacgcguggagc\n", + "gcgccacugcagcuggcauuggccpacuggaagugcpcuucugcagcagccgaagcuggagcugcuagg\n", + "gcagcagcggcuccccuguuguauggacauucugcacccgaaacugauagcugaguccugaaguuuuauguuaugaaacagaagaacuuucaucccag\n", + "apaagguupcaguccupcggccagcaccccggcgugcaugucuccugagcagcugcccaucpccucugcuggccupcuccaag\n", + "ucuugacucgucugcugaacaaauccucugaccucaggccggcugugaacguaguuccugagagauagcaaac\n", + "gaugcaaugaccagcuaauggcucgauucucaagapuuucauuggucucaaccuggccccccaggcaacccaccccugauuggacagucucaucaagaag\n", + "aapaaacugaaagaaagapaagaguauuaaagaccauuucuggcupcapcacucucagcagcucaacugcccagcgugaccaguggccaccucugcagugucuuccacaaccugg\n", + "gugaaucuacuucucuuaacaaagucucaauguccuauuugcaauuuaugugguaaacacugaagacaaugguccuuaaccuuuuggcaucucagccuccuuucgaaag\n", + "auguuccugaacuccaaguugaaaaaccucugaaguucaacucaauucugaaagucaacaaagaaauaaaggaggaugucaauag\n", + "ggcacucucagcagcucaacugcccagcgugaccaguggccaccucugcagugucuuccacaaccugg\n", + "acucucagcagcucaacugcccagcgugaccaguggccaccucugcagugucuuccacaaccugg\n", + "ggaaacugaaagaaagapaagaguauuaaagaccauuucuggcupcapcacucucagcagcucaacugcccagcgugaccaguggccaccucugcagugucuuccacaaccugg\n", + "cggacggcguuuccacggacgcccaggagacagccgguugcugagccpagcgcugacuggcccggcupcagg\n", + "ucucaauguccuauuugcaauuuaugugguaaacacugaagacaaugguccuuaaccuuuuggcaucucagccuccuuucgaaag\n", + "aaugaccagcuaauggcucgauucucaagapuuucauuggucucaaccuggccccccaggcaacccaccccugauuggacagucucaucaagaag\n", + "ggcapcacucucagcagcucaacugcccagcgugaccaguggccaccucugcagugucuuccacaaccugg\n", + "ggacggcguuuccacggacgcccaggagacagccgguugcugagccpagcgcugacuggcccggcupcagg\n", + "gaagauuucugaagagugcagcugccugaaccgagcccugccgaacagcugagaauugcacugcaacc\n", + "aauauaagcuccaugaagacagagaucuuuguguacugauguaucuuaagagccuagaauggugccuggcacauaguagauucuca\n", + "ugagaacaauaagaauuccuuggagagcagccuacggcaacuaaaaugccauuucaccuggaacuug\n", + "ggcagaagaggaagauuucugaagagugcagcugccugaaccgagcccugccgaacagcugagaauugcacugcaaccaugag\n", + "uccaucuuuguguuuuucccuacagugagaacaauaagaauuccuuggagagcagccuacggcaacuaaaaugccauuucaccuggaacuug\n", + "ggcagaagaggaagauuucugaagagugcagcugccugaaccgagcccugccgaacagcugagaauugcacugcaacc\n", + "gcuguugaggccacccugguggcaccaaagcccucucaggcaggcagacccapccuccccgccacaccuuguuc\n", + "guugaggccacccugguggcaccaaagcccucucaggcaggcagacccapccuccccgccacaccuuguucauggauuuugucgcuggagccaucggag\n", + "guguuccugacgucgcccacugagguggccaaaguccgcuugcagacgcagacacaggcgcagaagcagcagcggcggcuuucggccucpccguuggcugugcccccc\n", + "aaccucacgaggccuuacgugccuagagcgguuccucuccguggcgcccuaccgccuucggcgcgaagguggcuggugcguaccgucccgaacccuaggagccgag\n", + "gcaaaagcauuucagaaagapagagcaggagcauaaacccugagguggagcaugccugguaaagugugaggaacacugaggucagugcaacugaaguggaaugaaacacag\n", + "acuuggagcucgcccccgucguucccgcggcgccgcgccucgcuggcuccucagcuuccagccaaa\n", + "cpagcgccgcuccagcgaggcgcpcugupccgccgcgugccuggccccgcucgcccgugccggccgcucgcccgcc\n", + "gcuccagcgaggcgcpcugupccgccgcgugccuggccccgcucgcccgugccggccgcucgcccgcc\n", + "gccgcccggagccpagcgccgcuccagcgaggcgcpcugupccgccgcgugccuggccccgcucgcccgugccggccgcucgcccgcc\n", + "uucccaggacapcupucuucupauccupaaguagagccccucaggccucugcuugcccuuuugucucaucuaggcugguupaaccggucug\n", + "aucuacccagacccggagcuggaaguacaaguauupccugccuauccgcugcauccacagugaggapcugccgcuggagupccacuacgucaucuacag\n", + "agucggcgccgcccggagccpagcgccgcuccagcgaggcgcpcugupccgccgcgugccuggccccgcucgcccgugccggccgcucgcccgcc\n", + "cgccgcuccagcgaggcgcpcugupccgccgcgugccuggccccgcucgcccgugccggccgcucgcccgcc\n", + "gacuugguggcuuucgaggauguggcugugaacuucacccaggaggaguggucuuugcuggauccuucccagaagaaucucuacagagaagug\n", + "agcagucagcaacapucccguccuugacaccucagccucuacaggacugagaagaaguaaaaccguuugcupcuggccugacucaccagcugcc\n", + "ugaugcagcuugguuuaacgaaucuugguuaagccgaauuaaagaggauguupacaacuggagaauaaag\n", + "gucguggacgccggcuccuggaggagagccgguaggapagugugaagguguccgcggcgucgucgacggcggcgccggcc\n", + "cagccgccauuuucucgccgcuuguguggcucgcuggcugcguggcucgguucuugugagcgaagcuuuguccgguucggca\n", + "ucccccggcpcuuuggucgagaaaaugagaagaaagcpcuuggaggcupaggcauapcgauggcp\n", + "agccgccauuuucucgccgcuuguguggcucgcuggcugcguggcucgguucuugugagcgaagcuuuguccgguucggca\n", + "pccccagccgccauuuucucgccgcuuguguggcucgcuggcugcguggcucgguucuugugagcgaagcuuuguccgguucggca\n", + "aguuucuggaaaaacgacuauaaaaacccagaaccaugcugcaucuuugcgaaccugagucaagacggaaugcugagugag\n", + "gccauuuucucgccgcuuguguggcucgcuggcugcguggcucgguucuugugagcgaagcuuuguccgguucggca\n", + "aaaugcaacugagccaccuggaguaagcccgagucccauccccaacagccaaagacuguccggcaccuuaaaa\n", + "ccaacaaggagagccugccagaacugagcacagcucagcagaacaagcugaagcaucuuaccaucgugagcuuggcaucaaga\n", + "agaaaagcgccggacgccpugaucauggacgcuugacaaccugcpcaggcgccpaggccgagccagcgacuaagaggaccgagagguggcguggacag\n", + "gaaaagcgccggacgccpugaucauggacgcuugacaaccugcpcaggcgccpaggccgagccagcgacuaagaggaccgagagguggcguggacag\n", + "ggacgccpugaucauggacgcuugacaaccugcpcaggcgccpaggccgagccagcgacuaagaggaccgagagguggcguggacag\n", + "aaaagcgccggacgccpugaucauggacgcuugacaaccugcpcaggcgccpaggccgagccagcgacuaagaggaccgagagguggcguggacag\n", + "cgccpugaucauggacgcuugacaaccugcpcaggcgccpaggccgagccagcgacuaagaggaccgagagguggcguggacag\n", + "gcagucgcgcccpccgccgcaggcccgcaccgaggcgcggagcgcggcgcacggcggugcccapccgcpcpcaggcpagcgcggupuggccggccuuggacpu\n", + "augcgcguggcpcaggcggcaggaggcpupucaagguaacucupcuacagaguccuugcupuucpagcgcuuggaccccggcuucupacgcgucag\n", + "gcaggcggcaggaggcpupucaagguaacucupcuacagaguccuugcupuucpagcgcuuggaccccggcuucupacgcgucag\n", + "ggaggcpupucaagguaacucupcuacagaguccuugcupuucpagcgcuuggaccccggcuucupacgcgucag\n", + "gcgcguggcpcaggcggcaggaggcpupucaagguaacucupcuacagaguccuugcupuucpagcgcuuggaccccggcuucupacgcgucag\n", + "auuaccacagacupuaauuuauaaagaaaagaaguuuauuuggcucacaguucuggagacupaaguccaagagcauggugcaaguaucug\n", + "agaaaggccpcgcggcgaggcupcgcupcggcugcggcgcgcggugcgcggugcguagucuggagcu\n", + "ccggacugaccggauccgccacgcupaaccuapcggcccapcucuuuucuguacuuuuuaacucucucguuagagaugaccagagcup\n", + "gaucuccuuccccuggugcuuuggacuuccaagucugucuucccagucuaggucuuccgcauaauccacuuggag\n", + "guugagcgcaccaucacaucuaagccaucagcaaguuuguugguuuuaaucuccaaaauacgucuugauuuugucugacucuuugccaccacccugaucuaagcccuuaucaucugcuugaaucacu\n", + "aacuugucuccacuugcaguuuuuaaaagaguugcuuccauuugacuuuuucugucugcuguaccagcauaugaguuucaggagg\n", + "gcagcucacuuccggaccgcggauagcacuggcgacccuagcpugagaggcccuucapccgcggcgg\n", + "gguuucguggcgguggcaagcgcugcaacagguagacggcgagagacggaccccggccgaggcag\n", + "gcagaggcaaccaaaaaggaacccacaccucccuccapcccpcgcugucagacpcagcaaccaggagauucccupccugcaggaagcccuuccgcggaccgaaag\n", + "uggagcgaaaccucaacuaugccaggcgucggcccguaggaaggcapaacacagapcgcugcccucggcggcagcggcag\n", + "auuguuccccauuuuggagaugaagaaacugagacucaaagcagcugagugaccuucccaaggacacacacuga\n", + "agauaaucauucaggucuucgugagcuaaggccaaacaaacaaaaaacacuugcuuugauggacugaauacuguuauuagaaguaaau\n", + "agguagugcgcgugcgugaggcuagagcagupugcggucacgupccggcgguccacggccggaauggcagcaagcucag\n", + "paacuggagcacuacccupuuuggaauguaaagaaggcauuaauugcagcuuuuggcaccgauuuacccuuaugcuguuag\n", + "agacucuccaacaugugccuucugaccauacaaaugaaacuuccaacaguacugugaaaccaccaacuucaguugccucagacuccaguaauacaacggucaccacc\n", + "gcagacucaacccaaacacuuggugaggcccuuacccugugauuuuaguuupacaaagccuupccucugaguucacuaacauggaaagaugcaagaaccaggcug\n", + "guugaauuaaagaaaauacuuuaucagaagaagauggccacugcccaguugcagaggacucccaug\n", + "agugcacugguauuucccaauaagauaucaacugaacaccagucuuugguguuagugaagaggcuucuagcaguuucaguauccuguaucacguauuugapaauauucccaga\n", + "ggaaagcgcaugcgcgucpcacagcgcgugcagccucgugcagcucuucuggucuccggcgcccgccccucagacguaau\n", + "cpcacagcgcgugcagccucgugcagcucuucuggucuccggcgcccgccccucagacguaau\n", + "augcgcgucpcacagcgcgugcagccucgugcagcucuucuggucuccggcgcccgccccucagacguaau\n", + "gaccguugaaggaaagcgcaugcgcgucpcacagcgcgugcagccucgugcagcucuucuggucuccggcgcccgccccucagacguaau\n", + "guugccuaaaccucugccacccaccugugaacuucacuuugccacapaggcacugaacugaaaaa\n", + "guuacuccucgaaaaacucuacgapauccucugauuuuaaggauaagaaacugagacacagagaagaaaaaacucuuaccapucucccaaaaua\n", + "uccuguguaccaggccccaggupcagugcugaggucacagaaagaaccugaccugagccccaucuucaagacccccagauggagaaaagaacaggccagaccucagcaa\n", + "pcagugcugaggucacagaaagaaccugaccugagccccaucuucaagacccccagauggagaaaagaacaggccagaccucagcaa\n", + "agucccugcaggaagcaucacccaggcuggcagaucaugguagcagcagcpuggcupaagugaaacggagccagcggcugaggapccccagcagcccccgaaggcccuaucaggac\n", + "ggcgcuucugaagacpupcagacgauggaggacgaggcucugucccgccccugcagagcuuccuucguuccggccccuuccagcgaapcapcuccgag\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "init_g = 0\n", + "opt_g = 0\n", + "optimus_g = 0\n", + "nat_g = 0\n", + "\n", + "start = time.time()\n", + "\n", + "t = has_gquad(inits[0])\n", + "\n", + "end = time.time()\n", + "\n", + "print(end-start)\n", + "\n", + "print(\"starting inits\")\n", + "\n", + "for i in range(len(inits)):\n", + " if has_gquad(inits[i]):\n", + " init_g += 1\n", + "\n", + "print(\"starting opts\")\n", + "\n", + "\n", + "for i in range(len(opts)):\n", + " if has_gquad(opts[i]):\n", + " opt_g += 1\n", + "\n", + "print(\"starting optimus\")\n", + "\n", + "for i in range(len(optimus)):\n", + " if has_gquad(optimus[i]):\n", + " opt_g += 1\n", + "\n", + "print(\"starting nats\")\n", + "\n", + "for i in range(len(nats)):\n", + " if has_gquad(nats[i]):\n", + " nat_g += 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "98\n", + "28\n", + "89.92\n", + "0\n" + ] + } + ], + "source": [ + "print(init_g)\n", + "print(opt_g)\n", + "print(nat_g/32000.*1024)\n", + "print(optimus_g)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "checkpoint: 1000\n", + "checkpoint: 2000\n", + "checkpoint: 3000\n", + "checkpoint: 4000\n", + "checkpoint: 5000\n", + "checkpoint: 6000\n", + "checkpoint: 7000\n", + "checkpoint: 8000\n", + "checkpoint: 9000\n", + "checkpoint: 10000\n", + "checkpoint: 11000\n", + "checkpoint: 12000\n", + "checkpoint: 13000\n", + "checkpoint: 14000\n", + "checkpoint: 15000\n", + "checkpoint: 16000\n", + "checkpoint: 17000\n", + "checkpoint: 18000\n", + "checkpoint: 19000\n", + "checkpoint: 20000\n", + "checkpoint: 21000\n", + "checkpoint: 22000\n", + "checkpoint: 23000\n", + "checkpoint: 24000\n", + "checkpoint: 25000\n", + "checkpoint: 26000\n", + "checkpoint: 27000\n", + "checkpoint: 28000\n", + "checkpoint: 29000\n", + "checkpoint: 30000\n", + "checkpoint: 31000\n", + "checkpoint: 32000\n", + "checkpoint: 33000\n", + "checkpoint: 34000\n", + "checkpoint: 35000\n", + "checkpoint: 36000\n", + "checkpoint: 37000\n", + "checkpoint: 38000\n", + "checkpoint: 39000\n", + "checkpoint: 40000\n", + "checkpoint: 41000\n", + "checkpoint: 42000\n", + "checkpoint: 43000\n", + "checkpoint: 44000\n", + "checkpoint: 45000\n", + "checkpoint: 46000\n", + "checkpoint: 47000\n", + "checkpoint: 48000\n", + "checkpoint: 49000\n", + "checkpoint: 50000\n", + "checkpoint: 51000\n", + "checkpoint: 52000\n", + "checkpoint: 53000\n", + "checkpoint: 54000\n", + "checkpoint: 55000\n", + "checkpoint: 56000\n", + "checkpoint: 57000\n", + "checkpoint: 58000\n", + "checkpoint: 59000\n", + "checkpoint: 60000\n", + "checkpoint: 61000\n", + "checkpoint: 62000\n", + "checkpoint: 63000\n", + "checkpoint: 64000\n", + "checkpoint: 65000\n", + "checkpoint: 66000\n", + "checkpoint: 67000\n", + "checkpoint: 68000\n", + "checkpoint: 69000\n", + "checkpoint: 70000\n", + "checkpoint: 71000\n", + "checkpoint: 72000\n", + "checkpoint: 73000\n", + "checkpoint: 74000\n", + "checkpoint: 75000\n", + "checkpoint: 76000\n", + "checkpoint: 77000\n", + "checkpoint: 78000\n", + "checkpoint: 79000\n", + "checkpoint: 80000\n", + "checkpoint: 81000\n", + "checkpoint: 82000\n", + "checkpoint: 83000\n", + "checkpoint: 84000\n", + "checkpoint: 85000\n", + "checkpoint: 86000\n", + "checkpoint: 87000\n", + "checkpoint: 88000\n", + "checkpoint: 89000\n", + "checkpoint: 90000\n", + "checkpoint: 91000\n", + "checkpoint: 92000\n", + "checkpoint: 93000\n", + "checkpoint: 94000\n", + "checkpoint: 95000\n", + "checkpoint: 96000\n", + "checkpoint: 97000\n", + "checkpoint: 98000\n", + "checkpoint: 99000\n", + "checkpoint: 100000\n", + "checkpoint: 101000\n", + "checkpoint: 102000\n", + "checkpoint: 103000\n", + "checkpoint: 104000\n", + "checkpoint: 105000\n", + "checkpoint: 106000\n", + "checkpoint: 107000\n", + "checkpoint: 108000\n", + "checkpoint: 109000\n", + "checkpoint: 110000\n", + "checkpoint: 111000\n", + "checkpoint: 112000\n", + "checkpoint: 113000\n", + "checkpoint: 114000\n", + "checkpoint: 115000\n", + "checkpoint: 116000\n", + "checkpoint: 117000\n", + "checkpoint: 118000\n", + "checkpoint: 119000\n", + "checkpoint: 120000\n", + "checkpoint: 121000\n", + "checkpoint: 122000\n", + "checkpoint: 123000\n", + "checkpoint: 124000\n", + "checkpoint: 125000\n", + "checkpoint: 126000\n", + "checkpoint: 127000\n", + "checkpoint: 128000\n", + "checkpoint: 129000\n", + "checkpoint: 130000\n", + "checkpoint: 131000\n", + "checkpoint: 132000\n", + "checkpoint: 133000\n", + "checkpoint: 134000\n", + "checkpoint: 135000\n", + "checkpoint: 136000\n", + "checkpoint: 137000\n", + "checkpoint: 138000\n", + "checkpoint: 139000\n", + "checkpoint: 140000\n", + "checkpoint: 141000\n", + "checkpoint: 142000\n", + "checkpoint: 143000\n", + "checkpoint: 144000\n", + "checkpoint: 145000\n", + "checkpoint: 146000\n", + "checkpoint: 147000\n", + "checkpoint: 148000\n", + "checkpoint: 149000\n", + "checkpoint: 150000\n", + "checkpoint: 151000\n", + "checkpoint: 152000\n", + "checkpoint: 153000\n", + "checkpoint: 154000\n", + "checkpoint: 155000\n", + "checkpoint: 156000\n", + "checkpoint: 157000\n", + "checkpoint: 158000\n", + "checkpoint: 159000\n", + "checkpoint: 160000\n", + "checkpoint: 161000\n", + "checkpoint: 162000\n", + "checkpoint: 163000\n", + "checkpoint: 164000\n", + "checkpoint: 165000\n", + "checkpoint: 166000\n", + "checkpoint: 167000\n", + "checkpoint: 168000\n", + "checkpoint: 169000\n", + "checkpoint: 170000\n", + "checkpoint: 171000\n", + "checkpoint: 172000\n", + "checkpoint: 173000\n", + "checkpoint: 174000\n", + "checkpoint: 175000\n", + "checkpoint: 176000\n", + "checkpoint: 177000\n", + "checkpoint: 178000\n", + "checkpoint: 179000\n", + "checkpoint: 180000\n", + "checkpoint: 181000\n", + "checkpoint: 182000\n", + "checkpoint: 183000\n", + "checkpoint: 184000\n", + "checkpoint: 185000\n", + "checkpoint: 186000\n", + "checkpoint: 187000\n", + "checkpoint: 188000\n", + "checkpoint: 189000\n", + "checkpoint: 190000\n", + "checkpoint: 191000\n", + "checkpoint: 192000\n", + "checkpoint: 193000\n", + "checkpoint: 194000\n", + "checkpoint: 195000\n", + "checkpoint: 196000\n", + "checkpoint: 197000\n", + "checkpoint: 198000\n", + "checkpoint: 199000\n", + "checkpoint: 200000\n", + "checkpoint: 201000\n", + "checkpoint: 202000\n", + "checkpoint: 203000\n", + "checkpoint: 204000\n", + "checkpoint: 205000\n", + "checkpoint: 206000\n", + "checkpoint: 207000\n", + "checkpoint: 208000\n", + "checkpoint: 209000\n", + "checkpoint: 210000\n", + "checkpoint: 211000\n", + "checkpoint: 212000\n", + "checkpoint: 213000\n", + "checkpoint: 214000\n", + "checkpoint: 215000\n", + "checkpoint: 216000\n", + "checkpoint: 217000\n", + "checkpoint: 218000\n", + "checkpoint: 219000\n", + "checkpoint: 220000\n", + "checkpoint: 221000\n", + "checkpoint: 222000\n", + "checkpoint: 223000\n", + "checkpoint: 224000\n", + "checkpoint: 225000\n", + "checkpoint: 226000\n", + "checkpoint: 227000\n", + "checkpoint: 228000\n", + "checkpoint: 229000\n", + "checkpoint: 230000\n", + "checkpoint: 231000\n", + "checkpoint: 232000\n", + "checkpoint: 233000\n", + "checkpoint: 234000\n", + "checkpoint: 235000\n", + "checkpoint: 236000\n", + "checkpoint: 237000\n", + "checkpoint: 238000\n", + "checkpoint: 239000\n", + "checkpoint: 240000\n", + "checkpoint: 241000\n", + "checkpoint: 242000\n", + "checkpoint: 243000\n", + "checkpoint: 244000\n", + "checkpoint: 245000\n", + "checkpoint: 246000\n", + "checkpoint: 247000\n", + "checkpoint: 248000\n", + "checkpoint: 249000\n", + "checkpoint: 250000\n", + "checkpoint: 251000\n", + "checkpoint: 252000\n", + "checkpoint: 253000\n", + "checkpoint: 254000\n", + "checkpoint: 255000\n", + "checkpoint: 256000\n", + "checkpoint: 257000\n", + "checkpoint: 258000\n", + "checkpoint: 259000\n", + "checkpoint: 260000\n", + "checkpoint: 261000\n", + "checkpoint: 262000\n", + "checkpoint: 263000\n", + "checkpoint: 264000\n", + "checkpoint: 265000\n", + "checkpoint: 266000\n", + "checkpoint: 267000\n", + "checkpoint: 268000\n", + "checkpoint: 269000\n", + "checkpoint: 270000\n", + "checkpoint: 271000\n", + "checkpoint: 272000\n", + "checkpoint: 273000\n", + "checkpoint: 274000\n", + "checkpoint: 275000\n", + "checkpoint: 276000\n", + "checkpoint: 277000\n", + "checkpoint: 278000\n", + "checkpoint: 279000\n", + "checkpoint: 280000\n", + "checkpoint: 281000\n", + "checkpoint: 282000\n", + "checkpoint: 283000\n", + "checkpoint: 284000\n", + "checkpoint: 285000\n", + "checkpoint: 286000\n", + "checkpoint: 287000\n", + "checkpoint: 288000\n", + "checkpoint: 289000\n", + "checkpoint: 290000\n", + "checkpoint: 291000\n", + "checkpoint: 292000\n", + "checkpoint: 293000\n", + "checkpoint: 294000\n", + "checkpoint: 295000\n", + "checkpoint: 296000\n", + "checkpoint: 297000\n", + "checkpoint: 298000\n", + "checkpoint: 299000\n", + "checkpoint: 300000\n", + "checkpoint: 301000\n", + "checkpoint: 302000\n", + "checkpoint: 303000\n", + "checkpoint: 304000\n", + "checkpoint: 305000\n", + "checkpoint: 306000\n", + "checkpoint: 307000\n", + "checkpoint: 308000\n", + "checkpoint: 309000\n", + "checkpoint: 310000\n", + "checkpoint: 311000\n", + "checkpoint: 312000\n", + "checkpoint: 313000\n", + "checkpoint: 314000\n", + "checkpoint: 315000\n", + "checkpoint: 316000\n", + "checkpoint: 317000\n", + "checkpoint: 318000\n", + "checkpoint: 319000\n", + "checkpoint: 320000\n", + "checkpoint: 321000\n", + "checkpoint: 322000\n", + "checkpoint: 323000\n", + "checkpoint: 324000\n", + "checkpoint: 325000\n", + "checkpoint: 326000\n", + "checkpoint: 327000\n", + "checkpoint: 328000\n", + "checkpoint: 329000\n", + "checkpoint: 330000\n", + "checkpoint: 331000\n", + "checkpoint: 332000\n", + "checkpoint: 333000\n", + "checkpoint: 334000\n", + "checkpoint: 335000\n", + "checkpoint: 336000\n", + "checkpoint: 337000\n", + "checkpoint: 338000\n", + "checkpoint: 339000\n", + "checkpoint: 340000\n", + "checkpoint: 341000\n", + "checkpoint: 342000\n", + "checkpoint: 343000\n", + "checkpoint: 344000\n", + "checkpoint: 345000\n", + "checkpoint: 346000\n", + "checkpoint: 347000\n", + "checkpoint: 348000\n", + "checkpoint: 349000\n", + "checkpoint: 350000\n", + "checkpoint: 351000\n", + "checkpoint: 352000\n", + "checkpoint: 353000\n", + "checkpoint: 354000\n", + "checkpoint: 355000\n", + "checkpoint: 356000\n", + "checkpoint: 357000\n", + "checkpoint: 358000\n", + "checkpoint: 359000\n", + "checkpoint: 360000\n", + "checkpoint: 361000\n", + "checkpoint: 362000\n", + "checkpoint: 363000\n", + "checkpoint: 364000\n", + "checkpoint: 365000\n", + "checkpoint: 366000\n", + "checkpoint: 367000\n", + "checkpoint: 368000\n", + "checkpoint: 369000\n", + "checkpoint: 370000\n", + "checkpoint: 371000\n", + "checkpoint: 372000\n", + "checkpoint: 373000\n", + "checkpoint: 374000\n", + "checkpoint: 375000\n", + "checkpoint: 376000\n", + "checkpoint: 377000\n", + "checkpoint: 378000\n", + "checkpoint: 379000\n", + "checkpoint: 380000\n", + "checkpoint: 381000\n", + "checkpoint: 382000\n", + "checkpoint: 383000\n", + "checkpoint: 384000\n", + "checkpoint: 385000\n", + "checkpoint: 386000\n", + "checkpoint: 387000\n", + "checkpoint: 388000\n", + "checkpoint: 389000\n", + "checkpoint: 390000\n", + "checkpoint: 391000\n", + "checkpoint: 392000\n", + "checkpoint: 393000\n", + "checkpoint: 394000\n", + "checkpoint: 395000\n", + "checkpoint: 396000\n", + "checkpoint: 397000\n", + "checkpoint: 398000\n", + "checkpoint: 399000\n", + "checkpoint: 400000\n", + "checkpoint: 401000\n", + "checkpoint: 402000\n" + ] + } + ], + "source": [ + "init_c = 0\n", + "opt_c = 0\n", + "optimus_c = 0\n", + "nat_c = 0\n", + "\n", + "for i in range(len(seqs)):\n", + " if i != 0 and i % 1000 == 0:\n", + " print(f\"checkpoint: {i}\")\n", + " for j in range(len(nats)):\n", + " if seqs[i] in nats[j]:\n", + " nat_c += 1\n", + " for j in range(len(inits)):\n", + " if seqs[i] in inits[j]:\n", + " init_c += 1\n", + " for j in range(len(opts)):\n", + " if seqs[i] in opts[j]:\n", + " opt_c += 1\n", + " for j in range(len(optimus)):\n", + " if seqs[i] in optimus[j]:\n", + " optimus_c += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "kozaks = ['AAAAAAAUG','GCCGCCAUG','ACAGCAAUG','AACACCAUG','GAAGCAAUG','GCAACAAUG',\n", + " 'ACAACCAUG','ACAGACAUG','GCACAAAUG','GCAAACAUG','GACAACAUG','GACACAAUG',\n", + " 'GAAACCAUG','ACCACAAUG','GAAGACAUG','ACCAACAUG','AACGCAAUG','GACGAAAUG','ACCGAAAUG']\n", + "starts = ['AUG','GUG','CUG','AUA']\n", + "# starts = ['AUG']\n", + "\n", + "kozak_t = []\n", + "for i in range(len(kozaks)):\n", + " for j in range(len(starts)):\n", + " kozak_t.append(kozaks[i][:-3]+starts[j])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AAAAAAAUG\n" + ] + } + ], + "source": [ + "print(kozak_t[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AGACAAGGUUUCCCUCUGUAACCCAGGCUGGAGUGCAGUGGAACUUCUGAGCUCAAGUAGUCUUCACAUCUCAGCCUUCCAAGUAGCUGUGACUAGAG\n" + ] + } + ], + "source": [ + "print(nats[4])" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "nat_k = 0\n", + "init_k = 0\n", + "opt_k = 0\n", + "optimus_k = 0\n", + "\n", + "kozaks = kozak_t\n", + "# kozaks = [starts[0]]\n", + "\n", + "for i in range(len(kozaks)):\n", + " if i != 0 and i % 1000 == 0:\n", + " print(f\"checkpoint: {i}\")\n", + " for j in range(len(nats)):\n", + " if kozaks[i] in nats[j]:\n", + " nat_k += 1\n", + " for j in range(len(inits)):\n", + " if kozaks[i] in inits[j]:\n", + " init_k += 1\n", + " for j in range(len(opts)):\n", + " if kozaks[i] in opts[j]:\n", + " opt_k += 1\n", + " for j in range(len(optimus)):\n", + " if kozaks[i] in optimus[j]:\n", + " optimus_k += 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "nat_pos = []\n", + "init_pos = []\n", + "opt_pos = []\n", + "optimus_pos = []\n", + "\n", + "kozaks = kozaks\n", + "\n", + "for i in range(len(kozaks)):\n", + " if i != 0 and i % 1000 == 0:\n", + " print(f\"checkpoint: {i}\")\n", + " for j in range(len(nats)):\n", + " if kozaks[i] in nats[j]:\n", + " t = nats[j].find(kozaks[i])\n", + " nat_pos.append(len(nats[j])-t)\n", + " for j in range(len(inits)):\n", + " if kozaks[i] in inits[j]:\n", + " t = inits[j].find(kozaks[i])\n", + " init_pos.append(len(inits[j])-t)\n", + " for j in range(len(opts)):\n", + " if kozaks[i] in opts[j]:\n", + " t = opts[j].find(kozaks[i])\n", + " opt_pos.append(len(opts[j])-t)\n", + " for j in range(len(optimus)):\n", + " if kozaks[i] in optimus[j]:\n", + " t = optimus[j].find(kozaks[i])\n", + " optimus_pos.append(len(optimus[j])-t)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "55.89917936694021\n", + "60.76\n", + "48.38095238095238\n", + "17.333333333333332\n" + ] + } + ], + "source": [ + "print(np.average(nat_pos))\n", + "print(np.average(init_pos))\n", + "print(np.average(opt_pos))\n", + "print(np.average(optimus_pos))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27.296\n", + "42\n", + "25\n", + "9\n" + ] + } + ], + "source": [ + "print(nat_k/32000.*1024)\n", + "print(opt_k)\n", + "print(init_k)\n", + "print(optimus_k)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tf25", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/conf/analysis/utils/__init__.py b/conf/analysis/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/conf/analysis/utils/__pycache__/__init__.cpython-310.pyc b/conf/analysis/utils/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94f6f2d1c2b5db0298677c7c3e19a592d5c2d076 Binary files /dev/null and b/conf/analysis/utils/__pycache__/__init__.cpython-310.pyc differ diff --git a/conf/analysis/utils/__pycache__/framepool.cpython-310.pyc b/conf/analysis/utils/__pycache__/framepool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1fe358db7dc3c232e13782f92ff90d95339698dd Binary files /dev/null and b/conf/analysis/utils/__pycache__/framepool.cpython-310.pyc differ diff --git a/conf/analysis/utils/__pycache__/util.cpython-310.pyc b/conf/analysis/utils/__pycache__/util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af85ae4f5b1021bf80887f6a524269ffb0fc2d4c Binary files /dev/null and b/conf/analysis/utils/__pycache__/util.cpython-310.pyc differ diff --git a/conf/analysis/utils/framepool.py b/conf/analysis/utils/framepool.py new file mode 100644 index 0000000000000000000000000000000000000000..1ddb50e033ee6fc26003609f9a1bc1a0f5601575 --- /dev/null +++ b/conf/analysis/utils/framepool.py @@ -0,0 +1,172 @@ +import numpy as np +import pandas as pd +import tensorflow as tf +from tensorflow.keras import backend as K +from tensorflow.keras.models import load_model +from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping +from tensorflow.keras.layers import Input, Dense, Conv1D, GlobalMaxPooling1D, GlobalAveragePooling1D, Dropout, Concatenate, Lambda, Flatten, ZeroPadding1D, MaxPooling1D, BatchNormalization, ThresholdedReLU, Masking, Add, LSTM, SpatialDropout1D +from tensorflow.keras.models import Model +from tensorflow.keras.layers import Layer +from tensorflow.keras import losses +from tensorflow.keras.utils import Sequence +tf.compat.v1.enable_eager_execution() + + +def apply_pad_mask(input_tensors): + tensor = input_tensors[0] + mask = input_tensors[1] + mask = K.expand_dims(mask, axis=2) + return tf.multiply(tensor, mask) + +class LogNonhomogenousGeometric(Layer): + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def build(self, input_shape): + super().build(input_shape) + + def call(self, x): + log_P = tf.log_sigmoid(x) + log_inverse_P = -x + log_P + cumul_P = tf.cumsum(log_inverse_P, axis=1, exclusive=True) # exclusive ensures correct index + Q = log_P + cumul_P + return Q + + def compute_output_shape(self, input_shape): + return input_shape + +# Function to compute an interaction term between a value and a one-hot vector +def interaction_term(tensors): + prediction = tensors[0] + experiment_indicator = tensors[1] + return tf.multiply(prediction, experiment_indicator) + +# Layer which slices input tensor into three tensors, one for each frame w.r.t. the canonical start +class FrameSliceLayer(Layer): + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def build(self, input_shape): + super().build(input_shape) + + def call(self, x): + shape = K.shape(x) + x = K.reverse(x, axes=1) # reverse, so that frameness is related to fixed point (start codon) + frame_1 = tf.gather(x, K.arange(start=0, stop=shape[1], step=3), axis=1) + frame_2 = tf.gather(x, K.arange(start=1, stop=shape[1], step=3), axis=1) + frame_3 = tf.gather(x, K.arange(start=2, stop=shape[1], step=3), axis=1) + return [frame_1, frame_2, frame_3] + + def compute_output_shape(self, input_shape): + if len(input_shape) == 2: + return [(input_shape[0], None),(input_shape[0], None),(input_shape[0], None)] + return [(input_shape[0], None, input_shape[2]),(input_shape[0], None, input_shape[2]),(input_shape[0], None, input_shape[2])] + +# Masking to prevent zero padding to influence results +def compute_pad_mask(x): + return K.sum(x, axis=2) + +def apply_pad_mask(input_tensors): + tensor = input_tensors[0] + mask = input_tensors[1] + mask = K.expand_dims(mask, axis=2) + return tf.multiply(tensor, mask) + +# Average pooling that accounts for masking +def global_avg_pool_masked(input_tensors): + tensor = input_tensors[0] + mask = input_tensors[1] + mask = K.expand_dims(mask, axis=2) + return K.sum(tensor, axis=1)/K.sum(mask, axis=1) + +def convolve_and_mask(conv_features, pad_mask, n_filters, kernel_size, suffix, prefix="", + padding="causal", dilation=1, batchnorm=False, conv_dropout=0.0): + convolution = Conv1D(filters=n_filters, kernel_size=kernel_size, dilation_rate=dilation, activation='relu', + padding=padding, name=prefix+"convolution_"+suffix) + conv_features = convolution(conv_features) + conv_features = Lambda(apply_pad_mask, name=prefix+"apply_pad_mask_"+suffix)([conv_features, pad_mask]) # Mask padding + if batchnorm: + conv_features = BatchNormalization(axis=2, name="batchnorm_"+suffix)(conv_features) + if conv_dropout > 0.0: + conv_features = SpatialDropout1D(conv_dropout, name=prefix+"1d_dropout_"+suffix)(conv_features) + return conv_features + +def inception_block(conv_features, pad_mask, n_filters, suffix, prefix=""): + conv_features_3 = convolve_and_mask(conv_features, pad_mask, n_filters[0], kernel_size=3, suffix="incept3_"+suffix, prefix=prefix) + conv_features_5 = convolve_and_mask(conv_features, pad_mask, n_filters[1], kernel_size=5, suffix="incept5_"+suffix, prefix=prefix) + conv_features_7 = convolve_and_mask(conv_features, pad_mask, n_filters[2], kernel_size=7, suffix="incept7_"+suffix, prefix=prefix) + conv_features = Concatenate(name="incept_concat"+suffix)([conv_features_3, conv_features_5, conv_features_7]) + return conv_features + +def create_frame_slice_model(n_conv_layers=3, + kernel_size=[8,8,8], n_filters=128, dilations=[1, 1, 1], + padding="causal", use_batchnorm=False, + conv_dropout=[0.0, 0.0, 0.0], + use_inception=False, skip_connections="", + n_dense_layers=1, fc_neurons=[64], fc_drop_rate=0.2, + only_max_pool=False, + loss='mean_squared_error', + use_counter_input=False, + use_scaling_regression=False, library_size=6): + # Inputs + input_seq = Input(shape=(None, 4), name="input_seq") + inputs = input_seq + conv_features = input_seq + # Compute presence of zero padding + pad_mask = Lambda(compute_pad_mask, name="compute_pad_mask")(conv_features) + + layer_list = [] + for i in range(n_conv_layers): + if skip_connections: + conv_features_shortcut = conv_features #shortcut connections + if use_inception: + conv_features = inception_block(conv_features, pad_mask, n_filters, suffix=str(i)) + else: + conv_features = convolve_and_mask(conv_features, pad_mask, n_filters, kernel_size[i], + suffix=str(i), padding=padding, + dilation=dilations[i], + batchnorm=use_batchnorm, + conv_dropout=conv_dropout[i]) + if skip_connections == "residual" and i > 0: + conv_features = Add(name="add_residual_"+str(i))([conv_features, conv_features_shortcut]) + elif skip_connections == "dense": + conv_features = Concatenate(axis=-1, name="concat_dense_"+str(i))([conv_features, + conv_features_shortcut]) + # Frame based masking + frame_masked_features = FrameSliceLayer(name="frame_masking")(conv_features) + frame_masked_pad_mask = FrameSliceLayer(name="frame_masking_padmask")(pad_mask) + # Pooling + pooled_features = [] + max_pooling = GlobalMaxPooling1D(name="pool_max_frame_conv") + avg_pooling = Lambda(global_avg_pool_masked, name="pool_avg_frame_conv") + pooled_features = pooled_features + \ + [max_pooling(frame_masked_features[i]) for i in range(len(frame_masked_features))] + if not only_max_pool: + pooled_features = pooled_features + [avg_pooling([frame_masked_features[i], frame_masked_pad_mask[i]]) for i in + range(len(frame_masked_features))] + pooled_features = Concatenate(axis=-1, name="concatenate_pooled")(pooled_features) + # Add tis_context if necessary + concat_features = pooled_features + # Prediction (Dense layer) + predict = concat_features + for i in range(n_dense_layers): + predict = Dense(fc_neurons[i], activation='relu', name="fully_connected_"+str(i))(predict) + predict = Dropout(rate=fc_drop_rate, name="fc_dropout_"+str(i))(predict) + predict = Dense(1, name="mrl_output_unscaled")(predict) + + model = Model(inputs=inputs, outputs=predict) + adam = tf.keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) + model.compile(loss=loss, optimizer=adam) + return model + +def load_framepool(path): + model = create_frame_slice_model(kernel_size=[7,7,7], + only_max_pool=False, + padding="same", + skip_connections="residual", + use_scaling_regression=True, library_size=2) + + model.load_weights(path) + return model \ No newline at end of file diff --git a/conf/analysis/utils/util.py b/conf/analysis/utils/util.py new file mode 100644 index 0000000000000000000000000000000000000000..f198827a22feb4f3390d10f73feec527b4978d43 --- /dev/null +++ b/conf/analysis/utils/util.py @@ -0,0 +1,362 @@ +import os +import operator +import pickle +import time +import seaborn as sns +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np +import math +import itertools +import random +import os +from polyleven import levenshtein +import operator +import pickle +import time +import tensorflow as tf + +tf.random.set_seed(35) +np.random.seed(35) + +rna_vocab = {"A":0, + "C":1, + "G":2, + "U":3, + "*":4} + +rev_rna_vocab = {v:k for k,v in rna_vocab.items()} + +def recover_seq(samples, rev_charmap=rev_rna_vocab): + """Convert samples to strings and save to log directory.""" + + char_probs = samples + argmax = np.argmax(char_probs, 2) + seqs = [] + for line in argmax: + s = "".join(rev_charmap[d] for d in line) + s = s.replace('*','') + s = s.replace('U','T') + seqs.append(s) + return seqs + +def file_to_list(file_name,size): + data = [] + with open(file_name,'r') as f: + lines = f.readlines() + + for seq in lines: + seq_ = seq.replace('\n','') + data.append(seq_) + # if len(seq) == size: + # data.append(seq) + + return data + +def one_hot_encode(seq): + mapping = dict(zip("ACGT", range(4))) + seq = seq.replace('U','T') + seq2 = [mapping[i] for i in seq] + return np.eye(4)[seq2] + +def encode(seqs): + return np.reshape([one_hot_encode(seqs[i]) for i in range(len(seqs))],(np.array(seqs).shape[0],-1)) + +min_len = None +nuc_dict = {'a':[1.0,0.0,0.0,0.0],'c':[0.0,1.0,0.0,0.0],'g':[0.0,0.0,1.0,0.0], + 'u':[0.0,0.0,0.0,1.0], 't':[0.0,0.0,0.0,1.0], + 'n':[0.0,0.0,0.0,0.0], 'x':[1/4,1/4,1/4,1/4]} + +def encode_seq_framepool(seq, max_len=128): + # print(seq) + length = len(seq) + if max_len > 0 and min_len is None: + padding_needed = max_len - length + seq = "N"*padding_needed + seq + if min_len is not None: + if len(seq) < min_len: + seq = "N"*(min_len - len(seq)) + seq + + if len(seq) > min_len: + seq = seq[(len(seq) - min_len):] + seq = seq.lower() + one_hot = np.array([nuc_dict[x] for x in seq]) # get stacked on top of each other + + return one_hot + +def list_to_file(filename,list): + with open(filename + ".txt", 'w') as f: + for element in list[:-1]: + f.write(element+"\n") + f.write(list[-1]) + +def tsne_natural(file_name, length, key='seq'): + df = pd.read_csv(file_name) + seqs = np.array(df[key]).tolist() + + selected_seqs = [] + + for i in range(len(seqs)): + seq = seqs[i] + seq = seq.upper() + if seq not in selected_seqs and len(seq) == length: + selected_seqs.append(seq) + + return selected_seqs + +def read_real(file_name, UTR_LEN, key='seq', all= True, samples= 128 ): + df = pd.read_csv(file_name) + seqs = np.array(df[key]).tolist() + + selected_seqs = [] + + for i in range(len(seqs)): + if len(seqs[i]) < (UTR_LEN + 1) and len(seqs[i]) > int(UTR_LEN/2): + seqs[i] = seqs[i].upper() + if seqs[i] not in selected_seqs: + selected_seqs.append(seqs[i]) + + if all: + return selected_seqs + + else: + indices = [] + + for i in range(len(selected_seqs)): + + indices.append(i) + + samples = np.random.choice(len(indices),samples,replace=False) + + chosen = [] + + for i in range(len(samples)): + chosen.append(selected_seqs[samples[i]]) + + return chosen + +def random_sample(length): + rna_vocab = {"A":0, + "C":1, + "G":2, + "T":3} + + rev_rna_vocab = {v:k for k,v in rna_vocab.items()} + + mapping = dict(zip([0,1,2,3],"ACGT")) + gc_limit = random.randrange(2,9) + gc_limit = float(gc_limit)/10 + gc_limit = 0.6 + sample = '' + for i in range(length): + r = random.random() + if r < gc_limit: + sample += random.choice(['C','G']) + else: + sample += random.choice(['A','T']) + + return sample + +def random_data(length, size): + samples = [] + for i in range(size): + samples.append(random_sample(length)) + + return samples + +def tsne_gen(path,length=128,BATCH_SIZE=64,DIM=40): + wgan = tf.keras.models.load_model(path) + + selected = [] + while len(selected) < BATCH_SIZE: + + noise = tf.Variable(tf.random.normal(shape=[64,DIM])) + + sequences_init = wgan(noise) + + gen_seqs_init = sequences_init.numpy().astype('float') + + seqs_gen_init = recover_seq(gen_seqs_init, rev_rna_vocab) + + for i in range(len(seqs_gen_init)): + if len(seqs_gen_init[i]) == length: + selected.append(seqs_gen_init[i]) + + return selected[:BATCH_SIZE] + +def generate_data(path,BATCH_SIZE=64,UTR_LEN=128,DIM=40): + wgan = tf.keras.models.load_model(path) + + gens = [] + + while len(gens) < BATCH_SIZE: + + noise = tf.Variable(tf.random.normal(shape=[BATCH_SIZE,DIM])) + + sequences_init = wgan(noise) + + gen_seqs_init = sequences_init.numpy().astype('float') + + seqs_gen_init = recover_seq(gen_seqs_init, rev_rna_vocab) + + for i in range(len(seqs_gen_init)): + if len(seqs_gen_init[i]) > int(UTR_LEN/2) and len(seqs_gen_init[i])< UTR_LEN+1: + gens.append(seqs_gen_init[i]) + if len(gens) == BATCH_SIZE: + break + + return gens[:BATCH_SIZE] + +def gc_percentage(seq): + count = 0.0 + for char in seq: + if char == 'C' or char == 'G': + count +=1 + + return float(count/len(seq)) + +def get_gc_content(data): + gc_content = [] + for seq in data: + seq.replace('\n','') + seq.replace('*','') + gc = gc_percentage(seq) + gc_content.append(gc) + + return gc_content + +def get_gc_content_many(data): + + collection = [] + gc_contents = [] + for seq in data: + seq = seq.upper() + seq.replace('\n','') + seq.replace('*','') + gc = gc_percentage(seq) + gc_contents.append(gc) + + return gc_contents + +def get_4mers(): + neucs = ['A','C','G','T'] + + mers = [p for p in itertools.product(neucs, repeat=4)] + for i in range(len(mers)): + mers[i] = mers[i][0] + mers[i][1] + mers[i][2] + mers[i][3] + + return mers + +def get_4mer_dic(seqs): + + _4mers = get_4mers() + length = 0 + dics = [] + c = 0 + for seq in seqs: + c += 1 + # dic = {} + dic = [] + for item in _4mers: + dic.append(0) + + # Iterate With the Sliding Window + length = len(seq) + limit = length - 4 + for i in range(limit): + mer = seq[i:i+4] + indx = _4mers.index(mer) + dic[indx] += 1 + + dics.append(dic) + + if c % 2000 == 0: + print("YUE") + + return dics + +def euclidean_kmer(item, ref, mers): + dist = 0 + # diff = np.linalg.norm(item-re) + for mer in range(len(mers)): + + diff = item[mer] - ref[mer] + dist += diff * diff + + return math.sqrt(dist) + +def euclidean_kmer_all(item,refs,mers): + dists = [] + for ref in refs: + dist = euclidean_kmer(item,ref,mers) + if dist > 0: + dists.append(dist) + + return min(dists) + +def kmer_dist_list(source, target, mers): + dists = [] + for item in source: + dists.append(euclidean_kmer_all(item, target, mers)) + + return dists + +def calc_dist_kmer(source,target): + mers = get_4mers() + source_dic = get_4mer_dic(source) + target_dic = get_4mer_dic(target) + print("Dicts Processed") + dists = kmer_dist_list(source_dic, target_dic, mers) + + return dists + +def hamming_dist(src, target): + + dists = [] + for i in range(len(src)): + smallest = np.inf + for j in range(len(target)): + dist = levenshtein(src[i],target[j]) + if dist > 0 and dist < smallest: + smallest = dist + + dists.append(dist) + + return np.array(dists) + + + + + + + + +def one_hot_motif(seq,length=128,complementary=False): + """ + one_hot encoding on sequence + complementary: encode nucleatide into complementary one + """ + + if length == -1: + length = len(seq) + + # seq = str(seq) + # setting + seq = list(seq.replace("U","T")) + seq_len = len(seq) + complementary = -1 if complementary else 1 + # compose dict + keys = ['A', 'C', 'G', 'T'][::complementary] + oh_dict = {keys[i]:i for i in range(4)} + # array + oh_array = np.zeros((length,4)) + for i,C in enumerate(seq): + try: + oh_array[i,oh_dict[C]]=1 + except: + continue # for nucleotide that are not in A C G T + return oh_array + +def one_hot_all_motif(seqs): + length = np.max([len(seq) for seq in seqs]) + return [one_hot_motif(seqs[i], length = 128) for i in range(len(seqs))] \ No newline at end of file diff --git a/conf/analysis/violin.py b/conf/analysis/violin.py new file mode 100644 index 0000000000000000000000000000000000000000..1a8bfc9f8d025983e1600e643a515165cebb1da5 --- /dev/null +++ b/conf/analysis/violin.py @@ -0,0 +1,567 @@ +from matplotlib import colors +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import random +from scipy.stats import ks_2samp,kstest,ttest_ind, mannwhitneyu, norm +from cliffs_delta import cliffs_delta +import seaborn as sns +from tqdm import tqdm +import random +random.seed(1337) +import os +import numpy as np +np.random.seed(1337) +import pandas as pd +pd.options.mode.chained_assignment = None +import RNA +from polyleven import levenshtein +import time +import itertools +import tensorflow as tf +from tensorflow.keras import backend as K +from tensorflow.keras.models import load_model +from tensorflow.keras.layers import Layer + +from utils.util import * +from utils.framepool import * + +colors = ["#3c5068", "#acbab6", "#dcd3cd", "#d4a6a6"] + +tf.compat.v1.enable_eager_execution() + +os.environ["CUDA_VISIBLE_DEVICES"] = '-1' + +def ES_CI(d1, d2): + n1 = len(d1) + n2 = len(d2) + + u1 = np.mean(d1) + u2 = np.mean(d2) + + s1 = np.std(d1) + s2 = np.std(d2) + + s = np.sqrt(((n1 - 1) * np.power(s1,2) + (n2 - 1) * np.power(s2,2)) / (n1 + n2 - 2)) + + effect_size = (u1 - u2)/s + effect_size = cliffs_delta(d1, d2) + + + + ct1 = n1 #items in dataset 1 + ct2 = n2 #items in dataset 2 + ds1 = d1 + ds2 = d2 + alpha = 0.05 #95% confidence interval + N = norm.ppf(1 - alpha/2) # percent point function - inverse of cdf + + # The confidence interval for the difference between the two population + # medians is derived through these nxm differences. + diffs = sorted([i-j for i in ds1 for j in ds2]) + + # For an approximate 100(1-a)% confidence interval first calculate K: + k = int(round(ct1*ct2/2 - (N * (ct1*ct2*(ct1+ct2+1)/12)**0.5))) + + # The Kth smallest to the Kth largest of the n x m differences + # ct1 and ct2 should be > ~20 + CI = (diffs[k], diffs[len(diffs)-k]) + + + return effect_size, CI + + +customPalette = {'Generated':colors[0],'Optimus\n5-Prime':colors[3],'Natural\n5\' UTR':colors[1], 'Optimized':colors[2]} + +UTR_LEN = 128 +Z_DIM = 40 +DIM = Z_DIM +BATCH_SIZE = 2048 +MAX_LEN = UTR_LEN +gpath = './../models/checkpoint_3000.h5' +data_path = './../data/utrdb2.csv' +mrl_path = './../models/utr_model_combined_residual_new.h5' + +sns.set() +sns.set_style('ticks') + +#POSTER +params = {'legend.fontsize': 48, + 'figure.figsize': (60, 30), + 'axes.labelsize': 50, + 'axes.titlesize':50, + 'xtick.labelsize':50, + 'ytick.labelsize':50} + +plt.rcParams.update(params) + + +model = load_framepool(mrl_path) + +# gens = generate_data(path=gpath, UTR_LEN=UTR_LEN, BATCH_SIZE=BATCH_SIZE, DIM=DIM) +# gens2 = generate_data(path=gpath, UTR_LEN=UTR_LEN, BATCH_SIZE=4096, DIM=DIM) +BATCH_SIZE=1024 + +gens = read_data('/data4/sina/UTR/UTRGAN/src/mrl_te_optimization/outputs/opt_10000_1024_saved/init_seqs_FMRL_10000.txt') +gens_encoded = np.array([encode_seq_framepool(seq) for seq in gens]) +opts = read_data('/data4/sina/UTR/UTRGAN/src/mrl_te_optimization/outputs/opt_10000_1024_saved/opt_seqs_FMRL_10000.txt') +opts_encoded = np.array([encode_seq_framepool(seq) for seq in opts]) +randoms = random_data(length=UTR_LEN, size=BATCH_SIZE) +randoms = read_optimus() +randoms_encoded = np.array([encode_seq_framepool(seq) for seq in randoms]) +naturals = read_real(data_path, UTR_LEN=UTR_LEN, all=False, samples=BATCH_SIZE) +naturals2 = read_real(data_path, UTR_LEN=UTR_LEN, all=False, samples=10000) +naturals_encoded = np.array([encode_seq_framepool(seq) for seq in naturals]) +naturals_all = read_real(data_path, UTR_LEN=UTR_LEN, all=True) +naturals_encoded_all = np.array([encode_seq_framepool(seq) for seq in naturals_all]) +############################# MRL PREDICTION #################################### + +######### Gens + +gens_tensor = tf.convert_to_tensor(gens_encoded,dtype=tf.float32) +pred_gens = model(gens_tensor) +pred_gens = tf.reshape(pred_gens,(-1)) +genpreds = pred_gens.numpy().astype('float') + +######### Opts + +opts_tensor = tf.convert_to_tensor(opts_encoded,dtype=tf.float32) +pred_opts = model(opts_tensor) +pred_opts = tf.reshape(pred_opts,(-1)) +optpreds = pred_opts.numpy().astype('float') + +######### Randoms + +randoms_tensor = tf.convert_to_tensor(randoms_encoded,dtype=tf.float32) +pred_randoms = model(randoms_tensor) +pred_randoms = tf.reshape(pred_randoms,(-1)) +randpreds = pred_randoms.numpy().astype('float') + +######## Labeled + +naturals_tensors = tf.convert_to_tensor(naturals_encoded_all,dtype=tf.float32) +pred_naturals = model(naturals_tensors) +pred_naturals = tf.reshape(pred_naturals,(-1)) +realpreds = pred_naturals.numpy().astype('float') + +############ + +bins = np.linspace(2.5, 9, 30) + +fig, axs = plt.subplots(2,3) + +real_x = ['Natural\n5\' UTR' for i in range(len(realpreds))] +gen_x = ['Generated' for i in range(len(genpreds))] +opt_x = ['Optimized' for i in range(len(optpreds))] +rand_x = ['Optimus\n5-Prime' for i in range(len(randpreds))] + +x = np.concatenate((gen_x,opt_x,real_x,rand_x)) +y = np.concatenate((genpreds,optpreds,realpreds,randpreds)) + +gent_mrl = ttest_ind(genpreds,realpreds) +optt_mrl = ttest_ind(optpreds,realpreds) +randt_mrl = ttest_ind(randpreds,realpreds) +genu_mrl = mannwhitneyu(genpreds, realpreds) +optu_mrl = mannwhitneyu(optpreds, realpreds) +randu_mrl = mannwhitneyu(randpreds, realpreds) +es_gen_mrl = ES_CI(genpreds,realpreds) +es_opt_mrl = ES_CI(optpreds,realpreds) +es_rand_mrl = ES_CI(randpreds,realpreds) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[1,0],palette=customPalette) + +axs[1,0].set_ylabel("Mean Ribosome Load") +axs[1,0].set_xlabel("") + +############################# MFE PREDICTION #################################### + +genpreds = [] + +for i in range(len(gens)): + (ss, mfe) = RNA.fold(gens[i]) + genpreds.append(mfe) + +optpreds = [] + +for i in range(len(opts)): + (ss, mfe) = RNA.fold(opts[i]) + optpreds.append(mfe) + +randpreds = [] + +for i in range(len(randoms)): + (ss, mfe) = RNA.fold(randoms[i]) + randpreds.append(mfe) + +realpreds = [] + +for i in range(len(naturals_all)): + (ss, mfe) = RNA.fold(naturals_all[i]) + realpreds.append(mfe) + +real_x = ['Natural\n5\' UTR' for i in range(len(realpreds))] +gen_x = ['Generated' for i in range(len(genpreds))] +opt_x = ['Optimized' for i in range(len(optpreds))] +rand_x = ['Optimus\n5-Prime' for i in range(len(randpreds))] + +gent_mfe = ttest_ind(genpreds,realpreds) +optt_mfe = ttest_ind(optpreds,realpreds) +randt_mfe = ttest_ind(randpreds,realpreds) +randu_mfe = mannwhitneyu(randpreds, realpreds) +genu_mfe = mannwhitneyu(genpreds, realpreds) +optu_mfe = mannwhitneyu(optpreds, realpreds) +es_gen_mfe = ES_CI(genpreds,realpreds) +es_opt_mfe = ES_CI(optpreds,realpreds) +es_rand_mfe = ES_CI(randpreds,realpreds) + +x = np.concatenate((gen_x,opt_x,real_x,rand_x)) +y = np.concatenate((genpreds,optpreds,realpreds,randpreds)) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[1,2],palette=customPalette) + +axs[1,2].set_ylabel("Minimum Free Energy") +axs[1,2].set_xlabel("") + +############################# Levenshtein Distance #################################### + + + +DIST = 'S' + +if DIST == 'KMER': + dist_rand = calc_dist_kmer(randoms, naturals) + dist_gen = calc_dist_kmer(gens, naturals) + dist_real = calc_dist_kmer(naturals, naturals) + dist_opt = calc_dist_kmer(opts, naturals) +else: + if os.path.exists('./files/rand_ham_new.npy'): + dist_rand = np.load('./files/rand_ham_new.npy', allow_pickle=True) + else: + dist_rand = hamming_dist(randoms,naturals_all) + with open("./files/rand_ham_new.npy", 'wb') as f: + np.save(f,dist_rand) + + if os.path.exists('./files/real_ham_new.npy'): + dist_real = np.load('./files/real_ham_new.npy', allow_pickle=True) + else: + dist_real = hamming_dist(naturals, naturals_all) + with open("./files/real_ham_new.npy", 'wb') as f: + np.save(f,dist_real) + + if os.path.exists('./files/gen_ham_new.npy'): + dist_gen = np.load('./files/gen_ham_new.npy', allow_pickle=True) + else: + dist_gen = hamming_dist(gens, naturals_all) + with open("./files/gen_ham_new.npy", 'wb') as f: + np.save(f,dist_gen) + + if os.path.exists('./files/opt_ham_new.npy'): + dist_opt = np.load('./files/opt_ham_new.npy', allow_pickle=True) + else: + dist_opt = hamming_dist(opts, naturals_all) + with open("./files/opt_ham_new.npy", 'wb') as f: + np.save(f,dist_opt) + +# filter: +dist_real_filtered = [] +for i in range(len(dist_real)): + if dist_real[i] > 21: + dist_real_filtered.append(dist_real[i]) + + +dist_real = dist_real_filtered + +real_x = ['Natural\n5\' UTR' for i in range(len(dist_real))] +gen_x = ['Generated' for i in range(len(dist_gen))] +opt_x = ['Optimized' for i in range(len(dist_opt))] +rand_x = ['Optimus\n5-Prime' for i in range(len(dist_rand))] + +gent_dist = ttest_ind(dist_gen,dist_real) +optt_dist = ttest_ind(dist_opt,dist_real) +randt_dist = ttest_ind(dist_rand,dist_real) +genu_dist = mannwhitneyu(dist_gen, dist_real) +optu_dist = mannwhitneyu(dist_opt, dist_real) +randu_dist = mannwhitneyu(dist_rand, dist_real) +es_gen_lev = ES_CI(dist_gen,dist_real) +es_opt_lev = ES_CI(dist_opt,dist_real) +es_rand_lev = ES_CI(dist_rand,dist_real) + +x = np.concatenate((gen_x,opt_x,real_x,rand_x)) +y = np.concatenate((dist_gen,dist_opt,dist_real,dist_rand)) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[0,0], palette=customPalette) + +if DIST == 'KMER': + + + axs[0,0].set_ylabel("Min. 4-mer Distance") + axs[0,0].set_xlabel("") + +else: + + axs[0,0].set_ylabel("Min. Levenshtein Distance") + axs[0,0].set_xlabel("") + +############################################################################ + +if os.path.exists('./files/rand_4mer_new.npy'): + dist_rand = np.load('./files/rand_4mer_new.npy', allow_pickle=True) +else: + dist_rand = calc_dist_kmer(randoms, naturals_all) + with open("./files/rand_4mer_new.npy", 'wb') as f: + np.save(f,dist_rand) + +if os.path.exists('./files/real_4mer_new.npy'): + dist_real = np.load('./files/real_4mer_new.npy', allow_pickle=True) +else: + dist_real = calc_dist_kmer(naturals, naturals_all) + with open("./files/real_4mer_new.npy", 'wb') as f: + np.save(f,dist_real) + +if os.path.exists('./files/gen_4mer_new.npy'): + dist_gen = np.load('./files/gen_4mer_new.npy', allow_pickle=True) +else: + dist_gen = calc_dist_kmer(gens, naturals_all) + with open("./files/gen_4mer_new.npy", 'wb') as f: + np.save(f,dist_gen) + +if os.path.exists('./files/opt_4mer_new.npy'): + dist_opt = np.load('./files/opt_4mer_new.npy', allow_pickle=True) +else: + dist_opt = calc_dist_kmer(opts, naturals_all) + with open("./files/opt_4mer_new.npy", 'wb') as f: + np.save(f,dist_opt) + +anomalies = 0 + +dist_real_filtered = [] +for i in range(len(dist_real)): + if dist_real[i] > 7.5: + dist_real_filtered.append(dist_real[i]) + else: + anomalies += 1 + +print(anomalies) + +dist_real = dist_real_filtered + +real_x = ['Natural\n5\' UTR' for i in range(len(dist_real))] +gen_x = ['Generated' for i in range(len(dist_gen))] +opt_x = ['Optimized' for i in range(len(dist_opt))] +rand_x = ['Optimus\n5-Prime' for i in range(len(dist_rand))] + +gent_dist2 = ttest_ind(dist_gen,dist_real) +optt_dist2 = ttest_ind(dist_opt,dist_real) +randt_dist2 = ttest_ind(dist_rand,dist_real) +genu_dist2 = mannwhitneyu(dist_gen, dist_real) +optu_dist2 = mannwhitneyu(dist_opt, dist_real) +randu_dist2 = mannwhitneyu(dist_rand, dist_real) +es_gen_4mer = ES_CI(dist_gen,dist_real) +es_opt_4mer = ES_CI(dist_opt,dist_real) +es_rand_4mer = ES_CI(dist_rand,dist_real) + +x = np.concatenate((gen_x,opt_x,real_x,rand_x)) +y = np.concatenate((dist_gen,dist_opt,dist_real,dist_rand)) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[0,1], palette = customPalette) + + +axs[0,1].set_ylabel("Min. 4-mer Distance") +axs[0,1].set_xlabel("") + + +############################# GC Content #################################### + +rand_gc = get_gc_content_many(randoms) +real_gc = get_gc_content_many(naturals_all) +gens_gc = get_gc_content_many(gens) +opts_gc = get_gc_content_many(opts) + +real_x = ['Natural\n5\' UTR' for i in range(len(real_gc))] +gen_x = ['Generated' for i in range(len(gens_gc))] +opt_x = ['Optimized' for i in range(len(opts_gc))] +rand_x = ['Optimus\n5-Prime' for i in range(len(rand_gc))] + +x = np.concatenate((gen_x,opt_x,real_x,rand_x)) +y = np.concatenate((gens_gc,opts_gc,real_gc,rand_gc)) + +gent_gc = ttest_ind(gens_gc, real_gc) +optt_gc = ttest_ind(opts_gc, real_gc) +randt_gc = ttest_ind(rand_gc, real_gc) +genu_gc = mannwhitneyu(gens_gc, real_gc) +optu_gc = mannwhitneyu(opts_gc, real_gc) +randu_gc = mannwhitneyu(rand_gc, real_gc) +es_gen_gc = ES_CI(gens_gc,real_gc) +es_opt_gc = ES_CI(opts_gc,real_gc) +es_rand_gc = ES_CI(rand_gc,real_gc) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[0,2], palette=customPalette) + +axs[0,2].set_ylabel("G/C Content") +axs[0,2].set_xlabel("") + +########################################################### TE + +randpreds = np.load('./files/te_optimus.npy',allow_pickle=True) +genpreds = np.load('./files/te_gens.npy',allow_pickle=True) +optpreds = np.load('./files/te_optimized.npy',allow_pickle=True) +realpreds = np.load('./files/te_reals.npy',allow_pickle=True) + +randpreds = np.power(10,randpreds) +genpreds = np.power(10,genpreds) +optpreds = np.power(10,optpreds) +realpreds = np.power(10,realpreds) + +real_x = ['Natural\n5\' UTR' for i in range(len(realpreds))] +gen_x = ['Generated' for i in range(len(genpreds))] +opt_x = ['Optimized' for i in range(len(optpreds))] +rand_x = ['Optimus\n5-Prime' for i in range(len(randpreds))] + +x = np.concatenate((gen_x,opt_x,real_x,rand_x)) +y = np.concatenate((genpreds,optpreds,realpreds,randpreds)) + +gent_te = ttest_ind(genpreds, realpreds) +randt_te = ttest_ind(randpreds, realpreds) +optt_te = ttest_ind(optpreds, realpreds) +genu_te = mannwhitneyu(genpreds, realpreds) +optu_te = mannwhitneyu(optpreds, realpreds) +randu_te = mannwhitneyu(randpreds, realpreds) +es_gen_te = ES_CI(genpreds,realpreds) +es_opt_te = ES_CI(optpreds,realpreds) +es_rand_te = ES_CI(randpreds,realpreds) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[1,1], palette=customPalette) + +axs[1,1].set_ylabel("Translation Efficiency") +axs[1,1].set_xlabel("") + +############################################################ + +axs[1,0].set_title('D',weight='bold',fontsize=64,loc='left') +axs[1,1].set_title('E',weight='bold',fontsize=64,loc='left') +axs[1,2].set_title('F',weight='bold',fontsize=64,loc='left') +axs[0,0].set_title('A',weight='bold',fontsize=64,loc='left') +axs[0,1].set_title('B',weight='bold',fontsize=64,loc='left') +axs[0,2].set_title('C',weight='bold',fontsize=64,loc='left') + + +axs[0,0].tick_params(rotation=30) +axs[0,1].tick_params(rotation=30) +axs[1,0].tick_params(rotation=30) +axs[1,1].tick_params(rotation=30) +axs[0,2].tick_params(rotation=30) +axs[1,2].tick_params(rotation=30) + +fig.tight_layout(pad=2) + +plt.savefig('./plots/violins_all.png') + +print("Mean Ribosome Load KStest:") +print("Generated Samples Test:") +print(gent_mrl) +print(genu_mrl) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_mrl) +print("Random Samples Test:") +print(randt_mrl) +print(randu_mrl) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_mrl) +print("Optimized Samples Test:") +print(optt_mrl) +print(optu_mrl) +print("Optimized Samples Effect Size and Confidence Interval:") +print(es_opt_mrl) +print("Minimum Free Energy KStest:") +print("Generated Samples Test:") +print(gent_mfe) +print(genu_mfe) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_mfe) +print("Random Samples Test:") +print(randt_mfe) +print(randu_mfe) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_mfe) +print("Optimized Samples Test:") +print(optt_mfe) +print(optu_mfe) +print("Optimized Samples Effect Size and Confidence Interval:") +print(es_opt_mfe) +print("Levenshtien Distance KStest:") +print("Generated Samples Test:") +print(gent_dist) +print(genu_dist) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_lev) +print("Random Samples Test:") +print(randt_dist) +print(randu_dist) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_lev) +print("Optimized Samples Test:") +print(optt_dist) +print(optu_dist) +print("Optimized Samples Effect Size and Confidence Interval:") +print(es_opt_lev) +print("4-mer Distribution Distance KStest:") +print("Generated Samples Test:") +print(gent_dist2) +print(genu_dist2) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_4mer) +print("Random Samples Test:") +print(randt_dist2) +print(randu_dist2) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_4mer) +print("Optimized Samples Test:") +print(optt_dist2) +print(optu_dist2) +print("Optimized Samples Effect Size and Confidence Interval:") +print(es_opt_4mer) +print("GC Content KStest:") +print("Generated Samples Test:") +print(gent_gc) +print(genu_gc) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_gc) +print("Random Samples Test:") +print(randt_gc) +print(randu_gc) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_gc) +print("Optimized Samples Test:") +print(optt_gc) +print(optu_gc) +print("Optimized Samples Effect Size and Confidence Interval:") +print(es_opt_gc) +print("TE KStest:") +print("Generated Samples Test:") +print(gent_te) +print(genu_te) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_te) +print("Random Samples Test:") +print(randt_te) +print(randu_te) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_te) +print("Optimized Samples Test:") +print(optt_te) +print(optu_te) +print("Optimized Samples Effect Size and Confidence Interval:") +print(es_opt_te) \ No newline at end of file diff --git a/conf/analysis/violin_dists.py b/conf/analysis/violin_dists.py new file mode 100644 index 0000000000000000000000000000000000000000..1683c37b6f811662fa366225fe10025395929025 --- /dev/null +++ b/conf/analysis/violin_dists.py @@ -0,0 +1,463 @@ +from matplotlib import colors +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import random +from scipy.stats import ks_2samp,kstest,ttest_ind, mannwhitneyu, norm +from cliffs_delta import cliffs_delta +import seaborn as sns +from tqdm import tqdm +import random +random.seed(1337) +import os +import numpy as np +np.random.seed(1337) +import pandas as pd +pd.options.mode.chained_assignment = None +import RNA +from polyleven import levenshtein +import time +import itertools +import tensorflow as tf +from tensorflow.keras import backend as K +from tensorflow.keras.models import load_model +from tensorflow.keras.layers import Layer + +from utils.util import * +from utils.framepool import * + +colors = ["#3c5068", "#acbab6", "#dcd3cd", "#d4a6a6"] + +tf.compat.v1.enable_eager_execution() + +# os.environ["CUDA_VISIBLE_DEVICES"] = '5' + +def ES_CI(d1, d2): + n1 = len(d1) + n2 = len(d2) + + u1 = np.mean(d1) + u2 = np.mean(d2) + + s1 = np.std(d1) + s2 = np.std(d2) + + s = np.sqrt(((n1 - 1) * np.power(s1,2) + (n2 - 1) * np.power(s2,2)) / (n1 + n2 - 2)) + + effect_size = (u1 - u2)/s + effect_size = cliffs_delta(d1, d2) + + + + ct1 = n1 #items in dataset 1 + ct2 = n2 #items in dataset 2 + ds1 = d1 + ds2 = d2 + alpha = 0.05 #95% confidence interval + N = norm.ppf(1 - alpha/2) # percent point function - inverse of cdf + + # The confidence interval for the difference between the two population + # medians is derived through these nxm differences. + diffs = sorted([i-j for i in ds1 for j in ds2]) + + # For an approximate 100(1-a)% confidence interval first calculate K: + k = int(round(ct1*ct2/2 - (N * (ct1*ct2*(ct1+ct2+1)/12)**0.5))) + + # The Kth smallest to the Kth largest of the n x m differences + # ct1 and ct2 should be > ~20 + CI = (diffs[k], diffs[len(diffs)-k]) + + + return effect_size, CI + + +customPalette = {'Generated':colors[0],'Random':colors[3],'Natural':colors[1]} + +UTR_LEN = 128 +Z_DIM = 40 +DIM = Z_DIM +BATCH_SIZE = 2048 +MAX_LEN = UTR_LEN +gpath = './../models/checkpoint_3000.h5' +data_path = './../data/utrdb2.csv' +mrl_path = './../models/utr_model_combined_residual_new.h5' + +sns.set() +sns.set_style('ticks') + +#POSTER +params = {'legend.fontsize': 48, + 'figure.figsize': (54, 32), + 'axes.labelsize': 60, + 'axes.titlesize':60, + 'xtick.labelsize':60, + 'ytick.labelsize':60} + +plt.rcParams.update(params) + + +model = load_framepool(mrl_path) + +gens = generate_data(path=gpath, UTR_LEN=UTR_LEN, BATCH_SIZE=BATCH_SIZE, DIM=DIM) +gens2 = generate_data(path=gpath, UTR_LEN=UTR_LEN, BATCH_SIZE=4096, DIM=DIM) +gens_encoded = np.array([encode_seq_framepool(seq) for seq in gens]) +randoms = random_data(length=UTR_LEN, size=BATCH_SIZE) +randoms_encoded = np.array([encode_seq_framepool(seq) for seq in randoms]) +naturals = read_real(data_path, UTR_LEN=UTR_LEN, all=False, samples=BATCH_SIZE) +naturals2 = read_real(data_path, UTR_LEN=UTR_LEN, all=False, samples=10000) +naturals_encoded = np.array([encode_seq_framepool(seq) for seq in naturals]) +naturals_all = read_real(data_path, UTR_LEN=UTR_LEN, all=True) +naturals_encoded_all = np.array([encode_seq_framepool(seq) for seq in naturals_all]) +############################# MRL PREDICTION #################################### + +######### Gens + +gens_tensor = tf.convert_to_tensor(gens_encoded,dtype=tf.float32) +pred_gens = model(gens_tensor) +pred_gens = tf.reshape(pred_gens,(-1)) +genpreds = pred_gens.numpy().astype('float') + +######### Randoms + +randoms_tensor = tf.convert_to_tensor(randoms_encoded,dtype=tf.float32) +pred_randoms = model(randoms_tensor) +pred_randoms = tf.reshape(pred_randoms,(-1)) +randpreds = pred_randoms.numpy().astype('float') + +######## Labeled + +naturals_tensors = tf.convert_to_tensor(naturals_encoded_all,dtype=tf.float32) +pred_naturals = model(naturals_tensors) +pred_naturals = tf.reshape(pred_naturals,(-1)) +realpreds = pred_naturals.numpy().astype('float') + +############ + +bins = np.linspace(2.5, 9, 30) + +fig, axs = plt.subplots(2,3) + +real_x = ['Natural' for i in range(len(realpreds))] +gen_x = ['Generated' for i in range(len(genpreds))] +rand_x = ['Random' for i in range(len(randpreds))] + +x = np.concatenate((gen_x,real_x,rand_x)) +y = np.concatenate((genpreds,realpreds,randpreds)) + +gent_mrl = ttest_ind(genpreds,realpreds) +randt_mrl = ttest_ind(randpreds,realpreds) +genu_mrl = mannwhitneyu(genpreds, realpreds) +randu_mrl = mannwhitneyu(randpreds, realpreds) +es_gen_mrl = ES_CI(genpreds,realpreds) +es_rand_mrl = ES_CI(randpreds,realpreds) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[1,0],palette=customPalette) + +axs[1,0].set_ylabel("Mean Ribosome Load") +axs[1,0].set_xlabel("") + +############################# MFE PREDICTION #################################### + +genpreds = [] + +for i in range(len(gens)): + (ss, mfe) = RNA.fold(gens[i]) + genpreds.append(mfe) + +randpreds = [] + +for i in range(len(randoms)): + (ss, mfe) = RNA.fold(randoms[i]) + randpreds.append(mfe) + +realpreds = [] + +for i in range(len(naturals_all)): + (ss, mfe) = RNA.fold(naturals_all[i]) + realpreds.append(mfe) + +real_x = ['Natural' for i in range(len(realpreds))] +gen_x = ['Generated' for i in range(len(genpreds))] +rand_x = ['Random' for i in range(len(randpreds))] + +gent_mfe = ttest_ind(genpreds,realpreds) +randt_mfe = ttest_ind(randpreds,realpreds) +randu_mfe = mannwhitneyu(randpreds, realpreds) +genu_mfe = mannwhitneyu(genpreds, realpreds) +es_gen_mfe = ES_CI(genpreds,realpreds) +es_rand_mfe = ES_CI(randpreds,realpreds) + +x = np.concatenate((gen_x,real_x,rand_x)) +y = np.concatenate((genpreds,realpreds,randpreds)) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[1,2],palette=customPalette) + +axs[1,2].set_ylabel("Minimum Free Energy") +axs[1,2].set_xlabel("") + +############################# Levenshtein Distance #################################### + + + +DIST = 'S' + +if DIST == 'KMER': + dist_rand = calc_dist_kmer(randoms, naturals) + dist_gen = calc_dist_kmer(gens, naturals) + dist_real = calc_dist_kmer(naturals, naturals) +else: + if os.path.exists('./files/rand_ham_new.npy'): + dist_rand = np.load('./files/rand_ham_new.npy', allow_pickle=True) + else: + dist_rand = hamming_dist(randoms,naturals_all) + with open("./files/rand_ham_new.npy", 'wb') as f: + np.save(f,dist_rand) + + if os.path.exists('./files/real_ham_new.npy'): + dist_real = np.load('./files/real_ham_new.npy', allow_pickle=True) + else: + dist_real = hamming_dist(naturals, naturals_all) + with open("./files/real_ham_new.npy", 'wb') as f: + np.save(f,dist_real) + + if os.path.exists('./files/gen_ham_new.npy'): + dist_gen = np.load('./files/gen_ham_new.npy', allow_pickle=True) + else: + dist_gen = hamming_dist(gens, naturals_all) + with open("./files/gen_ham_new.npy", 'wb') as f: + np.save(f,dist_gen) + +# filter: +dist_real_filtered = [] +for i in range(len(dist_real)): + if dist_real[i] > 21: + dist_real_filtered.append(dist_real[i]) + + +dist_real = dist_real_filtered + +real_x = ['Natural' for i in range(len(dist_real))] +gen_x = ['Generated' for i in range(len(dist_gen))] +rand_x = ['Random' for i in range(len(dist_rand))] + +gent_dist = ttest_ind(dist_gen,dist_real) +randt_dist = ttest_ind(dist_rand,dist_real) +genu_dist = mannwhitneyu(dist_gen, dist_real) +randu_dist = mannwhitneyu(dist_rand, dist_real) +es_gen_lev = ES_CI(dist_gen,dist_real) +es_rand_lev = ES_CI(dist_rand,dist_real) + +x = np.concatenate((gen_x,real_x,rand_x)) +y = np.concatenate((dist_gen,dist_real,dist_rand)) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[0,0], palette=customPalette) + +if DIST == 'KMER': + + + axs[0,0].set_ylabel("Min. 4-mer Distance") + axs[0,0].set_xlabel("") + +else: + + axs[0,0].set_ylabel("Min. Levenshtein Distance") + axs[0,0].set_xlabel("") + +############################################################################ + +if os.path.exists('./files/rand_4mer_new.npy'): + dist_rand = np.load('./files/rand_4mer_new.npy', allow_pickle=True) +else: + dist_rand = calc_dist_kmer(randoms, naturals_all) + with open("./files/rand_4mer_new.npy", 'wb') as f: + np.save(f,dist_rand) + +if os.path.exists('./files/real_4mer_new.npy'): + dist_real = np.load('./files/real_4mer_new.npy', allow_pickle=True) +else: + dist_real = calc_dist_kmer(naturals, naturals_all) + with open("./files/real_4mer_new.npy", 'wb') as f: + np.save(f,dist_real) + +if os.path.exists('./files/gen_4mer_new.npy'): + dist_gen = np.load('./files/gen_4mer_new.npy', allow_pickle=True) +else: + dist_gen = calc_dist_kmer(gens, naturals_all) + with open("./files/gen_4mer_new.npy", 'wb') as f: + np.save(f,dist_gen) + +anomalies = 0 + +dist_real_filtered = [] +for i in range(len(dist_real)): + if dist_real[i] > 7.5: + dist_real_filtered.append(dist_real[i]) + else: + anomalies += 1 + +print(anomalies) + +dist_real = dist_real_filtered + +real_x = ['Natural' for i in range(len(dist_real))] +gen_x = ['Generated' for i in range(len(dist_gen))] +rand_x = ['Random' for i in range(len(dist_rand))] + +gent_dist2 = ttest_ind(dist_gen,dist_real) +randt_dist2 = ttest_ind(dist_rand,dist_real) +genu_dist2 = mannwhitneyu(dist_gen, dist_real) +randu_dist2 = mannwhitneyu(dist_rand, dist_real) +es_gen_4mer = ES_CI(dist_gen,dist_real) +es_rand_4mer = ES_CI(dist_rand,dist_real) + +x = np.concatenate((gen_x,real_x,rand_x)) +y = np.concatenate((dist_gen,dist_real,dist_rand)) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[0,1], palette = customPalette) + + +axs[0,1].set_ylabel("Min. 4-mer Distance") +axs[0,1].set_xlabel("") + + +############################# GC Content #################################### + +rand_gc = get_gc_content_many(randoms) +real_gc = get_gc_content_many(naturals_all) +gens_gc = get_gc_content_many(gens) + +real_x = ['Natural' for i in range(len(real_gc))] +gen_x = ['Generated' for i in range(len(gens_gc))] +rand_x = ['Random' for i in range(len(rand_gc))] + +x = np.concatenate((gen_x,real_x,rand_x)) +y = np.concatenate((gens_gc,real_gc,rand_gc)) + +gent_gc = ttest_ind(gens_gc, real_gc) +randt_gc = ttest_ind(rand_gc, real_gc) +genu_gc = mannwhitneyu(gens_gc, real_gc) +randu_gc = mannwhitneyu(rand_gc, real_gc) +es_gen_gc = ES_CI(gens_gc,real_gc) +es_rand_gc = ES_CI(rand_gc,real_gc) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[0,2], palette=customPalette) + +axs[0,2].set_ylabel("G/C Content") +axs[0,2].set_xlabel("") + +########################################################### TE + +randpreds = np.load('./files/te_rands.npy',allow_pickle=True) +genpreds = np.load('./files/te_gens.npy',allow_pickle=True) +realpreds = np.load('./files/te_reals.npy',allow_pickle=True) + +real_x = ['Natural' for i in range(len(realpreds))] +gen_x = ['Generated' for i in range(len(genpreds))] +rand_x = ['Random' for i in range(len(randpreds))] + +x = np.concatenate((gen_x,real_x,rand_x)) +y = np.concatenate((genpreds,realpreds,randpreds)) + +gent_te = ttest_ind(genpreds, realpreds) +randt_te = ttest_ind(randpreds, realpreds) +genu_te = mannwhitneyu(genpreds, realpreds) +randu_te = mannwhitneyu(randpreds, realpreds) +es_gen_te = ES_CI(genpreds,realpreds) +es_rand_te = ES_CI(randpreds,realpreds) + +df = pd.DataFrame({'x':x,'y':y}) + +sns.violinplot(x=df['x'],y=df['y'],ax=axs[1,1], palette=customPalette) + +axs[1,1].set_ylabel("Translation Efficiency") +axs[1,1].set_xlabel("") + +############################################################ + +axs[1,0].set_title('D',weight='bold',fontsize=64,loc='left') +axs[1,1].set_title('E',weight='bold',fontsize=64,loc='left') +axs[1,2].set_title('F',weight='bold',fontsize=64,loc='left') +axs[0,0].set_title('A',weight='bold',fontsize=64,loc='left') +axs[0,1].set_title('B',weight='bold',fontsize=64,loc='left') +axs[0,2].set_title('C',weight='bold',fontsize=64,loc='left') +fig.tight_layout(pad=2) + +plt.savefig('./plots/violins_all.png') + +print("Mean Ribosome Load KStest:") +print("Generated Samples Test:") +print(gent_mrl) +print(genu_mrl) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_mrl) +print("Random Samples Test:") +print(randt_mrl) +print(randu_mrl) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_mrl) +print("Minimum Free Energy KStest:") +print("Generated Samples Test:") +print(gent_mfe) +print(genu_mfe) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_mfe) +print("Random Samples Test:") +print(randt_mfe) +print(randu_mfe) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_mfe) +print("Levenshtien Distance KStest:") +print("Generated Samples Test:") +print(gent_dist) +print(genu_dist) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_lev) +print("Random Samples Test:") +print(randt_dist) +print(randu_dist) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_lev) +print("4-mer Distribution Distance KStest:") +print("Generated Samples Test:") +print(gent_dist2) +print(genu_dist2) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_4mer) +print("Random Samples Test:") +print(randt_dist2) +print(randu_dist2) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_4mer) +print("GC Content KStest:") +print("Generated Samples Test:") +print(gent_gc) +print(genu_gc) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_gc) +print("Random Samples Test:") +print(randt_gc) +print(randu_gc) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_gc) +print("TE KStest:") +print("Generated Samples Test:") +print(gent_te) +print(genu_te) +print("Generated Samples Effect Size and Confidence Interval:") +print(es_gen_te) +print("Random Samples Test:") +print(randt_te) +print(randu_te) +print("Random Samples Effect Size and Confidence Interval:") +print(es_rand_te) \ No newline at end of file diff --git a/conf/config.json b/conf/config.json new file mode 100644 index 0000000000000000000000000000000000000000..a7e3d28925e448534f37edb6c681dff3bf7a944c --- /dev/null +++ b/conf/config.json @@ -0,0 +1,23 @@ +{ + "runtime": { + "python": "3.11", + "dtk": "26.04", + "tensorflow": "2.18.0+das.opt1.dtk2604", + "torch": "2.5.1+das.opt1.dtk2604", + "tf_use_legacy_keras": true + }, + "paths": { + "dataset": "conf/data/utrdb2.csv", + "motifs": "conf/data/motifs.csv", + "generator": "weight/checkpoint_3000.h5", + "framepool": "weight/utr_model_combined_residual_new.h5", + "mttrans_te": "weight/mttrans/RL_hard_share_MTL/3R/schedule_MTL-model_best_cv1.pth", + "output_dir": "outputs" + }, + "defaults": { + "sequence_length": 128, + "latent_dimension": 40, + "batch_size": 64, + "learning_rate_exponent": 5 + } +} diff --git a/conf/data/motifs.csv b/conf/data/motifs.csv new file mode 100644 index 0000000000000000000000000000000000000000..f5b22d70f8850725e8dc097848d55b472890dcd8 --- /dev/null +++ b/conf/data/motifs.csv @@ -0,0 +1,257 @@ +,seq,spr +0,CTTTGGAAC,0.039 +1,GGCCCCTCC,-0.065 +2,CGGCCGCCC,-0.234 +3,GAACAATGG,-0.302 +4,GGATGGGGC,-0.365 +5,GGATGACGC,-0.261 +6,CAATGATGC,-0.196 +7,GGTGGCCCA,-0.113 +8,TGCCCGGTA,-0.023 +9,CGCTGCTGG,-0.085 +10,CAAAGAATG,-0.502 +11,TTTTAAAAT,0.187 +12,GGCCGCCCC,-0.223 +13,GGCGGGCCC,-0.161 +14,CGCCCCGGC,-0.302 +15,GGCGCCCTC,-0.191 +16,ATTTGAGCG,-0.085 +17,CGCCCGGGC,-0.236 +18,GTTGATCAT,0.17 +19,CTGTGCTCT,-0.005 +20,ACCCCCCCC,-0.231 +21,CGGGATCCG,-0.097 +22,GTTCCTTCC,0.142 +23,GCCGCCCTG,-0.221 +24,CATTTTGGT,0.157 +25,GGCCTGAGA,-0.042 +26,GTGGGGAGT,-0.112 +27,CAGCAATGA,-0.395 +28,GTCCGGCCG,-0.189 +29,TGGCTCCTC,0.095 +30,GGCAGGCCC,-0.174 +31,CGGGCCCGC,-0.288 +32,GGACACCCA,-0.055 +33,GGCGCCCGC,-0.198 +34,TTTTTGGAT,0.085 +35,CCGGGGCGG,-0.403 +36,ATTTGTAAA,0.194 +37,GCCGTAGGC,-0.049 +38,CAGTGTAGG,0.046 +39,AACATGGGG,-0.183 +40,CTTCATGTC,0.115 +41,TTTTTTTGT,0.254 +42,CCGCGGTGC,-0.334 +43,GGCGGCCCG,-0.183 +44,CCCCCCCCC,0.002 +45,TTTTGAAAT,0.17 +46,ATTGTTGAA,0.123 +47,GGCCCTGGC,-0.258 +48,CCAATATTG,-0.355 +49,TTTTTTTAA,0.236 +50,CCAGCGGCG,-0.435 +51,GGATGACGG,-0.204 +52,TCTGTTGCT,0.207 +53,CTGCCTAAG,-0.048 +54,CGTGGGGGG,-0.08 +55,CTGTGACGC,0.039 +56,CTTTGATGC,0.056 +57,GGAGCAATG,-0.284 +58,GTTCAGGGC,-0.007 +59,CATTTAAAC,0.086 +60,GTCCCCCTG,-0.035 +61,GCCCCGTGG,-0.244 +62,TGTCTCTTT,0.267 +63,CATCAGGTC,0.006 +64,AATGATGAC,-0.014 +65,CCGCCCCCC,-0.105 +66,AAATGACAA,-0.106 +67,GGTAGCTAC,0.124 +68,CCCGGCCGC,-0.473 +69,CTCTGATGA,-0.257 +70,CTTAAGGGG,-0.014 +71,ATGTTGACG,-0.186 +72,CTTTAAGCA,0.022 +73,GCCGCCGCC,0.008 +74,CGTAGTCGC,0.102 +75,TCGGCCCGC,-0.185 +76,GGCGCCCGC,-0.271 +77,GAAAGATGG,-0.237 +78,GCCCCGGGG,-0.506 +79,CCCGGCGCG,-0.149 +80,CCGGGGGGG,-0.367 +81,TTACTGGGG,0.158 +82,GGGGGGGGG,-0.213 +83,CGGGGGCGC,-0.271 +84,CGTATGATA,-0.074 +85,CGCTCCCCC,-0.249 +86,GCCACTGAG,-0.25 +87,GCATGCCCC,-0.149 +88,GCGGGGCGC,-0.393 +89,GGTGGAGGA,-0.088 +90,GGAAGATGG,-0.337 +91,GCCGGGACC,0.037 +92,GAGCTGGCG,-0.154 +93,ACCCCCCCC,0.053 +94,GGAGGGGGA,-0.108 +95,GGTATGTGA,-0.109 +96,CGGGGGGCT,-0.123 +97,GTGGTGGGG,0.02 +98,AGTTTTTGA,0.094 +99,AGGTGGTGG,-0.083 +100,ATTGTTTGT,0.2 +101,CGCTGTGGG,0.177 +102,GCGGGGGCC,-0.314 +103,CGGCGGGGC,-0.233 +104,CCGGCCCCC,-0.265 +105,AGCGTTGAG,0.005 +106,CCGGGATGG,-0.402 +107,GCCCTGTGG,-0.21 +108,CGCTAACGC,0.087 +109,CGCCCTGGC,-0.262 +110,CCAACGGGG,-0.172 +111,CCGCCCCCC,-0.251 +112,TGTCTCCGT,-0.008 +113,CCCAGCCCC,0.028 +114,AGGGGGGGC,-0.169 +115,CAGCTAGCT,0.024 +116,CCCGTGAGC,-0.061 +117,GGCCGGCCC,-0.25 +118,TCTTGAAAA,0.219 +119,AACCTTTAA,0.143 +120,CCCCTAAAA,0.133 +121,GAGAGGGTT,-0.108 +122,CTGAGCTGG,-0.28 +123,GCCCATGTG,-0.176 +124,GTCTGATAA,0.221 +125,GAAAAAAGT,-0.124 +126,GCCCCCGGG,-0.289 +127,GTGAAGGAT,0.095 +128,TTAAGAAGG,-0.072 +129,TAATAATGA,-0.159 +130,CGGCCTCTG,-0.041 +131,CGTTATGAT,0.071 +132,GGACTTCCA,0.038 +133,CGCCCGGGC,-0.174 +134,GAGTTTGAA,0.201 +135,TGGCACGAT,0.087 +136,GGCGCCCGC,-0.24 +137,CTGCCGAGC,-0.055 +138,TAAAACAAA,0.223 +139,CCCTTGGGC,-0.061 +140,GCCGCCGCC,-0.322 +141,CCCTCTAGG,0.048 +142,CACGCCGCG,-0.219 +143,CTGTGCCTC,0.043 +144,CCCCTGGCT,-0.095 +145,ATATGCTCG,-0.106 +146,GATTAAAAA,0.196 +147,ATTTTCTGC,0.084 +148,CCATGGCCC,-0.271 +149,CAAATGGGG,-0.091 +150,CCCTAGCAG,0.002 +151,GGGCAGGGT,-0.167 +152,GTTCTAAGG,-0.032 +153,CCCGCCCGG,-0.352 +154,GGGGCGGGC,-0.24 +155,GGGCTCCAG,0.039 +156,TTTAATAAA,0.137 +157,GGCCCTGAG,-0.084 +158,TGCTCGGCC,0.013 +159,CGGCGGGGG,-0.232 +160,GCCCCCCCG,-0.127 +161,GCCCCCGGC,-0.166 +162,AAATCGGGA,-0.136 +163,CAATTCCCT,-0.078 +164,CGTCCGCCC,-0.111 +165,TTGTGACCC,0.014 +166,CCGTAAGCG,0.017 +167,GGGGAGGCG,-0.093 +168,GCGTGGCAG,-0.158 +169,CCTTTGCTC,0.151 +170,CCGGGGCCC,-0.306 +171,TGGGGGGGC,-0.037 +172,CTCCGTAGA,0.049 +173,CCGGCCGCC,-0.052 +174,CGGCCTTGA,-0.125 +175,GTTGCTGTG,-0.062 +176,GCGGTGTAG,-0.067 +177,ATTTGGGGG,-0.069 +178,GGGATGGGG,-0.382 +179,TTGTCCATG,-0.074 +180,CTCTTACCC,0.263 +181,TCTGCTCCC,0.127 +182,TCTGTCCCA,0.126 +183,AAAAATGAT,0.135 +184,CCGACTCCA,0.049 +185,CGGCCCGGC,-0.206 +186,AAGTTTTTT,0.218 +187,TGTTGAGCC,-0.013 +188,CAGATGGGG,-0.119 +189,ATGGGGGGG,-0.18 +190,GTCGATGGG,-0.269 +191,CTTCGCCAC,0.032 +192,GCGGCGCCC,-0.107 +193,GGCCCATGC,-0.261 +194,CCGGGGGGC,-0.332 +195,CCCGCTCAG,0.038 +196,CCCGTGAGC,0.052 +197,ATGGCCGCC,-0.216 +198,TAAAAATGG,-0.245 +199,GGCCGCCGG,-0.244 +200,GCGGCCCTC,-0.074 +201,GGGGGGTGG,-0.167 +202,ACTTGTAAA,0.036 +203,CTTTGAGAA,0.108 +204,CTGGCGCGG,-0.22 +205,CGGCCCTGA,-0.168 +206,CCCCCCCCC,-0.032 +207,ACCAGCATG,-0.002 +208,CATCATGGC,0.053 +209,CGCCGGGGC,-0.152 +210,TTCAAGATG,0.012 +211,TGGGTGAAC,0.034 +212,TGGGGCCCC,-0.274 +213,CCCTGGCTC,-0.108 +214,GCCTGGGGG,-0.239 +215,GAGCTAAGC,0.014 +216,ATTTTTTCT,0.089 +217,TGAGGAAGG,-0.264 +218,CCGGCCCGG,-0.423 +219,CGCCGCCAC,-0.048 +220,GGCCGGCAG,-0.133 +221,CCCCCTCCC,0.077 +222,TCTGTTGTT,0.127 +223,GAAACGTAG,0.06 +224,CCCTGGGTG,-0.205 +225,TCAGTGATG,0.018 +226,TGCCCCCCC,-0.024 +227,CGGGGGCCC,-0.331 +228,CAACCAAAA,0.213 +229,CCAGGATGG,-0.347 +230,CAGCGCGGC,-0.215 +231,TTTTAAGTA,0.227 +232,CGTGGGGGG,-0.147 +233,GGCGGCCCG,-0.288 +234,CCTGTAAAC,0.138 +235,TCTCTTCCC,0.153 +236,CCTCCCCCG,-0.17 +237,CGTGGATTA,-0.185 +238,GCGGTAACG,-0.065 +239,AAAACATTC,0.068 +240,CAGGTAAGT,0.115 +241,AGCCCCTGG,-0.095 +242,GGCGGGCCG,-0.282 +243,TCCTAAGCC,0.122 +244,GCAGCCTGG,-0.159 +245,TTCTAAGTT,0.067 +246,CCATGATGC,-0.12 +247,CTGTGAGCT,0.034 +248,CGACCCCAG,-0.049 +249,CGTGTAAGC,-0.055 +250,GTGGGCCCC,-0.095 +251,TCTTTTCAA,0.193 +252,GTTTAATAA,0.108 +253,GCCCCCCGC,-0.113 +254,GGCTCTAAG,0.022 +255,GTATGATGG,-0.258 diff --git a/conf/data/utrdb2.csv b/conf/data/utrdb2.csv new file mode 100644 index 0000000000000000000000000000000000000000..9c54ca2a28e644ab35ee811a2319bed227b91f04 --- /dev/null +++ b/conf/data/utrdb2.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2ac8227b6084f0164d75a3f1dde738daa93199a156dc60601a53e7204360120 +size 20420229 diff --git a/conf/environment.yml b/conf/environment.yml new file mode 100644 index 0000000000000000000000000000000000000000..c2df4040cb784607930e0669b4f30ad0cb356990 --- /dev/null +++ b/conf/environment.yml @@ -0,0 +1,297 @@ +name: utrgan +channels: + - bioconda + - conda-forge + - https://repo.anaconda.com/pkgs/main + - https://repo.anaconda.com/pkgs/r +dependencies: + - _libgcc_mutex=0.1 + - _openmp_mutex=4.5 + - absl-py=2.2.0 + - aiohappyeyeballs=2.6.1 + - aiohttp=3.11.16 + - aiosignal=1.3.2 + - anyio=4.9.0 + - argon2-cffi=23.1.0 + - argon2-cffi-bindings=21.2.0 + - arrow=1.3.0 + - asttokens=3.0.0 + - astunparse=1.6.3 + - async-lru=2.0.5 + - async-timeout=5.0.1 + - attrs=25.3.0 + - babel=2.17.0 + - beautifulsoup4=4.13.3 + - biopython=1.85 + - bleach=6.2.0 + - bleach-with-css=6.2.0 + - blinker=1.9.0 + - brotli=1.1.0 + - brotli-bin=1.1.0 + - brotli-python=1.1.0 + - bzip2=1.0.8 + - c-ares=1.34.5 + - ca-certificates=2025.1.31 + - cached_property=1.5.2 + - cachetools=5.5.2 + - certifi=2025.1.31 + - cffi=1.17.1 + - charset-normalizer=3.4.1 + - click=8.1.8 + - colorama=0.4.6 + - comm=0.2.2 + - contourpy=1.3.0 + - cpython=3.9.22 + - cryptography=39.0.0 + - cuda-version=11.8 + - cudatoolkit=11.8.0 + - cudnn=8.9.7.29 + - cycler=0.12.1 + - debugpy=1.8.14 + - decorator=5.2.1 + - defusedxml=0.7.1 + - einops=0.8.1 + - exceptiongroup=1.2.2 + - executing=2.1.0 + - filelock=3.18.0 + - flatbuffers=22.12.06 + - fonttools=4.57.0 + - fqdn=1.5.1 + - freetype=2.13.3 + - frozenlist=1.5.0 + - gast=0.4.0 + - giflib=5.2.2 + - gmp=6.3.0 + - gmpy2=2.1.5 + - google-auth=2.39.0 + - google-auth-oauthlib=0.4.6 + - google-pasta=0.2.0 + - grpcio=1.51.1 + - gsl=2.7 + - h11=0.14.0 + - h2=4.2.0 + - h5py=3.9.0 + - hdf5=1.14.0 + - hpack=4.1.0 + - httpcore=1.0.7 + - httpx=0.28.1 + - hyperframe=6.1.0 + - icu=70.1 + - idna=3.10 + - importlib-metadata=8.6.1 + - importlib-resources=6.5.2 + - importlib_resources=6.5.2 + - ipykernel=6.29.5 + - ipython=8.18.1 + - isoduration=20.11.0 + - jedi=0.19.2 + - jinja2=3.1.6 + - joblib=1.4.2 + - jpeg=9e + - json5=0.12.0 + - jsonpointer=3.0.0 + - jsonschema=4.23.0 + - jsonschema-specifications=2024.10.1 + - jsonschema-with-format-nongpl=4.23.0 + - jupyter-lsp=2.2.5 + - jupyter_client=8.6.3 + - jupyter_core=5.7.2 + - jupyter_events=0.12.0 + - jupyter_server=2.15.0 + - jupyter_server_terminals=0.5.3 + - jupyterlab=4.4.0 + - jupyterlab_pygments=0.3.0 + - jupyterlab_server=2.27.3 + - keras=2.11.0 + - keras-preprocessing=1.1.2 + - keyutils=1.6.1 + - kiwisolver=1.4.7 + - krb5=1.20.1 + - lcms2=2.15 + - ld_impl_linux-64=2.43 + - lerc=4.0.0 + - libabseil=20220623.0 + - libaec=1.1.3 + - libblas=3.9.0 + - libbrotlicommon=1.1.0 + - libbrotlidec=1.1.0 + - libbrotlienc=1.1.0 + - libcblas=3.9.0 + - libcurl=7.87.0 + - libdeflate=1.17 + - libedit=3.1.20250104 + - libev=4.33 + - libexpat=2.7.0 + - libffi=3.4.6 + - libgcc=14.2.0 + - libgcc-ng=14.2.0 + - libgfortran=14.2.0 + - libgfortran-ng=14.2.0 + - libgfortran5=14.2.0 + - libgomp=14.2.0 + - libgrpc=1.51.1 + - libhwloc=2.9.1 + - libiconv=1.18 + - libjpeg-turbo=2.1.4 + - liblapack=3.9.0 + - liblzma=5.8.1 + - liblzma-devel=5.8.1 + - libmagma=2.7.1 + - libmagma_sparse=2.7.1 + - libnghttp2=1.51.0 + - libnsl=2.0.1 + - libopenblas=0.3.29 + - libpng=1.6.47 + - libprotobuf=3.21.12 + - libsodium=1.0.18 + - libsqlite=3.49.1 + - libssh2=1.10.0 + - libstdcxx=14.2.0 + - libstdcxx-ng=14.2.0 + - libtiff=4.5.0 + - libuuid=2.38.1 + - libwebp-base=1.5.0 + - libxcb=1.13 + - libxcrypt=4.4.36 + - libxml2=2.10.3 + - libzlib=1.3.1 + - llvm-openmp=20.1.2 + - magma=2.7.1 + - markdown=3.6 + - markupsafe=3.0.2 + - matplotlib-base=3.9.4 + - matplotlib-inline=0.1.7 + - mistune=3.1.3 + - mkl=2022.2.1 + - ml_dtypes=0.2.0 + - mpc=1.3.1 + - mpfr=4.2.1 + - mpmath=1.3.0 + - multidict=6.3.2 + - munkres=1.1.4 + - nbclient=0.10.2 + - nbconvert-core=7.16.6 + - nbformat=5.10.4 + - nccl=2.26.2.1 + - ncurses=6.5 + - nest-asyncio=1.6.0 + - networkx=3.2.1 + - notebook=7.4.0 + - notebook-shim=0.2.4 + - numpy=1.26.4 + - oauthlib=3.2.2 + - openjpeg=2.5.0 + - openssl=1.1.1w + - opt_einsum=3.4.0 + - overrides=7.7.0 + - packaging=24.2 + - pandas=2.2.3 + - pandocfilters=1.5.0 + - parso=0.8.4 + - patsy=1.0.1 + - perl=5.32.1 + - pexpect=4.9.0 + - pickleshare=0.7.5 + - pillow=9.4.0 + - pip=25.0.1=pyh8b19718_0 + - pkgutil-resolve-name=1.3.10 + - platformdirs=4.3.7 + - polyleven=0.9.0 + - prometheus_client=0.21.1 + - prompt-toolkit=3.0.50 + - propcache=0.3.1 + - protobuf=4.21.12 + - psutil=7.0.0 + - pthread-stubs=0.4 + - ptyprocess=0.7.0 + - pure_eval=0.2.3 + - pyasn1=0.6.1 + - pyasn1-modules=0.4.2 + - pycparser=2.22 + - pygments=2.19.1 + - pyjwt=2.10.1 + - pyopenssl=23.2.0 + - pyparsing=3.2.3 + - pysocks=1.7.1 + - python=3.9.15 + - python-dateutil=2.9.0.post0 + - python-fastjsonschema=2.21.1 + - python-flatbuffers=25.2.10 + - python-json-logger=2.0.7 + - python-tzdata=2025.2 + - python_abi=3.9 + - pytorch=2.0.0 + - pytz=2025.2 + - pyu2f=0.1.5 + - pyyaml=6.0.2 + - pyzmq=26.2.0 + - qhull=2020.2 + - re2=2022.06.01 + - readline=8.2 + - referencing=0.36.2 + - requests=2.32.3 + - requests-oauthlib=2.0.0 + - rfc3339-validator=0.1.4 + - rfc3986-validator=0.1.1 + - rpds-py=0.24.0 + - rsa=4.9 + - scikit-learn=1.6.1 + - scipy=1.13.1 + - seaborn=0.13.2 + - seaborn-base=0.13.2 + - send2trash=1.8.3 + - setuptools=78.1.0 + - six=1.17.0 + - sleef=3.8 + - snappy=1.1.10 + - sniffio=1.3.1 + - soupsieve=2.5 + - stack_data=0.6.3 + - statsmodels=0.14.4 + - sympy=1.13.3 + - tbb=2021.9.0 + - tensorboard=2.11.2 + - tensorboard-data-server=0.6.1 + - tensorboard-plugin-wit=1.8.1 + - tensorflow=2.11.0 + - tensorflow-base=2.11.0 + - tensorflow-estimator=2.11.0 + - tensorflow-gpu=2.11.0 + - termcolor=3.0.1 + - terminado=0.18.1 + - threadpoolctl=3.6.0 + - tinycss2=1.4.0 + - tk=8.6.13 + - tomli=2.2.1 + - tornado=6.4.2 + - tqdm=4.67.1 + - traitlets=5.14.3 + - types-python-dateutil=2.9.0.20241206 + - typing-extensions=4.13.2 + - typing_extensions=4.13.2 + - typing_utils=0.1.0 + - tzdata=2025b + - unicodedata2=16.0.0 + - uri-template=1.3.0 + - viennarna=2.7.0 + - wcwidth=0.2.13 + - webcolors=24.11.1 + - webencodings=0.5.1 + - websocket-client=1.8.0 + - werkzeug=3.1.3 + - wheel=0.45.1 + - wrapt=1.14.1 + - xorg-libxau=1.0.12 + - xorg-libxdmcp=1.1.5 + - xz=5.8.1 + - xz-gpl-tools=5.8.1 + - xz-tools=5.8.1 + - yaml=0.2.5 + - yarl=1.18.3 + - zeromq=4.3.5 + - zipp=3.21.0 + - zlib=1.3.1 + - zstandard=0.23.0 + - zstd=1.5.7 + - pip: + - urllib3==1.26.20 diff --git a/conf/img/pipeline.png b/conf/img/pipeline.png new file mode 100644 index 0000000000000000000000000000000000000000..d4d756113edcb7caa3098198c9c0d7b505b9c123 --- /dev/null +++ b/conf/img/pipeline.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a847cfb671458a0617b45e2ddc8f5dda98d36591b073e6be23565a59403f82d9 +size 924991 diff --git a/conf/notebooks/exp_optimization_multiple.ipynb b/conf/notebooks/exp_optimization_multiple.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..a9cbf0ec19c2c8f021d83e5d489c6ed8446395a1 --- /dev/null +++ b/conf/notebooks/exp_optimization_multiple.ipynb @@ -0,0 +1,1053 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "47fa042d", + "metadata": {}, + "outputs": [ + { + "ename": "ImportError", + "evalue": "cannot import name 'Modules' from 'models' (unknown location)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 26\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mrequests\u001b[39;00m\u001b[38;5;241m,\u001b[39m \u001b[38;5;21;01msys\u001b[39;00m\n\u001b[0;32m---> 26\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msrc\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mexp_optimization\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpopen\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Auto_popen\n\u001b[1;32m 28\u001b[0m abs_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m./src/mrl_te_optimization/log/Backbone/RL_hard_share/3M/small_repective_filed_strides1113.ini\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 29\u001b[0m Configuration \u001b[38;5;241m=\u001b[39m Auto_popen(abs_path)\n", + "File \u001b[0;32m~/Documents/bilkent/utrgan/bioinformatics advances/code/UTRGAN/src/exp_optimization/popen.py:5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mjson\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mmodels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Modules\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mconfigparser\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mlogging\u001b[39;00m\n", + "\u001b[0;31mImportError\u001b[0m: cannot import name 'Modules' from 'models' (unknown location)" + ] + } + ], + "source": [ + "import requests\n", + "import json\n", + "import time\n", + "import numpy as np\n", + "import os\n", + "from re import A, L\n", + "import numpy as np\n", + "import pandas as pd\n", + "from tqdm import tqdm\n", + "import torch\n", + "import tensorflow as tf\n", + "import tensorflow.keras.backend as K\n", + "from tensorflow.keras import Model\n", + "from tensorflow.keras.models import load_model\n", + "import sys\n", + "import argparse\n", + "from src.exp_optimization.util import *\n", + "from src.exp_optimization.framepool import *\n", + "\n", + "tf.compat.v1.enable_eager_execution()\n", + "\n", + "from Bio import SeqIO\n", + "import pandas as pd\n", + "import numpy as np\n", + "import requests, sys\n", + "from src.exp_optimization.popen import Auto_popen\n", + "\n", + "abs_path = './src/mrl_te_optimization/log/Backbone/RL_hard_share/3M/small_repective_filed_strides1113.ini'\n", + "Configuration = Auto_popen(abs_path)\n", + "\n", + "np.random.seed(25)\n", + "\n", + "BATCH_SIZE = 100\n", + "N_GENES = 8\n", + "LR = 0.001\n", + "GPU = '0'\n", + "STEPS = 10\n", + "\n", + "if GPU == '-1':\n", + " device = 'cpu'\n", + "else:\n", + " os.environ['CUDA_VISIBLE_DEVICES'] = GPU\n", + " device = 'cuda'\n", + "\n", + "SEQ_BATCH = N_GENES\n", + "UTR_LEN = 128\n", + "DIM = 40\n", + "gpath = './models/checkpoint_3000.h5'\n", + "mrl_path = './models/utr_model_combined_residual_new.h5'\n", + "exp_path = './models/humanMedian_trainepoch.11-0.426.h5'\n", + "tpath = './src/exp_optimization/script/checkpoint/RL_hard_share_MTL/3R/schedule_MTL-model_best_cv1.pth'\n", + "LR = np.exp(-int(LR))\n", + "\n", + "gene_names = [\"MYOC\", \"TIGD4\", \"ATP6V1B2\", \"TAGLN\", \"COX7A2L\", \"IFNGR2\", \"TNFRSF21\", \"SETD6\"]\n", + "\n", + "target_genes = [\"ANTXR2\", \"NFIL3\", \"UNC13D\", \"DHRS2\", \"RPS13\", \"HBD\", \"METAP1D\", \"NCALD\"]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3a95c1ae", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'Model' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 387\u001b[0m\n\u001b[1;32m 375\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mGenerated \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mn_utrs\u001b[38;5;250m \u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;250m \u001b[39mn_genes\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m modified sequences (expected: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexpected_count\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 377\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m all_modified_sequences\n\u001b[0;32m--> 387\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconvert_model\u001b[39m(model_:\u001b[43mModel\u001b[49m):\n\u001b[1;32m 389\u001b[0m input_ \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mlayers\u001b[38;5;241m.\u001b[39mInput(shape\u001b[38;5;241m=\u001b[39m( \u001b[38;5;241m10500\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[1;32m 390\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m input_\n", + "\u001b[0;31mNameError\u001b[0m: name 'Model' is not defined" + ] + } + ], + "source": [ + "\n", + "\n", + "def reverse_complement(sequence):\n", + " \"\"\"Compute the reverse complement of a DNA sequence.\"\"\"\n", + " complement = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C', \n", + " 'a': 't', 't': 'a', 'c': 'g', 'g': 'c', 'N': 'N', 'n': 'N'}\n", + " return ''.join(complement.get(base, 'N') for base in reversed(sequence))\n", + "\n", + "class GeneInfoRetriever:\n", + " def __init__(self):\n", + " self.base_url = \"https://rest.ensembl.org\"\n", + " self.headers = {\"Content-Type\": \"application/json\"}\n", + " self.sleep_time = 0.5 # Respect Ensembl API rate limits\n", + "\n", + " def _make_request(self, endpoint):\n", + " \"\"\"Make a request to the Ensembl REST API.\"\"\"\n", + " url = self.base_url + endpoint\n", + " try:\n", + " response = requests.get(url, headers=self.headers)\n", + " time.sleep(self.sleep_time)\n", + " if response.status_code == 200:\n", + " return response.json()\n", + " else:\n", + " print(f\"Error: {response.status_code} - {response.text}\")\n", + " return None\n", + " except Exception as e:\n", + " print(f\"Request error: {e}\")\n", + " return None\n", + "\n", + " def get_gene_id(self, gene_symbol, species=\"homo_sapiens\"):\n", + " \"\"\"Retrieve the Ensembl gene ID for a gene symbol.\"\"\"\n", + " endpoint = f\"/lookup/symbol/{species}/{gene_symbol}\"\n", + " response = self._make_request(endpoint)\n", + " return response.get(\"id\") if response else None\n", + "\n", + " def get_gene_coordinates(self, gene_id):\n", + " \"\"\"Retrieve genomic coordinates for a gene ID.\"\"\"\n", + " endpoint = f\"/lookup/id/{gene_id}?expand=1\"\n", + " response = self._make_request(endpoint)\n", + " if response:\n", + " return {\n", + " \"chromosome\": response.get(\"seq_region_name\"),\n", + " \"start\": response.get(\"start\"),\n", + " \"end\": response.get(\"end\"),\n", + " \"strand\": response.get(\"strand\")\n", + " }\n", + " return None\n", + "\n", + " def get_tss_and_utr(self, gene_id):\n", + " \"\"\"Retrieve TSS and 5' UTR coordinates for the canonical transcript.\"\"\"\n", + " endpoint = f\"/lookup/id/{gene_id}?expand=1&utr=1\"\n", + " response = self._make_request(endpoint)\n", + " if not response or \"Transcript\" not in response:\n", + " return None\n", + "\n", + " # Find canonical transcript\n", + " canonical_transcript = None\n", + " for transcript in response[\"Transcript\"]:\n", + " if transcript.get(\"is_canonical\", 0) == 1:\n", + " canonical_transcript = transcript\n", + " break\n", + " if not canonical_transcript:\n", + " for transcript in response[\"Transcript\"]:\n", + " if transcript.get(\"biotype\") == \"protein_coding\":\n", + " canonical_transcript = transcript\n", + " break\n", + " if not canonical_transcript:\n", + " canonical_transcript = response[\"Transcript\"][0] if response[\"Transcript\"] else None\n", + "\n", + " if not canonical_transcript:\n", + " return None\n", + "\n", + " # Determine TSS and 5' UTR\n", + " strand = canonical_transcript.get(\"strand\")\n", + " tss = canonical_transcript[\"start\"] if strand == 1 else canonical_transcript[\"end\"]\n", + " five_prime_utr = None\n", + "\n", + " if \"UTR\" in canonical_transcript:\n", + " for utr in canonical_transcript[\"UTR\"]:\n", + " if utr.get(\"object_type\") == \"five_prime_UTR\":\n", + " five_prime_utr = {\n", + " \"start\": utr.get(\"start\"),\n", + " \"end\": utr.get(\"end\")\n", + " }\n", + " break\n", + "\n", + " # Verify TSS matches 5' UTR start\n", + " if five_prime_utr:\n", + " expected_tss = five_prime_utr[\"start\"] if strand == 1 else five_prime_utr[\"end\"]\n", + " if expected_tss != tss:\n", + " print(f\"Warning: Adjusting TSS from {tss} to match 5' UTR {'start' if strand == 1 else 'end'} ({expected_tss})\")\n", + " tss = expected_tss\n", + "\n", + " return {\n", + " \"tss\": tss,\n", + " \"strand\": strand,\n", + " \"chromosome\": canonical_transcript.get(\"seq_region_name\"),\n", + " \"five_prime_utr\": five_prime_utr,\n", + " \"transcript_id\": canonical_transcript.get(\"id\")\n", + " }\n", + "\n", + " def get_promoter_sequence(self, gene_id, upstream=8000, downstream=4000):\n", + " \"\"\"Retrieve sequence around TSS (8kb upstream, 4kb downstream).\"\"\"\n", + " tss_info = self.get_tss_and_utr(gene_id)\n", + " if not tss_info:\n", + " return None, None\n", + "\n", + " chromosome = tss_info[\"chromosome\"]\n", + " strand = tss_info[\"strand\"]\n", + " tss_position = tss_info[\"tss\"]\n", + "\n", + " # Calculate region based on strand\n", + " if strand == 1:\n", + " seq_start = tss_position - upstream\n", + " seq_end = tss_position + downstream - 1\n", + " else:\n", + " seq_start = tss_position - downstream\n", + " seq_end = tss_position + upstream - 1\n", + "\n", + " seq_start = max(1, seq_start)\n", + "\n", + " # Store sequence coordinates\n", + " sequence_coords = {\n", + " \"chromosome\": chromosome,\n", + " \"start\": seq_start,\n", + " \"end\": seq_end,\n", + " \"strand\": 1 if strand == 1 else -1\n", + " }\n", + "\n", + " # Validate 5' UTR inclusion\n", + " if tss_info[\"five_prime_utr\"]:\n", + " utr_start = tss_info[\"five_prime_utr\"][\"start\"]\n", + " utr_end = tss_info[\"five_prime_utr\"][\"end\"]\n", + " if not (seq_start <= utr_start <= seq_end and seq_start <= utr_end <= seq_end):\n", + " print(f\"Warning: 5' UTR ({utr_start}-{utr_end}) not fully within sequence ({seq_start}-{seq_end})\")\n", + "\n", + " # Get sequence\n", + " strand_str = \"1\" if strand == 1 else \"-1\"\n", + " endpoint = f\"/sequence/region/human/{chromosome}:{seq_start}..{seq_end}:{strand_str}\"\n", + " response = self._make_request(endpoint)\n", + " return response.get(\"seq\") if response else None, sequence_coords\n", + "\n", + " def get_gene_info(self, gene_symbol, species=\"homo_sapiens\", output_json=\"gene_info.json\"):\n", + " \n", + " if not os.path.exists(os.path.join('./.cache/',f\"{gene_symbol}_info.json\")):\n", + "\n", + " \"\"\"Retrieve and save promoter sequence, TSS, 5' UTR, and coordinates.\"\"\"\n", + " # Get gene ID\n", + " gene_id = self.get_gene_id(gene_symbol, species)\n", + " if not gene_id:\n", + " return {\"error\": f\"Gene {gene_symbol} not found\"}\n", + "\n", + " # Get TSS and 5' UTR\n", + " tss_info = self.get_tss_and_utr(gene_id)\n", + " if not tss_info:\n", + " return {\"error\": \"Could not retrieve TSS or transcript information\"}\n", + "\n", + " # Get promoter sequence and coordinates\n", + " promoter_sequence, sequence_coords = self.get_promoter_sequence(gene_id)\n", + " if not promoter_sequence:\n", + " return {\"error\": \"Could not retrieve promoter sequence\"}\n", + "\n", + " # Compile gene information\n", + " gene_info = {\n", + " \"gene_symbol\": gene_symbol,\n", + " \"gene_id\": gene_id,\n", + " \"promoter_sequence\": promoter_sequence,\n", + " \"sequence_length\": len(promoter_sequence),\n", + " \"sequence_coordinates\": sequence_coords,\n", + " \"tss\": {\n", + " \"chromosome\": tss_info[\"chromosome\"],\n", + " \"position\": tss_info[\"tss\"],\n", + " \"strand\": \"+\" if tss_info[\"strand\"] == 1 else \"-\"\n", + " },\n", + " \"five_prime_utr\": tss_info[\"five_prime_utr\"],\n", + " \"transcript_id\": tss_info[\"transcript_id\"]\n", + " }\n", + "\n", + " # Save to JSON\n", + " try:\n", + " os.makedirs(os.path.dirname('./.cache/'), exist_ok=True)\n", + " with open(os.path.join('./.cache/',f\"{gene_symbol}_info.json\"), \"w\") as f:\n", + " json.dump(gene_info, f, indent=2)\n", + " print(f\"Saved gene information to {output_json}\")\n", + " except Exception as e:\n", + " print(f\"Error saving JSON: {e}\")\n", + "\n", + " else:\n", + "\n", + " with open(os.path.join('./.cache/',f\"{gene_symbol}_info.json\"), \"r\") as f:\n", + " gene_info = json.load(f)\n", + "\n", + " return gene_info\n", + "\n", + " def reverse_complement(self, sequence):\n", + " \"\"\"Compute the reverse complement of a DNA sequence.\"\"\"\n", + " complement = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C', \n", + " 'a': 't', 't': 'a', 'c': 'g', 'g': 'c', 'N': 'N', 'n': 'N'}\n", + " return ''.join(complement.get(base, 'N') for base in reversed(sequence))\n", + "\n", + " def replace_utr_in_sequence(self, gene_info_file, generated_utrs, target_length=10500, output_prefix=\"modified_sequence\", write_json=False, verbose=False):\n", + " \"\"\"\n", + " Replace original 5' UTR with generated UTRs, ensuring 10,500nt output.\n", + " \n", + " Parameters:\n", + " gene_info_file (str): Path to JSON file with gene information\n", + " generated_utrs (list): List of generated 5' UTR sequences (64-128nt)\n", + " target_length (int): Desired output sequence length (default: 10500)\n", + " output_prefix (str): Prefix for output JSON files\n", + " \n", + " Returns:\n", + " list: List of modified sequences with metadata\n", + " \"\"\"\n", + " try:\n", + " # Read gene information\n", + " with open(gene_info_file, \"r\") as f:\n", + " gene_info = json.load(f)\n", + "\n", + " original_sequence = gene_info[\"promoter_sequence\"]\n", + " strand = gene_info[\"tss\"][\"strand\"]\n", + " tss_position = gene_info[\"tss\"][\"position\"]\n", + " sequence_coords = gene_info[\"sequence_coordinates\"]\n", + " seq_start = sequence_coords[\"start\"]\n", + " seq_end = sequence_coords[\"end\"]\n", + " five_prime_utr = gene_info[\"five_prime_utr\"]\n", + " gene_symbol = gene_info[\"gene_symbol\"]\n", + " transcript_id = gene_info[\"transcript_id\"]\n", + "\n", + " if not five_prime_utr:\n", + " print(f\"Error: No 5' UTR information available for {gene_symbol}\")\n", + " return []\n", + "\n", + " # Calculate original 5' UTR position in sequence\n", + " if strand == \"+\":\n", + " utr_start_genomic = five_prime_utr[\"start\"]\n", + " utr_end_genomic = five_prime_utr[\"end\"]\n", + " utr_start_seq = utr_start_genomic - seq_start\n", + " utr_end_seq = utr_end_genomic - seq_start\n", + " else:\n", + " utr_start_genomic = five_prime_utr[\"end\"] # TSS\n", + " utr_end_genomic = five_prime_utr[\"start\"]\n", + " utr_start_seq = seq_end - utr_start_genomic\n", + " utr_end_seq = seq_end - utr_end_genomic\n", + "\n", + " # Validate UTR positions\n", + " seq_length = len(original_sequence)\n", + " if not (0 <= utr_start_seq <= seq_length and 0 <= utr_end_seq <= seq_length):\n", + " print(f\"Error: 5' UTR coordinates (seq indices {utr_start_seq}-{utr_end_seq}) out of sequence bounds (0-{seq_length}) for {gene_symbol}\")\n", + " return []\n", + "\n", + " original_utr_length = abs(utr_end_genomic - utr_start_genomic) + 1\n", + " if verbose:\n", + " print(f\"Original 5' UTR length for {gene_symbol}: {original_utr_length} nt\")\n", + "\n", + " modified_sequences = []\n", + " for i, new_utr in enumerate(generated_utrs):\n", + " new_utr_length = len(new_utr)\n", + " if not 64 <= new_utr_length <= 128:\n", + " if verbose:\n", + " print(f\"Warning: Generated UTR {i+1} length ({new_utr_length}) outside 64-128nt range for {gene_symbol}\")\n", + " continue\n", + "\n", + " # Construct new sequence\n", + " if strand == \"+\":\n", + " new_sequence = (\n", + " original_sequence[:utr_start_seq] +\n", + " new_utr +\n", + " original_sequence[utr_end_seq + 1:]\n", + " )\n", + " new_utr_start_genomic = utr_start_genomic\n", + " new_utr_end_genomic = utr_start_genomic + new_utr_length - 1\n", + " if len(new_sequence) > target_length:\n", + " new_sequence = new_sequence[:target_length]\n", + " sequence_coords[\"end\"] = seq_start + target_length - 1\n", + " elif len(new_sequence) < target_length:\n", + " if verbose:\n", + " print(f\"Error: Sequence too short ({len(new_sequence)} nt) after UTR replacement for {gene_symbol}\")\n", + " continue\n", + " else:\n", + " new_utr_rc = reverse_complement(new_utr)\n", + " new_sequence = (\n", + " original_sequence[:min(utr_start_seq, utr_end_seq)] +\n", + " new_utr_rc +\n", + " original_sequence[max(utr_start_seq, utr_end_seq) + 1:]\n", + " )\n", + " new_utr_start_genomic = utr_start_genomic\n", + " new_utr_end_genomic = utr_start_genomic - new_utr_length + 1\n", + " if len(new_sequence) > target_length:\n", + " trim_amount = len(new_sequence) - target_length\n", + " new_sequence = new_sequence[trim_amount:]\n", + " sequence_coords[\"start\"] = seq_start + trim_amount\n", + " elif len(new_sequence) < target_length:\n", + " if verbose:\n", + " print(f\"Error: Sequence too short ({len(new_sequence)} nt) after UTR replacement for {gene_symbol}\")\n", + " continue\n", + "\n", + " # Store modified sequence and metadata\n", + " modified_info = {\n", + " \"gene_symbol\": gene_symbol,\n", + " \"transcript_id\": transcript_id,\n", + " \"modified_sequence\": new_sequence,\n", + " \"sequence_length\": len(new_sequence),\n", + " \"sequence_coordinates\": sequence_coords.copy(),\n", + " \"tss\": gene_info[\"tss\"],\n", + " \"five_prime_utr\": {\n", + " \"start\": new_utr_start_genomic,\n", + " \"end\": new_utr_end_genomic,\n", + " \"sequence\": new_utr if strand == \"+\" else new_utr_rc\n", + " },\n", + " \"original_utr_length\": original_utr_length,\n", + " \"new_utr_length\": new_utr_length,\n", + " \"utr_index\": i + 1\n", + " }\n", + "\n", + " # Save to JSON\n", + " if write_json:\n", + " output_file = f\"{output_prefix}_{gene_symbol}_utr_{i+1}.json\"\n", + " try:\n", + " os.makedirs(os.path.dirname(output_file), exist_ok=True)\n", + " with open(output_file, \"w\") as f:\n", + " json.dump(modified_info, f, indent=2)\n", + " print(f\"Saved modified sequence {i+1} for {gene_symbol} to {output_file}\")\n", + " except Exception as e:\n", + " print(f\"Error saving modified sequence {i+1} for {gene_symbol}: {e}\")\n", + "\n", + " modified_sequences.append(modified_info[\"modified_sequence\"])\n", + "\n", + " return modified_sequences\n", + "\n", + " except Exception as e:\n", + " print(f\"Error processing UTR replacement for {gene_info.get('gene_symbol', 'unknown')}: {e}\")\n", + " return []\n", + "\n", + "\n", + " def replace_utr_in_multiple_sequences(self, gene_symbols, generated_utrs, target_length=10500, cache_dir=\"./.cache\", output_prefix=\"modified_sequence\", verbose=False):\n", + " \"\"\"\n", + " Replace 5' UTRs for multiple genes with generated UTRs.\n", + " \n", + " Parameters:\n", + " gene_symbols (list): List of gene names\n", + " generated_utrs (list): List of generated 5' UTR sequences (64-128nt)\n", + " target_length (int): Desired output sequence length (default: 10500)\n", + " cache_dir (str): Directory containing cached gene info JSON files\n", + " output_prefix (str): Prefix for output JSON files\n", + " \n", + " Returns:\n", + " list: List of n_utrs * n_genes modified sequences with metadata\n", + " \"\"\"\n", + " all_modified_sequences = []\n", + " n_utrs = len(generated_utrs)\n", + " n_genes = len(gene_symbols)\n", + "\n", + " for gene_symbol in gene_symbols:\n", + " json_file = os.path.join(cache_dir, f\"{gene_symbol}_info.json\")\n", + " if not os.path.exists(json_file):\n", + " print(f\"Error: Gene info file {json_file} not found\")\n", + " continue\n", + " \n", + " if verbose:\n", + " print(f\"\\nProcessing gene: {gene_symbol}\")\n", + " modified_sequences = self.replace_utr_in_sequence(\n", + " gene_info_file=json_file,\n", + " generated_utrs=generated_utrs,\n", + " target_length=target_length,\n", + " output_prefix=os.path.join(cache_dir, output_prefix)\n", + " )\n", + "\n", + " if modified_sequences:\n", + " all_modified_sequences.extend(modified_sequences)\n", + " else:\n", + " if verbose:\n", + " print(f\"No modified sequences generated for {gene_symbol}\")\n", + "\n", + " expected_count = n_utrs * n_genes\n", + "\n", + " if verbose:\n", + " print(f\"\\nGenerated {n_utrs * n_genes} modified sequences (expected: {expected_count})\")\n", + "\n", + " return all_modified_sequences\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "def convert_model(model_:Model):\n", + "\n", + " input_ = tf.keras.layers.Input(shape=( 10500, 4))\n", + " input = input_\n", + " for i in range(len(model_.layers)-1):\n", + "\n", + " \n", + " if isinstance(model_.layers[i+1],tf.keras.layers.Concatenate):\n", + " paddings = tf.constant([[0,0],[0,6]])\n", + " output = tf.pad(input, paddings, 'CONSTANT')\n", + " input = output\n", + " else:\n", + " if not isinstance(model_.layers[i+1],tf.keras.layers.InputLayer):\n", + " output = model_.layers[i+1](input)\n", + " input = output\n", + "\n", + " if isinstance(model_.layers[i+1],tf.keras.layers.Conv1D):\n", + " pass\n", + "\n", + " model = tf.keras.Model(inputs=input_, outputs=output)\n", + " model.compile(loss=\"mse\", optimizer=\"adam\")\n", + " return model\n", + "\n", + "def one_hot(seq):\n", + " convert = True\n", + " if isinstance(seq, tf.Tensor):\n", + " seq = seq.numpy().astype(str)\n", + " convert = True\n", + "\n", + " num_seqs = len(seq)\n", + " seq_len = len(seq[0])\n", + " seqindex = {'A':0, 'C':1, 'G':2, 'T':3, 'a':0, 'c':1, 'g':2, 't':3}\n", + " seq_vec = np.zeros((num_seqs,seq_len,4), dtype='bool')\n", + " for i in range(num_seqs):\n", + " thisseq = seq[i]\n", + " for j in range(seq_len):\n", + " try:\n", + " seq_vec[i,j,seqindex[thisseq[j]]] = 1\n", + " except:\n", + " pass\n", + " \n", + " if convert:\n", + " seq_vec = tf.convert_to_tensor(seq_vec,dtype=tf.float32)\n", + "\n", + "\n", + " return seq_vec\n", + "\n", + "\n", + "def select_best(scores, seqs, gc_control=False, GC=-1, per_gene=False):\n", + " selected_scores = []\n", + " selected_seqs = []\n", + " if per_gene: \n", + "\n", + " scores = np.asarray(scores)\n", + " seqs = np.asarray(seqs)\n", + " \n", + " A, B, C = np.shape(scores)\n", + " selected_scores = []\n", + " selected_seqs = []\n", + " \n", + " for b in range(B):\n", + "\n", + " best_score = np.max(scores[0, b, :]) \n", + " best_seq = seqs[0, :] \n", + " \n", + " for a in range(1, A):\n", + " current_score = np.max(scores[a, b, :]) \n", + " \n", + " if current_score > best_score:\n", + " if gc_control:\n", + "\n", + " gc_content = get_gc_content(seqs[a, :])\n", + " if gc_content < GC:\n", + " best_score = current_score\n", + " best_seq = seqs[a, :]\n", + " best_a = a\n", + " else:\n", + " best_score = current_score\n", + " best_seq = seqs[a, :]\n", + " best_a = a\n", + " \n", + " selected_scores.append(best_score)\n", + " selected_seqs.append(best_seq)\n", + " \n", + "\n", + " selected_scores = np.array(selected_scores) \n", + " selected_seqs = np.array(selected_seqs) \n", + " else:\n", + " for i in range(len(scores[0])):\n", + " best = scores[1][i]\n", + " best_seq = seqs[1][i]\n", + " for j in range(len(scores)-1):\n", + " if scores[j+1][i] > best:\n", + " if gc_control:\n", + " if get_gc_content(seqs[j][i]) < GC:\n", + " best = scores[j+1][i]\n", + " best_seq = seqs[j+1][i]\n", + " else:\n", + " best = scores[j+1][i]\n", + " best_seq = seqs[j+1][i]\n", + "\n", + " selected_scores.append(best)\n", + " selected_seqs.append(best_seq)\n", + "\n", + " return selected_seqs, selected_scores" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9dcefb89", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:Error in loading the saved optimizer state. As a result, your model is starting with a freshly initialized optimizer.\n", + "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n", + "Saved gene information to MYOC_info.json\n", + "Saved gene information to TIGD4_info.json\n", + "Saved gene information to ATP6V1B2_info.json\n", + "Saved gene information to TAGLN_info.json\n", + "Saved gene information to COX7A2L_info.json\n", + "Saved gene information to IFNGR2_info.json\n", + "Saved gene information to TNFRSF21_info.json\n", + "Saved gene information to SETD6_info.json\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [00:40<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(8,)\n", + "\n", + "Evaluation of Optimization on Original Genes (Log TPM):\n", + "\n", + "Expression Levels (Log TPM):\n", + " Average Initial Log TPM: -0.1834 (TPM: 0.6555)\n", + " Average Optimized Log TPM: -0.0183 (TPM: 0.9587)\n", + " Log TPM Difference: 0.1651\n", + " TPM Improvement: 0.3032 (+46.25% (increase))\n", + "Genes:\n", + "['MYOC', 'TIGD4', 'ATP6V1B2', 'TAGLN', 'COX7A2L', 'IFNGR2', 'TNFRSF21', 'SETD6']\n", + "Average Initial Expression: -0.1834263348579407\n", + "Best Expression: -0.018321754410862923\n", + "Error processing UTR replacement for DHRS2: ufunc 'add' did not contain a loop with signature matching types (dtype('