From 55e13da39580eeb6de646278c9f9da614dcec846 Mon Sep 17 00:00:00 2001 From: j23414 Date: Wed, 30 Nov 2022 08:48:21 -0800 Subject: [PATCH 01/12] copy zika ingest --- ingest/README.md | 89 ++++++ ingest/Snakefile | 82 ++++++ ingest/bin/genbank-url | 109 +++++++ ingest/config/config.yaml | 73 +++++ ingest/config/optional.yaml | 24 ++ ingest/source-data/annotations.tsv | 274 ++++++++++++++++++ ingest/source-data/geolocation-rules.tsv | 16 + .../snakemake_rules/fetch_sequences.smk | 57 ++++ .../snakemake_rules/slack_notifications.smk | 76 +++++ ingest/workflow/snakemake_rules/transform.smk | 156 ++++++++++ .../snakemake_rules/trigger_rebuild.smk | 30 ++ ingest/workflow/snakemake_rules/upload.smk | 76 +++++ 12 files changed, 1062 insertions(+) create mode 100644 ingest/README.md create mode 100644 ingest/Snakefile create mode 100755 ingest/bin/genbank-url create mode 100644 ingest/config/config.yaml create mode 100644 ingest/config/optional.yaml create mode 100644 ingest/source-data/annotations.tsv create mode 100644 ingest/source-data/geolocation-rules.tsv create mode 100644 ingest/workflow/snakemake_rules/fetch_sequences.smk create mode 100644 ingest/workflow/snakemake_rules/slack_notifications.smk create mode 100644 ingest/workflow/snakemake_rules/transform.smk create mode 100644 ingest/workflow/snakemake_rules/trigger_rebuild.smk create mode 100644 ingest/workflow/snakemake_rules/upload.smk diff --git a/ingest/README.md b/ingest/README.md new file mode 100644 index 0000000..2db3aa2 --- /dev/null +++ b/ingest/README.md @@ -0,0 +1,89 @@ +# nextstrain.org/zika/ingest + +This is the ingest pipeline for Zika virus sequences. + +## Usage + +> NOTE: All command examples assume you are within the `ingest` directory. +> If running commands from the outer `zika` directory, please replace the `.` with `ingest` + +Fetch sequences with + +```sh +nextstrain build --cpus 1 . data/sequences_all.ndjson +``` + +Run the complete ingest pipeline with + +```sh +nextstrain build --cpus 1 . +``` + +This will produce two files (within the `ingest` directory): + +- data/metadata_all.tsv +- data/sequences_all.fasta + +Run the complete ingest pipeline and upload results to AWS S3 with + +```sh +nextstrain build . --configfiles config/config.yaml config/optional.yaml +``` + +### Adding new sequences not from GenBank + +#### Static Files + +Do the following to include sequences from static FASTA files. + +1. Convert the FASTA files to NDJSON files with: + + ```sh + wget https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/fasta-to-ndjson -O ingest/bin/fasta-to-ndjson + chmod 755 ingest/bin/fasta-to-ndjson + ./ingest/bin/fasta-to-ndjson \ + --fasta {path-to-fasta-file} \ + --fields {fasta-header-field-names} \ + --separator {field-separator-in-header} \ + --exclude {fields-to-exclude-in-output} \ + > ingest/data/{file-name}.ndjson + ``` + +2. Add the following to the `.gitignore` to allow the file to be included in the repo: + + ```gitignore + !ingest/data/{file-name}.ndjson + ``` + +3. Add the `file-name` (without the `.ndjson` extension) as a source to `ingest/config/config.yaml`. This will tell the ingest pipeline to concatenate the records to the GenBank sequences and run them through the same transform pipeline. + +## Configuration + +Configuration takes place in `config/config.yaml` by default. +Optional configs for uploading files and Slack notifications are in `config/optional.yaml`. + +### Environment Variables + +The complete ingest pipeline with AWS S3 uploads and Slack notifications uses the following environment variables: + +#### Required + +- `AWS_DEFAULT_REGION` +- `AWS_ACCESS_KEY_ID` +- `AWS_SECRET_ACCESS_KEY` +- `SLACK_TOKEN` +- `SLACK_CHANNELS` + +#### Optional + +These are optional environment variables used in our automated pipeline for providing detailed Slack notifications. + +- `GITHUB_RUN_ID` - provided via [`github.run_id` in a GitHub Action workflow](https://docs.github.com/en/actions/learn-github-actions/contexts#github-context) +- `AWS_BATCH_JOB_ID` - provided via [AWS Batch Job environment variables](https://docs.aws.amazon.com/batch/latest/userguide/job_env_vars.html) + +## Input data + +### GenBank data + +GenBank sequences and metadata are fetched via NCBI Virus. +The exact URL used to fetch data is constructed in `bin/genbank-url`. diff --git a/ingest/Snakefile b/ingest/Snakefile new file mode 100644 index 0000000..d370314 --- /dev/null +++ b/ingest/Snakefile @@ -0,0 +1,82 @@ +if not config: + + configfile: "config/config.yaml" + + +send_slack_notifications = config.get("send_slack_notifications", False) + +serotypes = ['all'] + +def _get_all_targets(wildcards): + # Default targets are the metadata TSV and sequences FASTA files + all_targets = expand(["data/sequences_{serotype}.fasta.zst", "data/metadata_{serotype}.tsv.zst"], serotype=serotypes) + + # Add additional targets based on upload config + upload_config = config.get("upload", {}) + + for target, params in upload_config.items(): + files_to_upload = params.get("files_to_upload", []) + remote_file_names = params.get("remote_file_names", []) + + if len(files_to_upload) != len(remote_file_names): + print( + f"Skipping file upload for {target!r} because the number of", + "files to upload does not match the number of remote file names.", + ) + elif len(remote_file_names) != len(set(remote_file_names)): + print( + f"Skipping file upload for {target!r} because there are duplicate remote file names." + ) + elif not params.get("dst"): + print( + f"Skipping file upload for {target!r} because the destintion was not defined." + ) + else: + all_targets.extend( + expand( + [ + f"data/upload/{target}/{{file_to_upload}}-to-{{remote_file_name}}.done" + ], + zip, + file_to_upload=files_to_upload, + remote_file_name=remote_file_names, + ) + ) + + # Add additional targets for Nextstrain's internal Slack notifications + if send_slack_notifications: + all_targets.extend( + [ + "data/notify/genbank-record-change.done", + "data/notify/metadata-diff.done", + ] + ) + + if config.get("trigger_rebuild"): + all_targets.append("data/trigger/rebuild.done") + + return all_targets + + +rule all: + input: + _get_all_targets, + + +include: "workflow/snakemake_rules/fetch_sequences.smk" +include: "workflow/snakemake_rules/transform.smk" + + +if config.get("upload"): + + include: "workflow/snakemake_rules/upload.smk" + + +if send_slack_notifications: + + include: "workflow/snakemake_rules/slack_notifications.smk" + + +if config.get("trigger_rebuild"): + + include: "workflow/snakemake_rules/trigger_rebuild.smk" diff --git a/ingest/bin/genbank-url b/ingest/bin/genbank-url new file mode 100755 index 0000000..881e8b6 --- /dev/null +++ b/ingest/bin/genbank-url @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +""" +Generate URL to download all Pathogen sequences and their curated metadata +from GenBank via NCBI Virus. + +The URL this program builds is based on the URL for SARS-CoV-2 constructed with + + https://github.com/nextstrain/ncov-ingest/blob/2a5f255329ee5bdf0cabc8b8827a700c92becbe4/bin/genbank-url + +and observing the network activity at + + https://www.ncbi.nlm.nih.gov/labs/virus/vssi/#/virus?SeqType_s=Nucleotide&VirusLineage_ss=Monkeypox%20virus,%20taxid:10244 + https://www.ncbi.nlm.nih.gov/labs/virus/vssi/#/virus?SeqType_s=Nucleotide&VirusLineage_ss=Dengue%20virus,%20taxid:12637 +""" +from urllib.parse import urlencode +import argparse +from datetime import date + +def parse_args(): + """ + Define parse args + """ + parser = argparse.ArgumentParser( + description="Given an NCBI taxon ID, generate URL to download " + "all viral sequences and their curated metadata from GenBank via NCBI Virus." + ) + parser.add_argument( + "--taxonid", + help="NCBI Taxon ID.", + required=True + ) + return parser.parse_args() + + +def build_query_url(ncbi_id: str): + """ + Generate URL to download all viral sequences and their curated metadata + from GenBank via NCBI Virus. + """ + today = str(date.today().strftime("%Y-%m-%d")) + endpoint = "https://www.ncbi.nlm.nih.gov/genomes/VirusVariation/vvsearch2/" + params = { + # Search criteria + 'fq': [ + '{!tag=SeqType_s}SeqType_s:("Nucleotide")', # Nucleotide sequences (as opposed to protein) + f'VirusLineageId_ss:({ncbi_id})', # NCBI Taxon id for virus + 'Division_s:("VRL")', # Restrict to viral sequences, avoid PAT + '{!tag=SLen_i}SLen_i:([5000 TO 15000])', # Longer than 5K bp, shorter than 15k bp + '{!tag=CollectionDate_s}CollectionDate_s:([2013-01-01T00:00:00.00Z TO ' + today + 'T00:00:00.00Z ])', # after 2013 + #'{!tag=UpdateDate_dt}UpdateDate_dt:([2022-01-01T00:00:00.00Z TO 2022-12-01T00:00:00.00Z ])', # recent + ], +# + # Unclear, but seems necessary. + 'q': '*:*', + + # Response format + 'cmd': 'download', + 'dlfmt': 'csv', + 'fl': ','.join( + ':'.join(names) for names in [ + # Pairs of (output column name, source data field). + ('genbank_accession', 'id'), + ('genbank_accession_rev', 'AccVer_s'), + ('database', 'SourceDB_s'), + ('strain', 'Isolate_s'), + ('strain_s', 'Strain_s'), # Derive strain name if Isolate_s is empty + ('viruslineage_ids', 'VirusLineageId_ss'), # Derive denv1 to 4 based on lineage ID + ('region', 'Region_s'), + ('location', 'CountryFull_s'), + ('collected', 'CollectionDate_s'), + ('submitted', 'CreateDate_dt'), + ('updated', 'UpdateDate_dt'), # Check for recent updates to the record + ('length', 'SLen_i'), + ('host', 'Host_s'), + ('isolation_source', 'Isolation_csv'), + ('bioproject_accession', 'BioProject_s'), + ('biosample_accession', 'BioSample_s'), + ('sra_accession', 'SRALink_csv'), + ('title', 'Definition_s'), # Should be PubMed title, not Definition + ('authors', 'Authors_csv'), + ('submitting_organization', 'SubmitterAffilFull_s'), + ('publications', 'PubMed_csv'), + ('sequence', 'Nucleotide_seq'), + ] + ), + + # Stable sort with GenBank accessions. + # Columns are source data fields, not our output columns. + 'sort': 'id asc', + + # This isn't Entrez, but include the same email parameter it requires just + # to be nice. + 'email': 'hello@nextstrain.org', + } + query = urlencode(params, doseq=True, encoding="utf-8") + + print(f"{endpoint}?{query}") + + +def main(): + """ + Main method + """ + args = parse_args() + build_query_url(args.taxonid) + + +if __name__ == "__main__": + main() diff --git a/ingest/config/config.yaml b/ingest/config/config.yaml new file mode 100644 index 0000000..e0ab1c1 --- /dev/null +++ b/ingest/config/config.yaml @@ -0,0 +1,73 @@ +# Sources of sequences to include in the ingest run +sources: ['genbank'] + +# Params for the transform rule +transform: + # Fields to rename. + # This is the first step in the pipeline, so any references to field names + # in the configs below should use the new field names + field_map: ['collected=date', 'submitted=date_submitted', 'genbank_accession=accession', 'submitting_organization=institution'] + # Standardized strain name regex + # Currently accepts any characters because we do not have a clear standard for strain names + strain_regex: '^.+$' + # Back up strain name field if 'strain' doesn't match regex above + strain_backup_fields: ['accession'] + # List of date fields to standardize + date_fields: ['date', 'date_submitted', 'updated'] + # Expected date formats present in date fields + # These date formats should use directives expected by datetime + # See https://docs.python.org/3.9/library/datetime.html#strftime-and-strptime-format-codes + expected_date_formats: ['%Y', '%Y-%m', '%Y-%m-%d', '%Y-%m-%dT%H:%M:%SZ'] + # Titlecase rules + titlecase: + # Abbreviations not cast to titlecase, keeps uppercase + abbreviations: ['USA'] + # Articles that should not be cast to titlecase + articles: [ + 'and', 'd', 'de', 'del', 'des', 'di', 'do', 'en', 'l', 'la', 'las', 'le', + 'los', 'nad', 'of', 'op', 'sur', 'the', 'y' + ] + # List of string fields to titlecase + fields: ['region', 'country', 'division', 'location'] + # Authors field name + authors_field: 'authors' + # Authors default value if authors value is empty + authors_default_value: '?' + # Field name for the generated abbreviated authors + abbr_authors_field: 'abbr_authors' + # General geolocation rules to apply to geolocation fields + geolocation_rules_url: 'https://raw.githubusercontent.com/nextstrain/ncov-ingest/master/source-data/gisaid_geoLocationRules.tsv' + # Local geolocation rules that are only applicable to dengue data + # Local rules can overwrite the general geolocation rules provided above + local_geolocation_rules: './source-data/geolocation-rules.tsv' + # User annotations file + annotations: 'source-data/annotations.tsv' + # ID field used to merge annotations + annotations_id: 'accession' + # Field to use as the sequence ID in the FASTA file + id_field: 'accession' + # Field to use as the sequence in the FASTA file + sequence_field: 'sequence' + # Final output columns for the metadata TSV + metadata_columns: [ + 'accession', + 'genbank_accession_rev', + 'strain', + 'strain_s', + 'viruslineage_ids', + 'date', + 'updated', + 'region', + 'country', + 'division', + 'location', + 'host', + 'date_submitted', + 'sra_accession', + 'abbr_authors', + 'reverse', + 'authors', + 'institution', + 'title', + 'publications' + ] diff --git a/ingest/config/optional.yaml b/ingest/config/optional.yaml new file mode 100644 index 0000000..dbc790b --- /dev/null +++ b/ingest/config/optional.yaml @@ -0,0 +1,24 @@ +# Optional configs used by Nextstrain team +# Params for uploads +upload: + # Upload params for AWS S3 + s3: + # AWS S3 Bucket with prefix + dst: 's3://nextstrain-data/files/workflows/zika/test' + # Files to upload to S3 that are in the `data` directory + files_to_upload: [ + 'metadata_all.tsv', + 'sequences_all.fasta', + ] + # Remote file names for the files to upload, must be in the same order as local files above + remote_file_names: [ + 'metadata_all.tsv.zst', + 'sequences_all.fasta.zst', + ] + cloudfront_domain: 'data.nextstrain.org' + +# Toggle for Slack notifications +send_slack_notifications: False + +# Toggle for triggering builds +trigger_rebuild: False diff --git a/ingest/source-data/annotations.tsv b/ingest/source-data/annotations.tsv new file mode 100644 index 0000000..4dec4d1 --- /dev/null +++ b/ingest/source-data/annotations.tsv @@ -0,0 +1,274 @@ +AF380138 country Democratic Republic of the Congo +AY741551 country Sierra Leone +DQ011153 country USA +DQ011154 country Republic of the Congo +DQ011155 country Democratic Republic of the Congo +DQ011156 country Liberia +DQ011157 country USA +NC_003310 country Democratic Republic of the Congo +AF380138 region Africa +AY741551 region Africa +AY753185 region Africa +DQ011153 region North America +DQ011154 region Africa +DQ011155 region Africa +DQ011156 region Africa +DQ011157 region North America +NC_003310 region Africa +AY603973 date 1961-XX-XX +AY741551 date 1970-XX-XX +AY753185 date 1958-XX-XX +DQ011153 date 2003-XX-XX +DQ011156 date 1970-XX-XX +DQ011157 date 2003-XX-XX +LC722946 date 2022-07-XX +MG693723 date 2017-XX-XX +AF380138 date 1996-XX-XX +DQ011154 date 2003-XX-XX +DQ011155 date 1978-XX-XX +HM172544 date 1979-XX-XX +HQ857562 date 1979-XX-XX +MT903337 date 2018-XX-XX +MT903338 date 2018-XX-XX +MT903339 date 2018-XX-XX +MT903340 date 2018-XX-XX +MT903341 date 2018-08-14 +MT903342 date 2019-04-30 +MT903342 date 2019-05-XX +MT903343 date 2018-09-XX +MT903344 date 2018-09-XX +MT903345 date 2018-09-XX +MT903346 date 2003-XX-XX +MT903347 date 2003-XX-XX +MT903348 date 2003-XX-XX +ON782021 date 2022-05-24 +ON782022 date 2022-05-31 +ON880529 date 2022-05-28 +ON880533 date 2022-05-30 +ON880534 date 2022-05-30 +OP536786 date 2022-XX-XX +OX044336 date 2022-XX-XX +OX044337 date 2022-XX-XX +OX044338 date 2022-XX-XX +OX044339 date 2022-XX-XX +OX044340 date 2022-XX-XX +OX044341 date 2022-XX-XX +OX044342 date 2022-XX-XX +OX044343 date 2022-XX-XX +OX044344 date 2022-XX-XX +OX044345 date 2022-XX-XX +OX044346 date 2022-XX-XX +OX044347 date 2022-XX-XX +OX044348 date 2022-XX-XX +OX344864 date 2022-XX-XX +OX344865 date 2022-XX-XX +OX344866 date 2022-XX-XX +OX344867 date 2022-XX-XX +OX344868 date 2022-XX-XX +OX344869 date 2022-XX-XX +OX344870 date 2022-XX-XX +OX344871 date 2022-XX-XX +OX344872 date 2022-XX-XX +OX344873 date 2022-XX-XX +OX344874 date 2022-XX-XX +OX344875 date 2022-XX-XX +OX344876 date 2022-XX-XX +OX344877 date 2022-XX-XX +OX344878 date 2022-XX-XX +OX344879 date 2022-XX-XX +OX344880 date 2022-XX-XX +OX344881 date 2022-XX-XX +OX344882 date 2022-XX-XX +OX344883 date 2022-XX-XX +OX344884 date 2022-XX-XX +OX344885 date 2022-XX-XX +OX344886 date 2022-XX-XX +OX344887 date 2022-XX-XX +OX344888 date 2022-XX-XX +OX344889 date 2022-XX-XX +OX344890 date 2022-XX-XX +AF380138 strain Zaire-96-I-16 +DQ011154 strain Congo_2003_358 +DQ011155 strain Zaire_1979-005 +HM172544 strain Zaire 1979-005 +HQ857562 strain V79-I-005 +MT903338 strain MPXV-M2957_Lagos +AY603973 institution Biochemistry & Microbiology, University of Victoria, Canada +AY741551 institution Biochemistry & Microbiology, University of Victoria, Canada +AY753185 institution Biochemistry & Microbiology, University of Victoria, Canada +DQ011153 institution National Center for Infectious Diseases, Centers for Disease Control and Prevention (US CDC), USA +DQ011154 institution National Center for Infectious Diseases, Centers for Disease Control and Prevention (US CDC), USA +DQ011156 institution National Center for Infectious Diseases, Centers for Disease Control and Prevention (US CDC), USA +DQ011157 institution National Center for Infectious Diseases, Centers for Disease Control and Prevention (US CDC), USA +FV537349 institution Genetics Signatures, Sydney, Australia +FV537350 institution Genetics Signatures, Sydney, Australia +FV537351 institution Genetics Signatures, Sydney, Australia +FV537352 institution Genetics Signatures, Sydney, Australia +HM172544 institution Virology, The United States Army Medical Research Institute for Infectious Diseases (USAMRIID), USA +HQ857562 institution Vaccine and Gene Therapy Institute, Oregon Health and Science University, USA +HQ857563 institution Vaccine and Gene Therapy Institute, Oregon Health and Science University, USA +JX878407 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878408 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878409 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878410 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878411 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878412 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878413 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878414 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878415 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878416 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878417 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878418 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878419 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878420 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878421 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878422 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878423 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878424 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878425 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878426 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878427 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878428 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +JX878429 institution Center for Genome Sciences, United States Army Medical Research Institute of Infectious Diseases (USAMRIID), USA +KC257459 institution Biochemistry & Microbiology, University of Victoria, Canada +KC257460 institution Biochemistry & Microbiology, University of Victoria, Canada +KJ136820 institution Centre for Biological Security, Robert Koch Institute, Germany +KJ642612 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642613 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642614 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642615 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642616 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642617 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642618 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KJ642619 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KP849469 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KP849470 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +KP849471 institution Poxvirus Program, Centres for Disease Control and prevention (US CDC), USA +MK783028 institution NCEZID/DHCPP/PRB, Centers for Disease Control & Prevention (US CDC), USA +MK783029 institution NCEZID/DHCPP/PRB, Centers for Disease Control & Prevention (US CDC), USA +MK783030 institution NCEZID/DHCPP/PRB, Centers for Disease Control & Prevention (US CDC), USA +MK783031 institution NCEZID/DHCPP/PRB, Centers for Disease Control & Prevention (US CDC), USA +MK783032 institution NCEZID/DHCPP/PRB, Centers for Disease Control & Prevention (US CDC), USA +MN346690 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346692 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346693 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346694 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346695 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346696 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346698 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346699 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346700 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN346702 institution Project Group Epidemiology of Highly Pathogenic Microorganisms, Robert Koch Institute, Germany +MN648051 institution Biochemistry & Molecular Genetics, Israel Institute for Biological Research, Israel +MN702444 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702445 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702446 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702447 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702448 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702449 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702450 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702451 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702452 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MN702453 institution Virology, Centre International de Recherches Medicales de Franceville, CIRMF, Gabon +MT724769 institution Biology, Universiteit Antwerpen, Belgium +MT724770 institution Biology, Universiteit Antwerpen, Belgium +MT724771 institution Biology, Universiteit Antwerpen, Belgium +MT724772 institution Biology, Universiteit Antwerpen, Belgium +MT903337 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903338 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903339 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903340 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903341 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903342 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903343 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903344 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903345 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903346 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903347 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +MT903348 institution National Center for Emerging and Zoonotic Infectious Diseases, Division of High Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +NC_003310 institution Department of Molecular Biology of Genomes, SRC VB Vector, Russia +ON563414 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON568298 institution Microbiol Genomics & Bioinformatics, Bundeswehr Institute of Microbiology, Germany +ON585029 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585030 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585031 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585032 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585033 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585034 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585035 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585036 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585037 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON585038 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON595760 institution Laboratory of Viorology, University Hospital of Geneva, Switzerland +ON602722 institution IHAP, VIRAL, Universite de Toulouse, INRAE, ENVT, France +ON609725 institution Laboratory for Diagnostics of Zoonoses & WHO Centre, Institute of Microbiology & Immunology, Faculty of Medicine, University of Ljubljana, Slovenia +ON614676 institution Laboratory of Virology, INMI Lazzaro Spallanzani IRCCS, Italy +ON615424 institution Public Health Virology, Erasmus Medical Centre, The Netherlands +ON619835 institution Research & Evaluation, UKHSA, UK +ON619836 institution Research & Evaluation, UKHSA, UK +ON619837 institution Research & Evaluation, UKHSA, UK +ON619838 institution Research & Evaluation, UKHSA, UK +ON622712 institution Microbiology, Immunology & Transplantation, KU Leuven, Rega Institute, Belgium +ON622713 institution Microbiology, Immunology & Transplantation, KU Leuven, Rega Institute, Belgium +ON622718 institution Microbiology, Hospital Universitari Germans Trias i Pujol, Spain +ON622720 institution Laboratory of Viorology, University Hospital of Geneva, Switzerland +ON622721 institution Department of Biomedical & Clinical Sciences, University of Milan, Italy +ON622722 institution Virology, GENomique EPIdemiologique das maladies Infectieuses, France +ON627808 institution Department of Health, Utah Public Health Laboratory, USA +ON631241 institution Laboratory for Diagnostics of Zoonoses & WHO Centre, Institute of Microbiology & Immunology, Faculty of Medicine, University of Ljubljana, Slovenia +ON631963 institution Victorian Infectious Diseases Reference Laboratory, Doherty Institute, Australia +ON637938 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON637939 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON644344 institution Genomics & Epigenomics, AREA Science Park, Italy +ON645312 institution Centre for Clinical Infection & Diagnostics Research, Kings College London, St Thomas Hospital, UK +ON649708 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649709 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649710 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649711 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649712 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649713 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649714 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649715 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649716 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649717 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649718 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649719 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649720 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649721 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649722 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649723 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649724 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649725 institution Institute National de Saude Doutor Ricardo Jorge (INSA), Portugal +ON649879 institution Biochemistry & Molecular Genetics, Israel Institute for Biological Research, Israel +ON674051 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON675438 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON676703 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON676704 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON676705 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON676706 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON676707 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON676708 institution Division of High-Consequence Pathogens & Pathology, Centers for Disease Control & Prevention (US CDC), USA +ON682263 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682264 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682265 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682266 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682267 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682268 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682269 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON682270 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694329 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694330 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694331 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694332 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694333 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694334 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694335 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694336 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694337 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694338 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694339 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694340 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694341 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON694342 institution Centre for Biological Threats, Highly Pathogenic Viruses, Robert Koch Institute, Germany +ON720848 institution Microbial Genomics, Hospital General Universitario Gregorio Marañón, Madrid, Spain +ON720849 institution Microbial Genomics, Hospital General Universitario Gregorio Marañón, Madrid, Spain diff --git a/ingest/source-data/geolocation-rules.tsv b/ingest/source-data/geolocation-rules.tsv new file mode 100644 index 0000000..2fc03f8 --- /dev/null +++ b/ingest/source-data/geolocation-rules.tsv @@ -0,0 +1,16 @@ +Africa/Cote d'Ivoire/*/* Africa/Côte d'Ivoire/*/* +Africa/Cote d'Ivoire/Tai National Park/* Africa/Côte d'Ivoire/Bas-Sassandra/Tai National Park +Africa/Democratic Republic of the Congo/Province Bandundu/* Africa/Democratic Republic of the Congo/Bandundu/* +Africa/Democratic Republic of the Congo/Province Equateur/* Africa/Democratic Republic of the Congo/Équateur/* +Africa/Democratic Republic of the Congo/Province Kasai Occidental/* Africa/Democratic Republic of the Congo/Kasaï-Occidental/* +Africa/Democratic Republic of the Congo/Province Kasai Oriental/* Africa/Democratic Republic of the Congo/Kasaï-Oriental/* +Africa/Democratic Republic of the Congo/Province P. Oriental/* Africa/Democratic Republic of the Congo/Orientale/* +Africa/Democratic Republic of the Congo/Yangdongi/ Africa/Democratic Republic of the Congo/Mongala/Yangdongi +Africa/Democratic Republic of the Congo/Zaire/* Africa/Democratic Republic of the Congo// +Africa/Zaire/*/* Africa/Democratic Republic of the Congo// +*/Zaire/*/* Africa/Democratic Republic of the Congo// +Europe/France/Paris/* Europe/France/Ile de France/Paris FR +Europe/Italy/Fvg/Gorizia Europe/Italy/Friuli Venezia Giulia/Gorizia +# Unclear which location is the real location +Europe/Netherlands/Utrecht/Rotterdam Europe/Netherlands// +North America/USA/Washington/Dc North America/USA/Washington DC/ diff --git a/ingest/workflow/snakemake_rules/fetch_sequences.smk b/ingest/workflow/snakemake_rules/fetch_sequences.smk new file mode 100644 index 0000000..158869b --- /dev/null +++ b/ingest/workflow/snakemake_rules/fetch_sequences.smk @@ -0,0 +1,57 @@ +""" +This part of the workflow handles fetching sequences from various sources. +Uses `config.sources` to determine which sequences to include in final output. + +Currently only fetches sequences from GenBank, but other sources can be +defined in the config. If adding other sources, add a new rule upstream +of rule `fetch_all_sequences` to create the file `data/{source}.ndjson` or the +file must exist as a static file in the repo. + +Produces final output as + + sequences_ndjson = "data/sequences.ndjson" + +""" + +def download_serotype(w): + serotype = { + 'all': '64320', + } + return serotype[w.serotype] + +rule fetch_from_genbank: + output: + genbank_ndjson="data/genbank_{serotype}.ndjson", + params: + serotype_tax_id=download_serotype, + csv_to_ndjson_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/csv-to-ndjson", + fetch_from_genbank_url="https://raw.githubusercontent.com/nextstrain/dengue/new_ingest/ingest/bin/fetch-from-genbank", + genbank_url_url="https://raw.githubusercontent.com/nextstrain/dengue/new_ingest/ingest/bin/genbank-url", # Update if dengue merged + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + cd bin + [[ -f csv-to-ndjson ]] || wget {params.csv_to_ndjson_url} + [[ -f genbank-url ]] || wget {params.genbank_url_url} + [[ -f fetch-from-genbank ]] || wget {params.fetch_from_genbank_url} + chmod 755 * + cd .. + ./bin/fetch-from-genbank {params.serotype_tax_id} > {output.genbank_ndjson} + """ + + +def _get_all_sources(wildcards): + return [f"data/{source}_{wildcards.serotype}.ndjson" for source in config["sources"]] + + +rule fetch_all_sequences: + input: + all_sources=_get_all_sources, + output: + sequences_ndjson="data/sequences_{serotype}.ndjson", + shell: + """ + cat {input.all_sources} > {output.sequences_ndjson} + """ diff --git a/ingest/workflow/snakemake_rules/slack_notifications.smk b/ingest/workflow/snakemake_rules/slack_notifications.smk new file mode 100644 index 0000000..638f84a --- /dev/null +++ b/ingest/workflow/snakemake_rules/slack_notifications.smk @@ -0,0 +1,76 @@ +""" +This part of the workflow handles various Slack notifications. +Designed to be used internally by the Nextstrain team with hard-coded paths +to files on AWS S3. + +All rules here require two environment variables: + * SLACK_TOKEN + * SLACK_CHANNELS +""" +import os +import sys + +slack_envvars_defined = "SLACK_CHANNELS" in os.environ and "SLACK_TOKEN" in os.environ +if not slack_envvars_defined: + print( + "ERROR: Slack notifications require two environment variables: 'SLACK_CHANNELS' and 'SLACK_TOKEN'.", + file=sys.stderr, + ) + sys.exit(1) + +S3_SRC = "s3://nextstrain-data/files/workflows/dengue" + + +rule notify_on_genbank_record_change: + input: + genbank_ndjson="data/genbank.ndjson", + output: + touch("data/notify/genbank-record-change.done"), + params: + s3_src=S3_SRC, + notify_on_record_change_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/notify-on-record-change", + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + if [[ ! -f bin/notify-on-record-change ]]; then + cd bin + wget {params.notify_on_record_change_url} + chmod 755 + cd .. + fi + + ./bin/notify-on-record-change {input.genbank_ndjson} {params.s3_src:q}/genbank.ndjson.xz Genbank + """ + + +rule notify_on_metadata_diff: + input: + metadata="data/metadata.tsv", + output: + touch("data/notify/metadata-diff.done"), + params: + s3_src=S3_SRC, + notify_on_diff_url = "https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/notify-on-diff", + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + if [[ ! -f bin/notify-on-diff ]]; then + cd bin + wget {params.notify_on_diff_url} + chmod 755 + cd .. + fi + ./bin/notify-on-diff {input.metadata} {params.s3_src:q}/metadata.tsv.gz + """ + + +onstart: + shell("./bin/notify-on-job-start") + + +onerror: + shell("./bin/notify-on-job-fail") diff --git a/ingest/workflow/snakemake_rules/transform.smk b/ingest/workflow/snakemake_rules/transform.smk new file mode 100644 index 0000000..78e399a --- /dev/null +++ b/ingest/workflow/snakemake_rules/transform.smk @@ -0,0 +1,156 @@ +""" +This part of the workflow handles transforming the data into standardized +formats and expects input file + + sequences_ndjson = "data/sequences.ndjson" + +This will produce output files as + + metadata = "data/metadata.tsv" + sequences = "data/sequences.fasta" + +Parameters are expected to be defined in `config.transform`. +""" + + +rule fetch_general_geolocation_rules: + output: + general_geolocation_rules="data/general-geolocation-rules.tsv", + params: + geolocation_rules_url=config["transform"]["geolocation_rules_url"], + shell: + """ + curl {params.geolocation_rules_url} > {output.general_geolocation_rules} + """ + + +rule concat_geolocation_rules: + input: + general_geolocation_rules="data/general-geolocation-rules.tsv", + local_geolocation_rules=config["transform"]["local_geolocation_rules"], + output: + all_geolocation_rules="data/all-geolocation-rules.tsv", + shell: + """ + cat {input.general_geolocation_rules} {input.local_geolocation_rules} >> {output.all_geolocation_rules} + """ + + +rule transform: + input: + sequences_ndjson="data/sequences_{serotype}.ndjson", + all_geolocation_rules="data/all-geolocation-rules.tsv", + annotations=config["transform"]["annotations"], + output: + metadata="data/raw_metadata_{serotype}.tsv", + sequences="data/sequences_{serotype}.fasta", + log: + "logs/transform_{serotype}.txt", + params: + field_map=config["transform"]["field_map"], + strain_regex=config["transform"]["strain_regex"], + strain_backup_fields=config["transform"]["strain_backup_fields"], + date_fields=config["transform"]["date_fields"], + expected_date_formats=config["transform"]["expected_date_formats"], + articles=config["transform"]["titlecase"]["articles"], + abbreviations=config["transform"]["titlecase"]["abbreviations"], + titlecase_fields=config["transform"]["titlecase"]["fields"], + authors_field=config["transform"]["authors_field"], + authors_default_value=config["transform"]["authors_default_value"], + abbr_authors_field=config["transform"]["abbr_authors_field"], + annotations_id=config["transform"]["annotations_id"], + metadata_columns=config["transform"]["metadata_columns"], + id_field=config["transform"]["id_field"], + sequence_field=config["transform"]["sequence_field"], + transform_field_names_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-field-names", + transform_string_fields_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-string-fields", + transform_strain_names_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-strain-names", + transform_date_fields_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-date-fields", + transform_genbank_location_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-genbank-location", + transform_authors_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-authors", + apply_geolocation_rules_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/apply-geolocation-rules", + merge_user_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/merge-user-metadata", + ndjson_to_tsv_and_fasta_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/ndjson-to-tsv-and-fasta", + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + cd bin + [[ -f transform-field-names ]] || wget {params.transform_field_names_url} + [[ -f transform-string-fields ]] || wget {params.transform_string_fields_url} + [[ -f transform-strain-names ]] || wget {params.transform_strain_names_url} + [[ -f transform-date-fields ]] || wget {params.transform_date_fields_url} + [[ -f transform-genbank-location ]] || wget {params.transform_genbank_location_url} + [[ -f transform-authors ]] || wget {params.transform_authors_url} + [[ -f apply-geolocation-rules ]] || wget {params.apply_geolocation_rules_url} + [[ -f merge-user-metadata ]] || wget {params.merge_user_metadata_url} + [[ -f ndjson-to-tsv-and-fasta ]] || wget {params.ndjson_to_tsv_and_fasta_url} + chmod 755 * + cd .. + + (cat {input.sequences_ndjson} \ + | ./bin/transform-field-names \ + --field-map {params.field_map} \ + | ./bin/transform-string-fields --normalize \ + | ./bin/transform-strain-names \ + --strain-regex {params.strain_regex} \ + --backup-fields {params.strain_backup_fields} \ + | ./bin/transform-date-fields \ + --date-fields {params.date_fields} \ + --expected-date-formats {params.expected_date_formats} \ + | ./bin/transform-genbank-location \ + | ./bin/transform-string-fields \ + --titlecase-fields {params.titlecase_fields} \ + --articles {params.articles} \ + --abbreviations {params.abbreviations} \ + | ./bin/transform-authors \ + --authors-field {params.authors_field} \ + --default-value {params.authors_default_value} \ + --abbr-authors-field {params.abbr_authors_field} \ + | ./bin/apply-geolocation-rules \ + --geolocation-rules {input.all_geolocation_rules} \ + | ./bin/merge-user-metadata \ + --annotations {input.annotations} \ + --id-field {params.annotations_id} \ + | ./bin/ndjson-to-tsv-and-fasta \ + --metadata-columns {params.metadata_columns} \ + --metadata {output.metadata} \ + --fasta {output.sequences} \ + --id-field {params.id_field} \ + --sequence-field {params.sequence_field} ) 2>> {log} + """ + +rule post_process_metadata: + input: + metadata="data/raw_metadata_{serotype}.tsv", + output: + metadata="data/metadata_{serotype}.tsv", + params: + post_process_metadata_url="https://raw.githubusercontent.com/nextstrain/zika/ingest/ingest/bin/post_process_metadata.py", + + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + cd bin + [[ -f post_process_metadata.py ]] || wget {params.post_process_metadata_url} + chmod 755 * + cd .. + + ./bin/post_process_metadata.py --metadata {input.metadata} --outfile {output.metadata} + """ + +rule compress: + input: + sequences="data/sequences_{serotype}.fasta", + metadata="data/metadata_{serotype}.tsv", + output: + sequences="data/sequences_{serotype}.fasta.zst", + metadata="data/metadata_{serotype}.tsv.zst", + shell: + """ + zstd -T0 -o {output.sequences} {input.sequences} + zstd -T0 -o {output.metadata} {input.metadata} + """ \ No newline at end of file diff --git a/ingest/workflow/snakemake_rules/trigger_rebuild.smk b/ingest/workflow/snakemake_rules/trigger_rebuild.smk new file mode 100644 index 0000000..6048dd8 --- /dev/null +++ b/ingest/workflow/snakemake_rules/trigger_rebuild.smk @@ -0,0 +1,30 @@ +""" +This part of the workflow handles triggering new Dengue builds after the +latest metadata TSV and sequence FASTA files have been uploaded to S3. + +Designed to be used internally by the Nextstrain team with hard-coded paths +to expected upload flag files. +""" + +rule trigger_build: + message: "Triggering monekypox builds via repository action type `rebuild`." + input: + metadata_upload = "data/upload/s3/metadata.tsv-to-metadata.tsv.gz.done", + fasta_upload = "data/upload/s3/sequences.fasta-to-sequences.fasta.xz.done" + output: + touch("data/trigger/rebuild.done") + params: + trigger_on_new_data_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/trigger-on-new-data" + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + if [[ ! -f bin/trigger-on-new-data ]]; then + cd bin + wget {params.trigger_on_new_data_url} + chmod 755 * + cd .. + fi + ./bin/trigger-on-new-data {input.metadata_upload} {input.fasta_upload} + """ diff --git a/ingest/workflow/snakemake_rules/upload.smk b/ingest/workflow/snakemake_rules/upload.smk new file mode 100644 index 0000000..95ad81e --- /dev/null +++ b/ingest/workflow/snakemake_rules/upload.smk @@ -0,0 +1,76 @@ +""" +This part of the workflow handles uploading files to a specified destination. + +Uses predefined wildcard `file_to_upload` determine input and predefined +wildcard `remote_file_name` as the remote file name in the specified destination. + +Produces output files as `data/upload/{upload_target_name}/{file_to_upload}-to-{remote_file_name}.done`. + +Currently only supports uploads to AWS S3, but additional upload rules can +be easily added as long as they follow the output pattern described above. +""" +import os + +slack_envvars_defined = "SLACK_CHANNELS" in os.environ and "SLACK_TOKEN" in os.environ +send_notifications = ( + config.get("send_slack_notifications", False) and slack_envvars_defined +) + + +def _get_upload_inputs(wildcards): + """ + If the file_to_upload has Slack notifications that depend on diffs with S3 files, + then we want the upload rule to run after the notification rule. + + This function is mostly to keep track of which flag files to expect for + the rules in `slack_notifications.smk`, so it only includes flag files if + `send_notifications` is True. + """ + file_to_upload = wildcards.file_to_upload + + inputs = { + "file_to_upload": f"data/{file_to_upload}", + } + + if send_notifications: + flag_file = [] + + if file_to_upload == "genbank.ndjson": + flag_file = "data/notify/genbank-record-change.done" + elif file_to_upload == "metadata.tsv": + flag_file = "data/notify/metadata-diff.done" + + inputs["notify_flag_file"] = flag_file + + return inputs + + +rule upload_to_s3: + input: + unpack(_get_upload_inputs), + output: + "data/upload/s3/{file_to_upload}-to-{remote_file_name}.done", + params: + quiet="" if send_notifications else "--quiet", + s3_dst=config["upload"].get("s3", {}).get("dst", ""), + cloudfront_domain=config["upload"].get("s3", {}).get("cloudfront_domain", ""), + upload_to_s3_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/upload-to-s3", + sha256sum_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/sha256sum", + cloudfront_invalidate_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/cloudfront-invalidate" + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + cd bin + [[ -f upload-to-s3 ]] || wget {params.upload_to_s3_url} + [[ -f sha256sum ]] || wget {params.sha256sum_url} + [[ -f cloudfront-invalidate ]] || wget {params.cloudfront_invalidate_url} + chmod 755 * + cd .. + ./bin/upload-to-s3 \ + {params.quiet} \ + {input.file_to_upload:q} \ + {params.s3_dst:q}/{wildcards.remote_file_name:q} \ + {params.cloudfront_domain} 2>&1 | tee {output} + """ From 02336993c3e75e4d182c87f561668191d56605ab Mon Sep 17 00:00:00 2001 From: j23414 Date: Mon, 28 Nov 2022 11:49:00 -0800 Subject: [PATCH 02/12] adapt to ebola --- ingest/README.md | 6 +++--- ingest/bin/genbank-url | 4 ++-- ingest/config/optional.yaml | 2 +- ingest/workflow/snakemake_rules/fetch_sequences.smk | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ingest/README.md b/ingest/README.md index 2db3aa2..7384113 100644 --- a/ingest/README.md +++ b/ingest/README.md @@ -1,11 +1,11 @@ -# nextstrain.org/zika/ingest +# nextstrain.org/ebola/ingest -This is the ingest pipeline for Zika virus sequences. +This is the ingest pipeline for Ebola virus sequences. ## Usage > NOTE: All command examples assume you are within the `ingest` directory. -> If running commands from the outer `zika` directory, please replace the `.` with `ingest` +> If running commands from the outer `ebola` directory, please replace the `.` with `ingest` Fetch sequences with diff --git a/ingest/bin/genbank-url b/ingest/bin/genbank-url index 881e8b6..65ad8f6 100755 --- a/ingest/bin/genbank-url +++ b/ingest/bin/genbank-url @@ -45,8 +45,8 @@ def build_query_url(ncbi_id: str): '{!tag=SeqType_s}SeqType_s:("Nucleotide")', # Nucleotide sequences (as opposed to protein) f'VirusLineageId_ss:({ncbi_id})', # NCBI Taxon id for virus 'Division_s:("VRL")', # Restrict to viral sequences, avoid PAT - '{!tag=SLen_i}SLen_i:([5000 TO 15000])', # Longer than 5K bp, shorter than 15k bp - '{!tag=CollectionDate_s}CollectionDate_s:([2013-01-01T00:00:00.00Z TO ' + today + 'T00:00:00.00Z ])', # after 2013 + '{!tag=SLen_i}SLen_i:([5000 TO 20000])', # Longer than 5K bp, shorter than 20k bp + #'{!tag=CollectionDate_s}CollectionDate_s:([2013-01-01T00:00:00.00Z TO ' + today + 'T00:00:00.00Z ])', # after 2013 #'{!tag=UpdateDate_dt}UpdateDate_dt:([2022-01-01T00:00:00.00Z TO 2022-12-01T00:00:00.00Z ])', # recent ], # diff --git a/ingest/config/optional.yaml b/ingest/config/optional.yaml index dbc790b..fe9bf40 100644 --- a/ingest/config/optional.yaml +++ b/ingest/config/optional.yaml @@ -4,7 +4,7 @@ upload: # Upload params for AWS S3 s3: # AWS S3 Bucket with prefix - dst: 's3://nextstrain-data/files/workflows/zika/test' + dst: 's3://nextstrain-data/files/workflows/ebola/test' # Files to upload to S3 that are in the `data` directory files_to_upload: [ 'metadata_all.tsv', diff --git a/ingest/workflow/snakemake_rules/fetch_sequences.smk b/ingest/workflow/snakemake_rules/fetch_sequences.smk index 158869b..0e2d065 100644 --- a/ingest/workflow/snakemake_rules/fetch_sequences.smk +++ b/ingest/workflow/snakemake_rules/fetch_sequences.smk @@ -15,7 +15,7 @@ Produces final output as def download_serotype(w): serotype = { - 'all': '64320', + 'all': '186536', # Returns 3530 records, check if we need a more specific Taxon ID } return serotype[w.serotype] From 5600aa7d56ff8b8e3e5d9bffc9d8b92dff4f36cf Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 2 Dec 2022 13:42:01 -0800 Subject: [PATCH 03/12] update ebola build to pull new ingest data --- Snakefile | 82 +++++++++++++++++++++++++----------- config/config_ebola.yaml | 2 + example_data/metadata.tsv | 31 ++++++++++++++ example_data/sequences.fasta | 60 ++++++++++++++++++++++++++ 4 files changed, 151 insertions(+), 24 deletions(-) create mode 100644 config/config_ebola.yaml create mode 100644 example_data/metadata.tsv create mode 100644 example_data/sequences.fasta diff --git a/Snakefile b/Snakefile index 25fa1d0..98b8235 100644 --- a/Snakefile +++ b/Snakefile @@ -1,3 +1,6 @@ +if not config: + configfile: "config/config_ebola.yaml" + rule all: input: auspice_json = "auspice/ebola.json" @@ -16,40 +19,40 @@ rule files: files = rules.files.params rule download: - """Downloading sequences from fauna""" + """Downloading sequences and metadata from data.nextstrain.org""" output: - sequences = "data/ebola.fasta" + sequences = "data/sequences.fasta", + metadata = "data/metadata.tsv", params: - fasta_fields = "strain virus accession collection_date region country division location source locus authors url title journal puburl" + sequences_url = "https://data.nextstrain.org/files/workflows/ebola/test/sequences_all.fasta.zst", + metadata_url = "https://data.nextstrain.org/files/workflows/ebola/test/metadata_all.tsv.zst", shell: """ - python3 ../fauna/vdb/download.py \ - --database vdb \ - --virus ebola \ - --fasta_fields {params.fasta_fields} \ - --resolve_method choose_genbank \ - --path $(dirname {output.sequences}) \ - --fstem $(basename {output.sequences} .fasta) + curl -fsSL {params.sequences_url:q} --output {output.sequences} + curl -fsSL {params.metadata_url:q} --output {output.metadata} """ -rule parse: - """Parsing fasta into sequences and metadata""" +rule wrangle_metadata: input: - sequences = files.input_fasta + metadata=rules.download.output.metadata, output: - sequences = "results/sequences.fasta", - metadata = "results/metadata.tsv" + metadata="results/wrangled_metadata.tsv", params: - fasta_fields = "strain virus accession date region country division city db segment authors url title journal paper_url", - prettify_fields = "region country division city" + strain_id=lambda w: config.get("strain_id_field", "strain"), + wrangle_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/scripts/wrangle_metadata.py", shell: """ - augur parse \ - --sequences {input.sequences} \ - --output-sequences {output.sequences} \ - --output-metadata {output.metadata} \ - --fields {params.fasta_fields} \ - --prettify-fields {params.prettify_fields} + if [[ ! -d bin ]]; then + mkdir bin + fi + cd bin + [[ -f wrangle_metadata.py ]] || wget {params.wrangle_metadata_url} + chmod 755 * + cd .. + + python3 ./bin/wrangle_metadata.py --metadata {input.metadata} \ + --strain-id {params.strain_id} \ + --output {output.metadata} """ rule filter: @@ -218,7 +221,8 @@ rule export: auspice_config = files.auspice_config, description = files.description output: - auspice_json = rules.all.input.auspice_json + auspice_json = "results/raw_ebola.json", + root_sequence="results/raw_ebola_root-sequence.json", shell: """ augur export v2 \ @@ -233,6 +237,36 @@ rule export: --output {output.auspice_json} """ +rule final_strain_name: + input: + auspice_json=rules.export.output.auspice_json, + metadata=rules.wrangle_metadata.output.metadata, + root_sequence=rules.export.output.root_sequence, + output: + auspice_json=rules.all.input.auspice_json, + root_sequence="auspice/ebola_root-sequence.json", + params: + display_strain_field=lambda w: config.get("display_strain_field", "strain"), + set_final_strain_name_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/scripts/set_final_strain_name.py", + shell: + """ + if [[ ! -d bin ]]; then + mkdir bin + fi + cd bin + [[ -f set_final_strain_name.py ]] || wget {params.set_final_strain_name_url} + chmod 755 * + cd .. + + python3 bin/set_final_strain_name.py \ + --metadata {input.metadata} \ + --input-auspice-json {input.auspice_json} \ + --display-strain-name {params.display_strain_field} \ + --output {output.auspice_json} + + cp {input.root_sequence} {output.root_sequence} + """ + rule clean: """Removing directories: {params}""" params: diff --git a/config/config_ebola.yaml b/config/config_ebola.yaml new file mode 100644 index 0000000..aa8d020 --- /dev/null +++ b/config/config_ebola.yaml @@ -0,0 +1,2 @@ +strain_id_field: "accession" +display_strain_field: "strain_original" \ No newline at end of file diff --git a/example_data/metadata.tsv b/example_data/metadata.tsv new file mode 100644 index 0000000..316f8a5 --- /dev/null +++ b/example_data/metadata.tsv @@ -0,0 +1,31 @@ +strain accession date region country division city authors url title +G5016.1 KR105293 2014-08-16 subsaharan_africa sierra_leone kenema kenema Goba et al https://www.ncbi.nlm.nih.gov/nuccore/KR105293 "Ebola virus epidemiology, transmission, and viral evolution from four months of sequencing in Sierra Leone" +EM_080193 KR817239 2014-06-29 subsaharan_africa liberia liberia liberia Carroll et al https://www.ncbi.nlm.nih.gov/nuccore/KR817239 Temporal and spatial analysis of the 2014-2015 Ebola virus outbreak in West Africa +EM_074351 KR817110 2014-07-22 subsaharan_africa liberia lofa lofa Carroll et al https://www.ncbi.nlm.nih.gov/nuccore/KR817110 Temporal and spatial analysis of the 2014-2015 Ebola virus outbreak in West Africa +LIBR10253 KT725282 2014-09-16 subsaharan_africa liberia margibi margibi Ladner et al https://www.ncbi.nlm.nih.gov/nuccore/KT725282 "Evolution and spread of Ebola virus in Liberia, 2014-2015" +G3848 KM233110 2014-06-18 subsaharan_africa sierra_leone kailahun kailahun Gire et al https://www.ncbi.nlm.nih.gov/nuccore/KM233110 Genomic surveillance elucidates Ebola virus origin and transmission during the 2014 outbreak +EM_000027 KR817068 2014-09-01 subsaharan_africa guinea guinea guinea Carroll et al https://www.ncbi.nlm.nih.gov/nuccore/KR817068 Temporal and spatial analysis of the 2014-2015 Ebola virus outbreak in West Africa +LIBR10047 KT725345 2014-10-01 subsaharan_africa liberia margibi margibi Ladner et al https://www.ncbi.nlm.nih.gov/nuccore/KT725345 "Evolution and spread of Ebola virus in Liberia, 2014-2015" +G4350.1 KR105242 2014-07-14 subsaharan_africa sierra_leone kenema kenema Goba et al https://www.ncbi.nlm.nih.gov/nuccore/KR105242 "Ebola virus epidemiology, transmission, and viral evolution from four months of sequencing in Sierra Leone" +J0165 KP759703 2014-11-08 subsaharan_africa sierra_leone western_urban western_urban Tong et al https://www.ncbi.nlm.nih.gov/nuccore/KP759703 Genetic diversity and evolutionary dynamics of Ebola virus in Sierra Leone +G3926.2 KR105208 2014-06-22 subsaharan_africa sierra_leone kailahun kailahun Goba et al https://www.ncbi.nlm.nih.gov/nuccore/KR105208 "Ebola virus epidemiology, transmission, and viral evolution from four months of sequencing in Sierra Leone" +EM_080223 KR817241 2014-07-04 subsaharan_africa liberia liberia liberia Carroll et al https://www.ncbi.nlm.nih.gov/nuccore/KR817241 Temporal and spatial analysis of the 2014-2015 Ebola virus outbreak in West Africa +G4345.1 KR105239 2014-07-18 subsaharan_africa sierra_leone kenema kenema Goba et al https://www.ncbi.nlm.nih.gov/nuccore/KR105239 "Ebola virus epidemiology, transmission, and viral evolution from four months of sequencing in Sierra Leone" +LIBR10218 KT725284 2014-09-29 subsaharan_africa liberia liberia liberia Ladner et al https://www.ncbi.nlm.nih.gov/nuccore/KT725284 "Evolution and spread of Ebola virus in Liberia, 2014-2015" +G3807 KM233084 2014-06-15 subsaharan_africa sierra_leone kailahun kailahun Gire et al https://www.ncbi.nlm.nih.gov/nuccore/KM233084 Genomic surveillance elucidates Ebola virus origin and transmission during the 2014 outbreak +LIBR10224 KT725302 2014-09-26 subsaharan_africa liberia montserrado montserrado Ladner et al https://www.ncbi.nlm.nih.gov/nuccore/KT725302 "Evolution and spread of Ebola virus in Liberia, 2014-2015" +13031_EMLH KU296665 2015-05-18 subsaharan_africa sierra_leone western_urban western_urban Arias et al https://www.ncbi.nlm.nih.gov/nuccore/KU296665 Rapid outbreak sequencing of Ebola virus in Sierra Leone identifies transmission chains linked to sporadic cases +G5996.1 KR105337 2014-09-25 subsaharan_africa sierra_leone sierra_leone sierra_leone Goba et al https://www.ncbi.nlm.nih.gov/nuccore/KR105337 "Ebola virus epidemiology, transmission, and viral evolution from four months of sequencing in Sierra Leone" +DML24708 KT357845 2015-01-28 subsaharan_africa sierra_leone kono kono Smits et al https://www.ncbi.nlm.nih.gov/nuccore/KT357845 "Hypermutated Ebola virus circulating in Magazine Wharf area, Freetown, Sierra Leone" +15686_EMLK KU296555 2015-06-30 subsaharan_africa sierra_leone kambia kambia Arias et al https://www.ncbi.nlm.nih.gov/nuccore/KU296555 Rapid outbreak sequencing of Ebola virus in Sierra Leone identifies transmission chains linked to sporadic cases +EM_COY_2015_016617 EM_COY_2015_016617 2015-05-16 subsaharan_africa guinea dubreka dubreka Quick et al https://github.com/nickloman/ebov/ ? +Makona-UK3 KR025228 2015-03-12 subsaharan_africa sierra_leone western_area western_area Lewandowski et al https://www.ncbi.nlm.nih.gov/nuccore/KR025228 Direct Submission +EM_000968 KR817085 2014-10-01 subsaharan_africa guinea macenta macenta Carroll et al https://www.ncbi.nlm.nih.gov/nuccore/KR817085 Temporal and spatial analysis of the 2014-2015 Ebola virus outbreak in West Africa +490_EMLH KU296746 2015-01-30 subsaharan_africa sierra_leone sierra_leone sierra_leone Arias et al https://www.ncbi.nlm.nih.gov/nuccore/KU296746 Rapid outbreak sequencing of Ebola virus in Sierra Leone identifies transmission chains linked to sporadic cases +PL4696 KU296513 2015-03-13 subsaharan_africa sierra_leone port_loko port_loko Arias et al https://www.ncbi.nlm.nih.gov/nuccore/KU296513 Rapid outbreak sequencing of Ebola virus in Sierra Leone identifies transmission chains linked to sporadic cases +MK2788 KU296573 2015-03-07 subsaharan_africa sierra_leone bombali bombali Arias et al https://www.ncbi.nlm.nih.gov/nuccore/KU296573 Rapid outbreak sequencing of Ebola virus in Sierra Leone identifies transmission chains linked to sporadic cases +LIBR10110 KT725387 2014-08-20 subsaharan_africa liberia liberia liberia Ladner et al https://www.ncbi.nlm.nih.gov/nuccore/KT725387 "Evolution and spread of Ebola virus in Liberia, 2014-2015" +J0102 KP759657 2014-10-27 subsaharan_africa sierra_leone port_loko port_loko Tong et al https://www.ncbi.nlm.nih.gov/nuccore/KP759657 Genetic diversity and evolutionary dynamics of Ebola virus in Sierra Leone +EM_COY_2015_017574 EM_COY_2015_017574 2015-06-10 subsaharan_africa guinea boke boke Quick et al https://github.com/nickloman/ebov/ ? +18636_EMLH KU296460 2015-07-08 subsaharan_africa sierra_leone sierra_leone sierra_leone Arias et al https://www.ncbi.nlm.nih.gov/nuccore/KU296460 Rapid outbreak sequencing of Ebola virus in Sierra Leone identifies transmission chains linked to sporadic cases +V768 KR534588 2014-08-27 subsaharan_africa guinea conakry conakry Simon-Loriere et al https://www.ncbi.nlm.nih.gov/nuccore/KR534588 Distinct lineages of Ebola virus in Guinea during the 2014 West African epidemic \ No newline at end of file diff --git a/example_data/sequences.fasta b/example_data/sequences.fasta new file mode 100644 index 0000000..324a8eb --- /dev/null +++ b/example_data/sequences.fasta @@ -0,0 +1,60 @@ +>KR105293 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnctatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcgaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaaggtggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattacttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcgattttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KR817239 +nnnnnnncacacaaaaagaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagcgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtccaaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcacaacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaagataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttatttttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatggtacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactcttcataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KR817110 +nnnnggacacacaaaaagaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgaccaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctcccttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KT725282 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntaaantgaaantgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccnccatcncccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactnanannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgnctcanctacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcnataangnnttcnctcnaggannttaagatcgttccnattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggcgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaactngacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaattcctcaaataagagattccaagncaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaaccctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaaggtaccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttataaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ntttttatanttgncnttgctttnnnnnnnnnn-nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatgatnaaattnaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgntaatgatnattannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KM233110 +nnnnngacacacaaaaagaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KR817068 +nnnnnnncacacaaaaagaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggaccctcaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaggattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaaaccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttgcaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgnnnnnnnn +>KT725345 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcnn-nnnntaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgagtaccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgacctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacgttggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagnttatgatatggcaannanaatctcctcattgaacagngnttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaagcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaatttggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccannnnnnnnnnnnnnnnnnnnnntgnntttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnncatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacanacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccgtttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaacgg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtacgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgctgcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggnnnnnnnnnnnnnnnnncatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgcttnat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaattcgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgctcaaatgccaagcaacctggcgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctnnannnnnnnnnctgggcncnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KR105242 +nnnnnnnnnnnnnnnnnnaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcagaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctcacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagggggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KP759703 +nnncggacacacaaaaagaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgaggcagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccctaaaagcagagaacaccaacacgagcaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagccaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactacgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaatattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatatcagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KR105208 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnctcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctcngaggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnctccgacnnnccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactgtcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KR817241 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtggtttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttttgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagnnnnaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctggcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgtgagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatctcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggnnnngagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcacaagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgaccacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggacctgggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccatcatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctttacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctagagaaaggggttgtcttaagcgacctctgtatcttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgnnnatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcagcctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgaccgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaannatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KR105239 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattgggactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctcacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KT725284 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgagtaccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgacctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacgttggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaagcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaatttggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccgtttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaacgg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtacgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgctgcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacannnnnnnnnnnttgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaattcgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgctcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaanacngatcttnnnnnnnnnn-nnnnnnnnnnnnnncatngcnntaannnnnnnn-tttnaanatngnnatannnttaatctttgtgtnaaataagagattnggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgntaatgataattaaggcattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KM233084 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KT725302 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacatcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaagaggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatcttgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggttccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagagctttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggaacaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcatttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatcnnngtgtnnnannagagattaggtgtnataactttaacatttttgtctagtaagctactattnnattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KU296665 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggtcaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatgataaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaacctaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgacaacatc-?tt??aataatccgtctactagaagagatacttc?aattgatcaata?actaaaggtgctttacacca?tgtctc???tctctcc?aaatgtagagc?taacaaaagactca?aatatacctgtttttaaaagattgattgaagaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagtcgttcacaatctaagtacagacattgctcttttaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgac-ttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacact-cccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattttgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaa-ttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaactttttagttagtcaaactattcaagggtggaaagtttgttgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaactcgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcccagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaaaaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccctaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcacattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatctcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KR105337 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgtcttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctactgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaannnnncacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgcttcataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaaccctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgnaaccnnnnnnnnnnnaagcannnnnnnnnnnnnnnnnnnnnnnnnnnacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcgtattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgattttggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgctagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaaggtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KT357845 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtgatagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnngaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgnnnnnnnnnnnnnnnnnnnnnnnnnngaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggnnnnnnnnnnnnnnnnnnnnnnnnnnntgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatagactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcnnnnncacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgcggatcagtagaacaacaattaaatataactgcnnnnnnnnnnnnnnnnnnagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatgatattcgctattgctatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttactattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggnnnnnnnnnnnnnnnnnnnnncggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatggtttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttctaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagctagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaataaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcgagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtctttacattatacactatatttggcctctctccctgcgtgataatc-aaaannttcacaatacagcnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattcag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcaggctagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KU296555 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagctcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcagcgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaacttatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatagactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgac-ttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacact-cccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcggg-cagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagggaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgcggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgctatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttactattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccag-tgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatgttaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgataatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttctaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagctagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcgagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtctttacattatacactatatttggcctctctccctgcgtgataatc---aaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattcag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>EM_COY_2015_016617 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaactatgaggaagattaataattttcct-ctcattgaaatttatatcag-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgggaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaannnnnnnnnnnnnnnnnnnntcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacggnnnnnnnnnnnnnnnnnnaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgagcttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgaggaagaacaggacagggacggaacttctaaccgcacacccactgtcnccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaagaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacaatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcactnnnnnnnnnnnnnnnnnnnnnnnnnccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatnnnnnnnnnnnnnnnnnnnnnnnatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgttcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcagnnnnnnnnnnnnnnnnnnngattggcctggatnnnnnnnnnnnnnnnnnnagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcaaatctgcaaaccggtagaatttggttgtaacctaacacacacaaagcattggtaaanaagtcaatagaaatttaaacagtgagtgcagacaactcttggatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagnnnnnnnnnnnnnnnnnnnnnnnnnnnacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatatnnnnnnnnnnnnnnnnnnnnnnaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacannnnnnnnnnnnnnnnnnnnnnaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagannnnnnnnnnnnnnnnnnntctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaannnnnnnnnnnnnnnnnnnnnnnnnatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggctttaagnnnnnnnnnnnnnnnnnnggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcgnnnnnnnnnnnnnnnnnnnnnnaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccggttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatactnnnnnnnnnnnnnnnnnnnnttagcctctaagatcatcaacaataatacannnnnnnnnnnnnnnnnnagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtctgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacggccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacannnnnnnnnnnnnnnnnnnctannnnnnnnnnnnnnnnnnnaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcgaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagaggnnnnnnnnnnnnnnnnnnnactattgattcagaaataccaagttaagaccttattcttcnnnnnnnnnnnnnnnnnnnnnnntatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagnnnnnnnnnnnnnnnnnnnnnnnnntatcaannnnnnnnnnnnnnnnnnnnnnaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccggatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn-nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KR025228 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntttgagtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaamcaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagtcagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ktttgaggrggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatgcttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagtcgttcataatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactaraaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagtgcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtgagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgcatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacagggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaactcgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcarttccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgctaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaaggggcacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggwcrcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn +>KR817085 +nnnnnnncacacaaaaagaaagaagaatttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggacacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgaccaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctcccttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcggataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatccacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtnnnnnnn +>KU296746 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnntttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgttttccagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaacagcagaggcttcaactgctgaactatagggtatgctacatcaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcgatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgac-ttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacagtctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacact-cccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagctgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagt-gcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgaaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtgttgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttattgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgacctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KU296513 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagtcagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgtcagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgtttttccattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatgcttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagtcgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagtgcagacaacgacagcacagcctccgacact-cccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgcatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacagggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtatgccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaactcgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcgggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgctaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaaggggcacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KU296573 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgctactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatgcttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagtcgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgac-ttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaaca-gtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagtgcagacaacgacagcacagcctccgacact-cccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtgagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcggg-cagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacct-acacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgnnnnnnnnnnnnngcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgcatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacagggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaactcgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgctaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaaggggcacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KT725387 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatcttgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggaacaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KP759657 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttaaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgataaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgaaaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccaaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaataaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgaggcagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaagccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattaattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaatattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatatcagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>EM_COY_2015_017574 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaactatgaggaagattaataattctcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagcgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaannnnnnnnnnnnnnnnnnnntcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattntttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacggnnnnnnnnnnnnnnnnnnaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgatcccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagccaatgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcnccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcactnnnnnnnnnnnnnnnnnnnnnnnnnccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagtttcaagatagtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatnnnnnnnnnnnnnnnnnnnnnnnatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttctaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacatctgaggacagccagtgtgacttggattggagatgtggaggaanaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaanaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtcctnttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgcgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaagactgctacaatcttgaaatcaaanaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaannaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaanaacatcagtggtcaaagtccggcgcgaacttcttccgactcagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctagacttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcagnnnnnnnnnnnnnnnnnnngattggcctggatnnnnnnnnnnnnnnnnnnagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcggaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagttatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttaatcttcatccttgattctacaatcatgacagttgtctttaatgaanaaggaanaaagccttntta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaannaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgccnccgagctgccagacagcattcaagnnnnnnnnnnnnnnnnnnnnnnnnnnnacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaannaaggattnntgtgtgacagtagtttttgcaannaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtccaaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatatnnnnnnnnnnnnnnnnnnnnnnaatcacaatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatacgccacaaaggtgtctctgagctaaagtggtctgtacacatctcatactttgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactct-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttgtcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatntatattactaactccatactcgtaactaacattagataagtaggttaagaanaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacannnnnnnnnnnnnnnnnnnnnnaatattatctcaanaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaanaaatcttatcttcaattcagggcaatgaattnttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttntttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaanaatagcagnnnnnnnnnnnnnnnnnnnntctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaannnnnnnnnnnnnnnnnnnnnnnnnatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagnnnnnnnnnnnnnnnnnnggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcagacgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcgnnnnnnnnnnnnnnnnnnnnnnaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatactnnnnnnnnnnnnnnnnnnnnttagcctctaagatcatcaacaataatacannnnnnnnnnnnnnnnnnagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatatcttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtatttaacatacacatctacatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnctannnnnnnnnnnnnnnnnnnaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaggggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagaggnnnnnnnnnnnnnnnnnnnactattgattcagaaataccaagttaagaccttatttttcnnnnnnnnnnnnnnnnnnnnnnntatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagnnnnnnnnnnnnnnnnnnnnnnnnntatcaannnnnnnnnnnnnnnnnnnnnnaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcccatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatattcggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn-nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KU296460 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctagggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggtcaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaattttttatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaacctaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccaatgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgacaacatc-?tt??aataatccgtctactagaagggatacttc?aattgatcaata?actaaaggtgctttacacca?tgtctc???tctctcc?aaatgtagagc?taacaaaagactca?aatatacctgtttttaaaagattgattgatgaaagatctaatgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatcttnnnnnttgcacatactctttgtccttatcctcaaa-tgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagtcgttcacaatctaagtacagacattgctcttttaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatattgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacact-cccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcccgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattttgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaa-ttagtgcataaatctgggctaactccaccaggtcaactcccattggctgaaaagaagcccacctacaacgaacattactttgagcaccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactccagacaccaagcaagacctgagaaaaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaactttttagttagtcaaactattcaagggtggaaagtttgttgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaactcgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaaggtccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcccagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaaaaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgccccagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggcaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccctaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggagcaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagaaaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcacattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatctcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttgtaattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +>KR534588 +nnnnnnnnnnnnnnnnnnnnnnnnnnnnttttaggatcttttgtgtgcgaataactatgaggaagattaataattttcct-ctcattgaaatttatatcgg-aatttaaattgaaattgttactgtaatcatacctggtttg-tttcagagccatatcaccaagatagagaacaacctaggtctccggagggggcaagggcatcagtgtgctcagttgaaaatcccttgtcaacatctaggccttatcacatcacaagttccgccttaaactctgcagggtgatccaacaaccttaatagcaacattattgttaaaggacagcattagttcacagtcaaacaagcaagattgagaattaactttgattttgaacctgaacacccagaggactggagactcaacaaccctaaagcctggggtaaaacattagaaatagtttaaagacaaattgctcggaatcacaaaattccgagtatggattctcgtcctcagaaagtctggatgacgccgagtctcactgaatctgacatggattaccacaagatcttgacagcaggtctgtccgttcaacaggggattgttcggcaaagagtcatcccagtgtatcaagtaaacaatcttgaggaaatttgccaacttatcatacaggcctttgaagctggtgttgattttcaagagagtgcggacagtttccttctcatgctttgtcttcatcatgcgtaccaaggagattacaaacttttcttggaaagtggcgcagtcaagtatttggaagggcacgggttccgttttgaagtcaagaagtgtgatggagtgaagcgccttgaggaattgctgccagcagtatctagtgggagaaacattaagagaacacttgctgccatgccggaagaggagacgactgaagctaatgccggtcagttcctctcctttgcaagtctattccttccgaaattggtagtaggagaaaaggcttgccttgagaaggttcaaaggcaaattcaagtacatgcagagcaaggactgatacaatatccaacagcttggcaatcagtaggacacatgatggtgattttccgtttgatgcgaacaaattttttgatcaaatttcttctaatacaccaagggatgcacatggttgccggacatgatgccaacgatgctgtgatttcaaattcagtggctcaagctcgtttttcaggtctattgattgtcaaaacagtacttgatcatatcctacaaaagacagaacgaggagttcgtctccatcctcttgcaaggaccgccaaggtaaaaaatgaggtgaactccttcaaggctgcactcagctccctggccaagcatggagagtatgctcctttcgcccgacttttgaacctttctggagtaaataatcttgagcatggtcttttccctcaac-tgtcggcaattgcactcggagtcgccacagcccacgggagcaccctcgcaggagtaaatgttggagaacagtatcaacagctcagagaggcagccactgaggctgagaagcaactccaacaatatgcggagtctcgtgaacttgaccatcttggacttgatgatcaggaaaagaaaattcttatgaacttccatcagaaaaagaacgaaatcagcttccagcaaacaaacgcgatggtaactctaagaaaagagcgcctggccaagctgacagaagctatcactgctgcatcactgcccaaaacaagtggacattacgatgatgatgacgacattccctttccaggacccatcaatgatgacgacaatcctggccatcaagatgatgatccgactgactcacaggatacgaccattcccgatgtggtagttgaccccgatgatggaggctacggcgaataccaaagttactcggaaaacggcatgagtgcaccagatgacttggtcctattcgatctagacgaggacgacgaggacaccaagccagtgcctaacagatcgaccaagggtggacaacagaaaaacagtcaaaagggccagcatacagagggcagacagacacaatccacgccaactcaaaacgtcacaggccctcgcagaacaatccaccatgccagtgctccactcacggacaatgacagaagaaacgaaccctccggctcaaccagccctcgcatgctgaccccaatcaacgaagaggcagacccactggacgatgccgacgacgagacgtctagccttccgcccttagagtcagatgatgaagaacaggacagggacggaacttctaaccgcacacccactgtcgccccaccggctcccgtatacagagatcactccgaaaagaaagaactcccgcaagatgaacaacaagatcaggaccacattcaagaggccaggaaccaagacagtgacaacacccagccagaacattcttttgaggagatgtatcgccacattctaagatcacaggggccatttgatgccgttttgtattatcatatgatgaaggatgagcctgtagttttcagtaccagtgatggtaaagagtacacgtatccggactcccttgaagaggaatatccaccatggctcactgaaaaagaggccatgaatgatgagaatagatttgttacactggatggtcaacaattttattggccagtaatgaatcacaggaataaattcatggcaatcctgcaacatcatcagtgaatgagcatgtaataatgggatgatttaatcgacaaatagctaacattaaatagtcaaggaacgcaaacaggaagaatttttgatgtctaaggtgtgaattattatcacaataaaagtgattcttagttttgaatttaaagctagcttattattactagccgtttttcaaagttcaatttgagtcttaatgcaaataagcgttaagccacagttatagccataatggtaactcaatatcttagccagcgatttatctaaattaaattacattatgcttttataacttacctactagcctgcccaacatttacacgatcgttttataattaagaaaaaactaatgatgaagattaaaaccttcatcatccttacgtcaattgaattctctagcactagaagcttattgtcttcaatg-taaaagaaaagctggcctaacaagatgacaactagaacaaagggcaggggccatactgtggccacgactcaaaacgacagaatgccaggccctgagctttcgggctggatctctgagcagctaatgaccggaaggattcctgtaaacgacatcttctgtgatattgagaacaatccaggattatgctacgcatcccaaatgcaacaaacgaagccaaacccgaagatgcgcaacagtcaaacccaaacggacccaatttgcaatcatag-ttttgaggaggtagtacaaacattggcttcattggctactgttgtgcaacaacaaaccatcgcatcagaatcattagaacaacgcattacgagtcttgagaatggtctaaagccagtttatgatatggcaaaaacaatctcctcattgaacagggtttgtgctgagatggttgcaaaatatgatcttctggtgatgacaaccggtcgggcaacagcaaccgctgcggcaactgaggcttattgggctgaacatggtcaaccaccacctggaccatcactttatgaagaaagtgcgattcggggtaagattgaatctagagatgagactgtccctcaaagtgttagggaggcattcaacaatctagacagtaccacttcactaactgaggaaaattttgggaaacctgacatttcggcaaaggatttgagaaacattatgtatgatcacttgcctggttttggaactgctttccaccaattagtacaagtgatttgtaaattgggaaaagatagcaattcattggacattattcatgctgagttccaggccagcctggctgaaggagactcccctcaatgtgccctaattcaaattacaaaaagagttccaatcttccaagatgctgctccacctgtcatccacatccgctctcgaggtgacattccccgagcttgccagaagagcttgcgtccagtcccaccatcacccaagattgatcgaggttgggtatgtgtttttcagcttcaagatggtaaaacacttggactcaaaatttgagccaatctcttttccctccgaaagaggcaactaatagcagaggcttcaactgctgaactatagggtatgttacattaatgatacacttgtgagtatcagccctagataatataagtcaattaaacaaccaagataaaattgttcatatcccgctagcagctttaaagataaatgtaataggagctatacctctgacagtattataattaattgttattaagtaacccaaaccaaaaatgatgaagattaagaaaaacctacctcgactgagagagtgttttttcattaaccttcatcttgtaaacgttgagcaaaattgttaaaaatatgaggcgggttatattgcctactgctcctcctgaatatatggaggccatataccctgccaggtcaaattcaacaattgctaggggtggcaacagcaatacaggcttcctgacaccggagtcagtcaatggagacactccatcgaatccactcaggccaattgctgatgacaccatcgaccatgccagccacacaccaggcagtgtgtcatcagcattcatcctcgaagctatggtgaatgtcatatcgggccccaaagtgctaatgaagcaaattccaatttggcttcctctaggtgtcgctgatcaaaagacctacagctttgactcaactacggccgccatcatgcttgcttcatatactatcacccatttcggcaaggcaaccaatccgcttgtcagagtcaatcggctgggtcctggaatcccggatcaccccctcaggctcctgcgaattggaaaccaggctttcctccaggagttcgttcttccaccagtccaactaccccagtatttcacctttgatttgacagcactcaaactgatcactcaaccactgcctgctgcaacatggaccgatgacactccaactggatcaaatggagcgttgcgtccaggaatttcatttcatccaaaacttcgccccattcttttacccaacaaaagtgggaagaaggggaacagtgccgatctaacatctccggagaaaatccaagcaataatgacttcactccaggactttaagatcgttccaattgatccaaccaaaaatatcatgggtatcgaagtgccagaaactctggtccacaagctgaccggtaagaaggtgacttccaaaaatggacaaccaatcatccctgttcttttgccaaagtacattgggttggacccggtggctccaggagacctcaccatggtaatcacacaggattgtgacacgtgtcattctcctgcaagtcttccagctgtggttgagaagtaattgcaataattgactcagatccagttttacagaatcttctcagggatagtgataacatc-tttttaataatccgtctactagaagagatacttctaattgatcaatatactaaaggtgctttacaccattgtctcttttctctcctaaatgtagagcttaacaaaagactcataatatacctgtttttaaaagattgattgatgaaagatc--atgactaataacattacaaacaatcctactataatcaat-acggtgattcaaatgtcaatctttctcattgcacatactctttgtccttatcctcaaattgcctacatgcttacatctgaggacagccagtgtgacttggattggagatgtggaggaaaaatcggggcccatttctaagttgttcacaatctaagtacagacattgctcttctaattaagaaaaaatcggcgatgaagattaagccgacagtgagcgtaatcttcatctctcttagattatttgtcttccagagtaggggtcatcaggtccttttcaattggataaccaaaataagcttcactagaaggatattgtgaggcgacaacacaatgggtgttacaggaatcttgcagttacctcgtgatcgattcaagaggacatcattctttctttgggtaattatccttttccaaagaacattttccatcccgcttggagttatccacaatagtacattacaggttagtgatgtcgacaaactagtttgtcgtgacaaactgtcatccacaaatcaattgagatcagttggactgaatctcgaggggaatggagtggcaactgacgtgccatctgtgactaaaagatggggcttcaggtccggtgtcccaccaaaggtggtcaattatgaagctggtgaatgggctgaaaactgctacaatcttgaaatcaaaaaacctgacgggagtgagtgtctaccagcagcgccagacgggattcggggcttcccccggtgccggtatgtgcacaaagtatcaggaacgggaccatgtgccggagactttgccttccacaaagagggtgctttcttcctgtatgatcgacttgcttccacagttatctaccgaggaacgactttcgctgaaggtgtcgttgcatttctgatactgccccaagctaagaaggacttcttcagctcacaccccttgagagagccggtcaatgcaacggaggacccgtcgagtggctattattctaccacaattagatatcaggctaccggttttggaactaatgagacagagtacttgttcgaggttgacaatttgacctacgtccaacttgaatcaagattcacaccacagtttctgctccagctgaatgagacaatatatgcaagtgggaagaggagcaacaccacgggaaaactaatttggaaggtcaaccccgaaattgatacaacaatcggggagtgggccttctgggaaact?aaaaaaacctcactagaaaaattcgcagtgaagagttgtctttcacagctgtatcaaacggacccaaaaacatcagtggtcagagtccggcgcgaacttcttccgacccagagaccaacacaacaaatgaagaccacaaaatcatggcttcagaaaattcctctgcaatggttcaagtgcacagtcaaggaaggaaagctgcagtgtcgcatctgacaacccttgccacaatctccacgagtcctcaacctcccacaaccaaaacaggtccggacaacagcacccataatacacccgtgtataaacttgacatctctgaggcaactcaagttggacaacatcaccgtagagcagacaacgacagcacagcctccgacactccccccgccacgaccgcagccggacccttaaaagcagagaacaccaacacgagtaagagcgctgactccctggacctcgccaccacgacaagcccccaaaactacagcgagactgctggcaacaacaacactcatcaccaagataccggagaagagagtgccagcagcgggaagctaggcttaattaccaatactattgctggagtagcaggactgatcacaggcgggagaaggactcgaagagaagtaattgtcaatgctcaacccaaatgcaaccccaatttacattactggactactcaggatgaaggtgctgcaatcggattggcctggataccatatttcgggccagcagccgaaggaatttacacagaggggctaatgcacaaccaagatggtttaatctgtgggttgaggcagctggccaacgaaacgactcaagctctccaactgttcctgagagccacaactgagctgcgaaccttttcaatcctcaaccgtaaggcaattgacttcctgctgcagcgatggggtggcacatgccacattttgggaccggactgctgtatcgaaccacatgattggaccaagaacataacagacaaaattgatcagattattcatgattttgttgataaaacccttccggaccagggggacaatgacaattggtggacaggatggagacaatggataccggcaggtattggagttacaggtgttataattgcagttatcgctttattctgtatatgcaaatttgtcttttagtctttcttcagattgtttcacggcaaaactcaacctcaaatcaatgaaactaggatttaattatatgaatcacttgaatctaagattacttgacaaatgataacataatacactggagcttcaaacatagccaatgtgattctaactcctttaaactcacagttaatcataaacaaggtttgacatcaatctagctatatctttaagaatgataaacttgatgaagattaagaaaaaggtaatctttcgattatctttagtcttcatccttgattctacaatcatgacagttgtctttaatgaaaaaggaaaaaagccttttta-ttaagttgtaataatcagatctgcaaaccggtagaatttagttgtaacctaacacacacaaagcattggtaaaaaagtcaatagaaatttaaacagtgagtgcagacaactcttaaatggaagcttcatatgagagaggacgcccccgagctgccagacagcattcaagggatggacacgaccaccatgttcgagcacgatcatcatccagagagaattatcgaggtgagtaccgtcaatcaaggagcgcctcacaagtgcgcgttcctactgtatttcataagaagagagttgaaccattaacagttcctccagcacctaaagacatatgtccgaccttgaaaaaaggatttttgtgtgacagtagtttttgcaaaaaagaccaccagttagaaagtttaactg-atagggaattactcctactaatcgcccgtaagacttgtggatcagtagaacaacaattaaatataactgcacccaaggactcgcgcttagcaaatccaacggctgatgatttccagcaagaggaaggtcccaaaattaccttgttgacactgatcaagacggcagaacactgggcgagacaagacatccgaaccatagaggattccaaattaagggcattgttaactctatgtgctgtgatgacgaggaaattctcaaaatcccagctgagtcttttgtgtgagacacacctaaggcgcgaagggcttgggcaagatcaggcagaacccgttctcgaagtatatcaacgattacacagtgataaaggaggcagttttgaagctgcactatggcaacaatgggaccgacaatccctaattatgtttatcactgcattcttgaatatcgctctccagttaccgtgtgaaagttctgctgtcgttgtttcagggttaagaacattggttcctcaatcagataatgaggaagcttcaaccaacccggggacatgctcatggtctgatgagggtaccccttaataaggctgactaaaacactatataaccttctacttgatcacaatactccgtatacctatcatcatatatttaatcaagacgatatcctttaaaac-ttattcagtactataatcactctcatttcaaattgataagatatgcataattgccttaatatataaagaggtatgatataacccaaacattgaccaaagaaaatcataatctcgtatcgctcgcaatataacctgccaagcatacctcttgcacaaagtgattcttgtacacaaataatgtttgactctacaggaggtagcaacgatccatctcatc-aaaaaataagtattttatgatttactaatgatctcttaaaatattaagaaaaactgacggaacataaattctttctgcttcaagttgtggaggaggtctatggtattcgctattgttatattacaatcaataacaagcttg------taaaaatattgttcttgtttcaggaggtatattgtgaccggaaaagctaaactaatgatgaagattaatgcggaggtctgatgagaataaaccttattattcagattaggccccaagaggcattcttcatctccttttagcaaaatactatttcaggatagtccagctagtgacacgtcttttagctgtataccagttgcccctgagatacgccacaaaagtgtctctgagctaaagtggtctgtacacatctcatacattgtattaggggcaataatatctaattgaacttagccatttaaaatttagtgcataaatctgggctaactccaccaggtcaactcc-attggctgaaaagaagcccacctacaacgaacattactttgagcgccctcacaattaaaaaataagagcgtcgttccaacaatcgagcgcaaggttacaaggttgaactgagagtgtctagacaacaaaatatcgatactctagacaccaagcaagacctgag--aaaaaaccatggccaaagctacgggacgatacaatctaatatcgcccaaaaaggacctggagaaaggggttgtcttaagcgacctctgtaacttcttagttagtcaaactattcaagggtggaaagtttattgggctggtattgagtttgatgtgactcacaaaggaatggccctattgcatagactgaaaactaatgactttgcccctgcatggtcaatgacaaggaacctatttccccatttatttcaaaatccgaattccactattgaatcaccgctgtgggcactgagagtcatccttgcagcagggatacaggaccagttaattgaccagtctttgattgaacccttagcaggagcccttggtctgatctctgattggctgctaacaaccaacactaaccatttcaacatgcgaacacaacgtgtcaaggaacaattgagcctaaaaatgctgtcgttgattcgatccaatattctcaagtttattaacaaattggatgctctacatgtcgtgaactacaatggattattgagcagtattgaaattggaactcaaaatcatacaatcatcataactcgaactaacatgggttttctggtggagctccaagaacccgacaaatcggcaatgaaccgcaagaagcctgggccggcgaaattttccctccttcatgagtccacactgaaagcatttacacaagggtcctcgacacgaatgcaaagtttaattcttgaattcaatagctctcttgctatctaactaagatggaatacttcatattgggctaactcatatatgctgactcaatagttaacttgacatctctgccttcataatcagatatataagcataataaataaatactcatatttcttgataatttgtttaaccacagataaatcctcactgtaagccagcttccaagttgacacccttacaaaaaccaggactcagaatccctcaaataagagattccaagacaacatcatagaattgctttat--tatattaataagcattttatcactagaaatccaatatacgaaatggttaattgtaactaaacccgcaggtcatgtgtgttaggtttcacaaattatatatattactaactccatactcgtaactaacattagataagtaggttaagaaaaaagcttgaggaagattaag-aaaaactgcttattgggtctttccgtgttttagatgaagcagttgacattcttcctcttgatattaaatggctacacaacatacccaatacccagacgccaggttatcatcaccaattgtattggaccaatgtgaccttgtcactagagcttgcgggttgtattcatcatactcccttaatccgcaactacgcaactgtaaactcccgaaacatatataccgtttaaaatatgatgtaactgttaccaagttcttaagtgatgtaccagtggcgacattgcccatagatttcatagtcccaattcttctcaaggcactatcaggcaatgggttctgtcctgttgagccgcggtgccaacagttcttagatgaaattattaagtacacaatgcaagatgctctcttcctgaaatattatctcaaaaatgtgggtgctcaagaagactgtgttgatgaccactttcaagaaaaaatcttatcttcaattcagggcaatgaatttttacatcaaatgtttttctggtatgacctggctattttaactcgaaggggtagattaaatcgaggaaactctagatcaacgtggtttgttcatgatgatttaatagacatcttaggctatggggactatgttttttggaagatcccaatttcactgttaccactgaacacacaaggaatcccccatgctgctatggattggtatcagacatcagtattcaaagaagcggttcaagggcatacacacattgtttctgtttctactgccgatgtcttgataatgtgcaaagatttaattacatgtcgattcaacacaactctaatctcaaaaatagcagaggttgaggacccagtttgctctgattatcccaattttaagattgtgtctatgctttaccagagcggagattacttactctccatattagggtctgatgggtataaaatcattaagtttctcgaaccattgtgcttggctaaaattcaattgtgctcaaagtacaccgagaggaagggccgattcttaacacaaatgcatttagctgtaaatcacaccctggaagaaattacagaaatacgtgcactaaagccttcacaggctcacaagatccgtgaattccatagaacattgataaggctggagatgacgccacaacaactttgtgagctattttccatacaaaaacactgggggcatcctgtgctacatagtgaaacagcaatccaaaaagttaaaaaacatgctacggtgctaaaagcattacgccctatcgtgattttcgagacatattgtgtttttaaatatagcattgcaaaacattattttgatagtcaaggatcttggtacagtgttacctcagatagaaatctaacaccaggtcttaattcttatatcaaaagaaatcaattccctccgttgccaatgattaaagaactgctatgggaattttaccaccttgaccatcctccacttttctcaaccaaaattattagtgacttaagtatttttataaaagacagagctactgcagtagaaaggacatgctgggatgcagtattcgagcctaatgttctgggatataatccacctcacaaattcagtaccaaacgtgtaccggaacaatttttagagcaagaaaacttttctattgagaatgttctttcctacgcgcaaaaactcgagtatctactaccacaatatcggaatttttc-tttctcattgaaagagaaagagttgaatgtaggtagaactttcggaaaattgccttatccgactcgcaatgttcaaacactttgtgaagctctgttagctgatggtcttgctaaagcatttcctagcaatatgatggtagttacggaacgtgaacaaaaagaaagcttattgcatcaagcatcatggcaccacacaagtgatgatttcggtgagcatgccacagttagagggagtagctttgtaactgatttagagaaatacaatcttgcatttaggtatgagtttacagcaccttttatagaatattgcaaccgttgctatggtgttaagaatgtttttaattggatgcattatacaatcccacagtgttatatgcatgtcagtgattattataatccaccgcataacctcacactggaaaatcgaaacaacccccctgaagggcctagttcatacaggggtcatatgggagggattgaaggactgcaacaaaaactctggacaagtatttcatgtgctcaaatttctttagttgaaattaagactggttttaagttgcgctcagctgtgatgggtgacaatcagtgcattaccgttttatcagtcttccccttagagactgatgcaggcgagcaggaacagagcgccgaggacaatgcagcgagggtggccgccagcctagcaaaagttacaagtgcctgtggaatctttttaaaacctgatgaaacatttgtacattcaggttttatctattttggaaaaaaacaatatttgaatggggtccaattgcctcagtcccttaaaacggctacaagaatggcaccattgtctgatgcaatttttgatgatcttcaagggaccctggctagtataggtactgcttttgagcgatccatctctgagacacgacatatctttccttgcagaataaccgcagctttccatacgttcttttcggtgagaatcttgcaatatcatcacctcggatttaataaaggttttgaccttggacagttaacactcggtaaacctctggatttcggaacaatatcattggcactagcggtaccgcaggtgcttggagggttatccttcttgaatcctgagaaatgtttctaccggaatctaggagatccagttacctcaggtttattccagttaaaaacttatctccgaatgattgagatggatgatttattcttacctttaattgcgaagaaccctgggaactgcactgccattgactttgtgctaaatcctagcggattaaatgttcctgggtcgcaagacttaacttcatttctgcgccagattgtacgtaggactatcaccctaagtgcgaaaaacaaacttattaataccttatttcatgcatcagctgacttcgaagacgaaatggtttgtaagtggctcttatcatcaactcctgttatgagtcgtttcgcagccgatatattttcacgcacgccgagcgggaagcgattgcaaattctaggatacttggaaggaacacgcacattattagcctctaagatcatcaacaataatacagagacgccggttttggacagactgaggaagataacattgcaaaggtggagtctatggtttagttatcttgatcattgtgataatatcctggcggaggctttaacccaaataacttgcacagttgatttagcacagatcctgagggaatattcatgggcacatattttagaggggagacctcttattggagccacactcccatgtatgattgagcaattcaaagtggtttggctgaaaccctacgaacaatgtccgcagtgttcaaatgccaagcaacctggtgggaaaccattcgtgtcagtagcagtcaagaaacatattgttagtgcatggccaaatgcatcccgaataagctggactatcggggatggaatcccatacattggatcaaggacagaagataagatagggcaacctgctattaaaccaaaatgtccttccgcagccttaagagaggccattgaattggcgtcccgtttaacatgggtaactcaaggcagttcgaacagtgacttgctaataaaaccatttttggaagcacgagtaaatttaagtgttcaagaaatacttcaaatgaccccttcacattactcgggaaatattgttcataggtacaacgatcaatacagtcctcattctttcatggccaatcgtatgagtaactcagcaacgcgattgattgtttctacaaacactttaggtgagttttcaggaggtggccaatcggcacgcgacagcaatattattttccagaatgttataaattatgcagttgcactgttcgatattaaatttagaaacactgaggctacagatatccagtataatcgtgctcaccttcatctaactaagtgttgcacccgggaggtaccagctcagtacttaacatacacatctacattggatttagatttaacaagataccgagaaaatgaattgatttatgacaataatcctctaaaaggaggactcaattgcaatatctcatttgataacccatttttccaaggcaaacagctgaacattatagaagatgaccttattcgactgcctcacttatctggatgggagctagctaagaccatcatgcaatcaattatttcagatagcaataattcgtctacagacccaattagcagtggagaaacaagatcattcactacccatttcttaacttatcccaaaataggacttctgtacagttttggggcctttgtaagttattatcttggcaatacaattcttcggactaagaaattaacacttgacaattttttatattacttaactacccaaattcataatctaccacatcgctcattgcgaatacttaagccaacattcaaacatgcaagcgttatgtcacgattaatgagtattgatccccatttttctatttacataggcggtgctgcaggtgacagaggactctcagatgcggccaggttatttttgagaacgtccatttcatcttttcttacatttgtaaaggaatggataattaatcgcggaacaattgtccctttatggatagtatatccattagagggtcaaaatccaacacctgttaataatttcctccatcagatcgtagaactgctggtgcatgattcatcaagacaccaggcttttaaaactaccataaatgatcatgtacatcctcacgacaatcttgtttacacatgtaagagtacagccagcaatttcttccatgcgtcattggcgtactggaggaacaggcacagaaacagcaaccgaaaagacttgacaagaaactcttcaactggatcaagcacaaacaacagtgatggtcatattaagagaagtcaagaacaaaccaccagagatccacatgatggcactgaacggagtctagtcctgcaaatgagccatgaaataaaaagaacgacaattccacaagagaacacgcaccagggtccgtcgttccagtcatttctaagtgactctgcttgcggtacagcaaacccaaaactaaatttcgatagatcgagacacaatgtgaaatctcaggatcataactcagcatccaagagggaaggtcatcaaataatctcacatcgtctagtcctacctttctttacattatctcaagggacacgccaattaacgtcatccaatgagtcacaaacccaagatgagatatcaaagtacttacggcaattgagatccgtcattgataccacagtttattgtaggtttaccggtatagtctcgtccatgcattacaaacttgatgaggtcctttgggaaatagagaattttaagtcggctgtgacgctggcagagggagaaggtgctggtgccttactattgattcagaaataccaagttaagaccttattcttcaacacgctagctactgagtccagtatagagtcagaaatagtatcaggaatgactactcctaggatgcttctacctgttatgtcaaaattccataatgaccaaattgagattattcttaacaactcagcaagccaaataacagacataacaaatcctacttggtttaaagaccaaagagcaaggctacctaggcaagtcgaggttataaccatggatgcagagacgacagagaatataaacagatcgaaattgtacgaagctgtacataaattgatcttacaccatgttgatcccagcgtattgaaagcagtggtccttaaagtctttctaagtgataccgagggtatgttatggctaaatgataatctagccccgttttttgccactgggtatttaattaagccaataacgtcaagtgccaggtctagtgagtggtatctttgtctgacgaacttcttatcaactacacgtaagatgccacaccaaaaccatctcagttgtaagcaggtaatacttacggcattgcaactgcaaattcaacggagcccatactggctaagtcatttaactcagtatgctgactgcgatttacatttaagctatatccgccttggttttccatcattagagaaagtactataccacaggtataaccttgtcgattcaaaaagaggtccactagtctctgtcactcagcacttagcacatcttagggcagagattcgagaattgaccaatgattataatcaacagcgacaaagtcggactcaaacatatcactttattcgtactgcaaaaggacgaatcacaaaactagtcaatgattatttaaaattctttcttattgtacaagcattaaaacataatgggacatggcaagctgagtttaagaaattaccagagttgattagtgtgtgcaataggttctatcatattagagattgtaattgtgaagaacgtttcttagttcaaaccttatatttacatagaatgcaggattctgaagttaagcttatcgaaaggctgacagggcttctgagtttatttccagatggtctctacaggttcgattgaataaccgtgcatagtattttgatacttgtaaaggttggttatcaacatacagattat-aaaaaactcataaattgctctcatacatcatcttgatctgatttcaataaataactatttagataacgaaaggagtccttacattatacactatatttggcctctctccctgcgtgataatc-aaaaaattcacaatacagcatgtgtgacatattactgctgcaatgagtctaacgcaacataataaactccgcactctttataattaagctttaacgataggtctgggctcatattgttattgatatagtaatgttgtatcaatatcttgccagatggaatagtgctttggttgataacacgacttcttaaaacaaaactgatctttaagattaag-ttttttataattgtcattgctttaatttgtcga-tttaaaaatggtgatagccttaatctttgtgtaaaataagagattaggtgtaataactttaacatttttgtctagtaagctactattccattcagaatgataaaattaaaagaaaagacatgactgtaaaatcagaaataccttctttacaatatagcagactagataataatcttcgtgttaatgataattaaggcattgaccacgctcatcagaaggctcactagaataaacgttgcaaaaaggatccctggaaaaatggtcgcacacaaaaatttaaaaataaatctatttcttcttttttgtgtgnnnnnn From 477979bf3be9ed38308c584ef2f4f429c5585767 Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 10:05:02 -0800 Subject: [PATCH 04/12] refactor: flag intermediate files as temp Flags most of the intermediate representations of sequences and metadata as temporary files such that we only keep the final compressed outputs. Deleting the intermediate files reduced the data directory size from 221MB to 584 KB. --- ingest/config/optional.yaml | 4 ++-- ingest/workflow/snakemake_rules/fetch_sequences.smk | 4 ++-- ingest/workflow/snakemake_rules/transform.smk | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/ingest/config/optional.yaml b/ingest/config/optional.yaml index fe9bf40..287e4d2 100644 --- a/ingest/config/optional.yaml +++ b/ingest/config/optional.yaml @@ -7,8 +7,8 @@ upload: dst: 's3://nextstrain-data/files/workflows/ebola/test' # Files to upload to S3 that are in the `data` directory files_to_upload: [ - 'metadata_all.tsv', - 'sequences_all.fasta', + 'metadata_all.tsv.zst', + 'sequences_all.fasta.zst', ] # Remote file names for the files to upload, must be in the same order as local files above remote_file_names: [ diff --git a/ingest/workflow/snakemake_rules/fetch_sequences.smk b/ingest/workflow/snakemake_rules/fetch_sequences.smk index 0e2d065..aa1d318 100644 --- a/ingest/workflow/snakemake_rules/fetch_sequences.smk +++ b/ingest/workflow/snakemake_rules/fetch_sequences.smk @@ -21,7 +21,7 @@ def download_serotype(w): rule fetch_from_genbank: output: - genbank_ndjson="data/genbank_{serotype}.ndjson", + genbank_ndjson=temp("data/genbank_{serotype}.ndjson"), params: serotype_tax_id=download_serotype, csv_to_ndjson_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/csv-to-ndjson", @@ -50,7 +50,7 @@ rule fetch_all_sequences: input: all_sources=_get_all_sources, output: - sequences_ndjson="data/sequences_{serotype}.ndjson", + sequences_ndjson=temp("data/sequences_{serotype}.ndjson"), shell: """ cat {input.all_sources} > {output.sequences_ndjson} diff --git a/ingest/workflow/snakemake_rules/transform.smk b/ingest/workflow/snakemake_rules/transform.smk index 78e399a..8d7480b 100644 --- a/ingest/workflow/snakemake_rules/transform.smk +++ b/ingest/workflow/snakemake_rules/transform.smk @@ -15,7 +15,7 @@ Parameters are expected to be defined in `config.transform`. rule fetch_general_geolocation_rules: output: - general_geolocation_rules="data/general-geolocation-rules.tsv", + general_geolocation_rules=temp("data/general-geolocation-rules.tsv"), params: geolocation_rules_url=config["transform"]["geolocation_rules_url"], shell: @@ -29,7 +29,7 @@ rule concat_geolocation_rules: general_geolocation_rules="data/general-geolocation-rules.tsv", local_geolocation_rules=config["transform"]["local_geolocation_rules"], output: - all_geolocation_rules="data/all-geolocation-rules.tsv", + all_geolocation_rules=temp("data/all-geolocation-rules.tsv"), shell: """ cat {input.general_geolocation_rules} {input.local_geolocation_rules} >> {output.all_geolocation_rules} @@ -42,7 +42,7 @@ rule transform: all_geolocation_rules="data/all-geolocation-rules.tsv", annotations=config["transform"]["annotations"], output: - metadata="data/raw_metadata_{serotype}.tsv", + metadata=temp("data/raw_metadata_{serotype}.tsv"), sequences="data/sequences_{serotype}.fasta", log: "logs/transform_{serotype}.txt", From e80815fe6d6a69fe860413a7e97fff8ac64a736a Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 10:24:10 -0800 Subject: [PATCH 05/12] refactor: serotypes Since serotype is annotated as a column in metadata, simplify intermediate filenames like `data/sequences_{serotype}.fasta` and `data/metadata_{serotype}.tsv` to `data/sequences.fasta` and `data/metadata.tsv`. --- ingest/README.md | 6 +++--- ingest/Snakefile | 2 +- ingest/config/optional.yaml | 8 ++++---- .../snakemake_rules/fetch_sequences.smk | 14 ++++--------- ingest/workflow/snakemake_rules/transform.smk | 20 +++++++++---------- 5 files changed, 22 insertions(+), 28 deletions(-) diff --git a/ingest/README.md b/ingest/README.md index 7384113..59290ea 100644 --- a/ingest/README.md +++ b/ingest/README.md @@ -10,7 +10,7 @@ This is the ingest pipeline for Ebola virus sequences. Fetch sequences with ```sh -nextstrain build --cpus 1 . data/sequences_all.ndjson +nextstrain build --cpus 1 . data/sequences.ndjson ``` Run the complete ingest pipeline with @@ -21,8 +21,8 @@ nextstrain build --cpus 1 . This will produce two files (within the `ingest` directory): -- data/metadata_all.tsv -- data/sequences_all.fasta +- data/metadata.tsv +- data/sequences.fasta Run the complete ingest pipeline and upload results to AWS S3 with diff --git a/ingest/Snakefile b/ingest/Snakefile index d370314..f58e943 100644 --- a/ingest/Snakefile +++ b/ingest/Snakefile @@ -9,7 +9,7 @@ serotypes = ['all'] def _get_all_targets(wildcards): # Default targets are the metadata TSV and sequences FASTA files - all_targets = expand(["data/sequences_{serotype}.fasta.zst", "data/metadata_{serotype}.tsv.zst"], serotype=serotypes) + all_targets = ["data/sequences.fasta.zst", "data/metadata.tsv.zst"] # Add additional targets based on upload config upload_config = config.get("upload", {}) diff --git a/ingest/config/optional.yaml b/ingest/config/optional.yaml index 287e4d2..e5e9975 100644 --- a/ingest/config/optional.yaml +++ b/ingest/config/optional.yaml @@ -7,13 +7,13 @@ upload: dst: 's3://nextstrain-data/files/workflows/ebola/test' # Files to upload to S3 that are in the `data` directory files_to_upload: [ - 'metadata_all.tsv.zst', - 'sequences_all.fasta.zst', + 'metadata.tsv.zst', + 'sequences.fasta.zst', ] # Remote file names for the files to upload, must be in the same order as local files above remote_file_names: [ - 'metadata_all.tsv.zst', - 'sequences_all.fasta.zst', + 'metadata.tsv.zst', + 'sequences.fasta.zst', ] cloudfront_domain: 'data.nextstrain.org' diff --git a/ingest/workflow/snakemake_rules/fetch_sequences.smk b/ingest/workflow/snakemake_rules/fetch_sequences.smk index aa1d318..40c57b1 100644 --- a/ingest/workflow/snakemake_rules/fetch_sequences.smk +++ b/ingest/workflow/snakemake_rules/fetch_sequences.smk @@ -13,17 +13,11 @@ Produces final output as """ -def download_serotype(w): - serotype = { - 'all': '186536', # Returns 3530 records, check if we need a more specific Taxon ID - } - return serotype[w.serotype] - rule fetch_from_genbank: output: - genbank_ndjson=temp("data/genbank_{serotype}.ndjson"), + genbank_ndjson=temp("data/genbank.ndjson"), params: - serotype_tax_id=download_serotype, + serotype_tax_id='186536', # Returns 3530 records, check if we need a more specific Taxon ID csv_to_ndjson_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/csv-to-ndjson", fetch_from_genbank_url="https://raw.githubusercontent.com/nextstrain/dengue/new_ingest/ingest/bin/fetch-from-genbank", genbank_url_url="https://raw.githubusercontent.com/nextstrain/dengue/new_ingest/ingest/bin/genbank-url", # Update if dengue merged @@ -43,14 +37,14 @@ rule fetch_from_genbank: def _get_all_sources(wildcards): - return [f"data/{source}_{wildcards.serotype}.ndjson" for source in config["sources"]] + return [f"data/{source}.ndjson" for source in config["sources"]] rule fetch_all_sequences: input: all_sources=_get_all_sources, output: - sequences_ndjson=temp("data/sequences_{serotype}.ndjson"), + sequences_ndjson=temp("data/sequences.ndjson"), shell: """ cat {input.all_sources} > {output.sequences_ndjson} diff --git a/ingest/workflow/snakemake_rules/transform.smk b/ingest/workflow/snakemake_rules/transform.smk index 8d7480b..ea507c2 100644 --- a/ingest/workflow/snakemake_rules/transform.smk +++ b/ingest/workflow/snakemake_rules/transform.smk @@ -38,14 +38,14 @@ rule concat_geolocation_rules: rule transform: input: - sequences_ndjson="data/sequences_{serotype}.ndjson", + sequences_ndjson="data/sequences.ndjson", all_geolocation_rules="data/all-geolocation-rules.tsv", annotations=config["transform"]["annotations"], output: - metadata=temp("data/raw_metadata_{serotype}.tsv"), - sequences="data/sequences_{serotype}.fasta", + metadata=temp("data/raw_metadata.tsv"), + sequences="data/sequences.fasta", log: - "logs/transform_{serotype}.txt", + "logs/transform.txt", params: field_map=config["transform"]["field_map"], strain_regex=config["transform"]["strain_regex"], @@ -123,9 +123,9 @@ rule transform: rule post_process_metadata: input: - metadata="data/raw_metadata_{serotype}.tsv", + metadata="data/raw_metadata.tsv", output: - metadata="data/metadata_{serotype}.tsv", + metadata="data/metadata.tsv", params: post_process_metadata_url="https://raw.githubusercontent.com/nextstrain/zika/ingest/ingest/bin/post_process_metadata.py", @@ -144,11 +144,11 @@ rule post_process_metadata: rule compress: input: - sequences="data/sequences_{serotype}.fasta", - metadata="data/metadata_{serotype}.tsv", + sequences="data/sequences.fasta", + metadata="data/metadata.tsv", output: - sequences="data/sequences_{serotype}.fasta.zst", - metadata="data/metadata_{serotype}.tsv.zst", + sequences="data/sequences.fasta.zst", + metadata="data/metadata.tsv.zst", shell: """ zstd -T0 -o {output.sequences} {input.sequences} From a17b2f03f4a44e39e5d2d8afd4f5f9a2570e3a3e Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 10:49:42 -0800 Subject: [PATCH 06/12] docs: ingest directory In ingest/README.md, assume user is within ingest directory. --- ingest/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ingest/README.md b/ingest/README.md index 59290ea..0c81a30 100644 --- a/ingest/README.md +++ b/ingest/README.md @@ -39,9 +39,9 @@ Do the following to include sequences from static FASTA files. 1. Convert the FASTA files to NDJSON files with: ```sh - wget https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/fasta-to-ndjson -O ingest/bin/fasta-to-ndjson - chmod 755 ingest/bin/fasta-to-ndjson - ./ingest/bin/fasta-to-ndjson \ + wget https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/fasta-to-ndjson -O bin/fasta-to-ndjson + chmod 755 bin/fasta-to-ndjson + ./bin/fasta-to-ndjson \ --fasta {path-to-fasta-file} \ --fields {fasta-header-field-names} \ --separator {field-separator-in-header} \ From fad2af9c636d01ff4fd18e3dfa9b19786ecf543f Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 12:10:23 -0800 Subject: [PATCH 07/12] edit: build accepts and decompresses zst inputs --- Snakefile | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/Snakefile b/Snakefile index 98b8235..b2e22a1 100644 --- a/Snakefile +++ b/Snakefile @@ -21,20 +21,34 @@ files = rules.files.params rule download: """Downloading sequences and metadata from data.nextstrain.org""" output: - sequences = "data/sequences.fasta", - metadata = "data/metadata.tsv", + sequences = "data/sequences.fasta.zst", + metadata = "data/metadata.tsv.zst", params: - sequences_url = "https://data.nextstrain.org/files/workflows/ebola/test/sequences_all.fasta.zst", - metadata_url = "https://data.nextstrain.org/files/workflows/ebola/test/metadata_all.tsv.zst", + sequences_url = "https://data.nextstrain.org/files/workflows/ebola/test/sequences.fasta.zst", + metadata_url = "https://data.nextstrain.org/files/workflows/ebola/test/metadata.tsv.zst", + shell: + """ + curl -fsSL --compressed {params.sequences_url:q} --output {output.sequences} + curl -fsSL --compressed {params.metadata_url:q} --output {output.metadata} + """ + +rule decompress: + message: "Decompressing sequences and metadata" + input: + sequences = "data/sequences.fasta.zst", + metadata = "data/metadata.tsv.zst" + output: + sequences = "data/sequences.fasta", + metadata = "data/metadata.tsv" shell: """ - curl -fsSL {params.sequences_url:q} --output {output.sequences} - curl -fsSL {params.metadata_url:q} --output {output.metadata} + zstd -d -c {input.sequences} > {output.sequences} + zstd -d -c {input.metadata} > {output.metadata} """ rule wrangle_metadata: input: - metadata=rules.download.output.metadata, + metadata=rules.decompress.output.metadata, output: metadata="results/wrangled_metadata.tsv", params: From 5c060a0a9dd456dfbb74f55c7b50965b6b49b4c8 Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 12:25:00 -0800 Subject: [PATCH 08/12] docs: included a data provisioning section --- README.md | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/README.md b/README.md index 3cb0d26..d4c7f3e 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,41 @@ housed in this repository. ## Usage +### Provision input data + +Input sequences and metadata can be retrieved from data.nextstrain.org + +* [sequences.fasta.xz](https://data.nextstrain.org/files/workflows/ebola/test/sequences.fasta.zst) +* [metadata.tsv.zst](https://data.nextstrain.org/files/workflows/ebola/test/metadata.tsv.zst) + +Note that these data are generously shared by many labs around the world. +If you analyze and plan to publish using these data, please contact these labs first. + +Within the analysis pipeline, these data are fetched from data.nextstrain.org and written to `data/` with: + +```bash +nextstrain build . data/sequences.fasta data/metadata.tsv +``` + +### Run analysis pipeline + +Run pipeline to produce "overview" tree for `/ebola` with: + +```bash +nextstrain build . +``` + +### Visualize results + +View results with: + +```bash +nextstrain view auspice/ +``` + + + ## Configuration From a1f36e2074901f56bfcbc6192ccbe514484a1137 Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 12:53:25 -0800 Subject: [PATCH 09/12] refactor: used explicit paths instead of references to the rules variables --- Snakefile | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Snakefile b/Snakefile index b2e22a1..a7c16d9 100644 --- a/Snakefile +++ b/Snakefile @@ -39,7 +39,7 @@ rule decompress: metadata = "data/metadata.tsv.zst" output: sequences = "data/sequences.fasta", - metadata = "data/metadata.tsv" + metadata = "data/metadata.tsv", shell: """ zstd -d -c {input.sequences} > {output.sequences} @@ -48,7 +48,7 @@ rule decompress: rule wrangle_metadata: input: - metadata=rules.decompress.output.metadata, + metadata="data/metadata.tsv", output: metadata="results/wrangled_metadata.tsv", params: @@ -77,8 +77,8 @@ rule filter: - excluding strains in {input.exclude} """ input: - sequences = "results/sequences.fasta", - metadata = "results/metadata.tsv", + sequences = "data/sequences.fasta", + metadata = "results/wrangled_metadata.tsv", include = files.forced_strains, exclude = files.dropped_strains output: @@ -146,7 +146,7 @@ rule refine: input: tree = "results/tree_raw.nwk", alignment = "results/aligned.fasta", - metadata = "results/metadata.tsv" + metadata = "results/wrangled_metadata.tsv" output: tree = "results/tree.nwk", node_data = "results/branch_lengths.json" @@ -171,7 +171,7 @@ rule ancestral: """Reconstructing ancestral sequences and mutations""" input: tree = "results/tree.nwk", - alignment = "results/aligned.fasta" + alignment = "results/aligned.fasta", output: node_data = "results/nt_muts.json" params: @@ -206,7 +206,7 @@ rule traits: """Inferring ancestral traits for {params.columns!s}""" input: tree = "results/tree.nwk", - metadata = "results/metadata.tsv" + metadata = "results/wrangled_metadata.tsv" output: node_data = "results/traits.json", params: @@ -225,7 +225,7 @@ rule export: """Exporting data files for for auspice""" input: tree = "results/tree.nwk", - metadata = "results/metadata.tsv", + metadata = "results/wrangled_metadata.tsv", branch_lengths = "results/branch_lengths.json", traits = "results/traits.json", nt_muts = "results/nt_muts.json", @@ -253,11 +253,11 @@ rule export: rule final_strain_name: input: - auspice_json=rules.export.output.auspice_json, - metadata=rules.wrangle_metadata.output.metadata, - root_sequence=rules.export.output.root_sequence, + auspice_json="results/raw_ebola.json", + metadata="results/wrangled_metadata.tsv", + root_sequence="results/raw_ebola_root-sequence.json", output: - auspice_json=rules.all.input.auspice_json, + auspice_json="auspice/ebola.json", root_sequence="auspice/ebola_root-sequence.json", params: display_strain_field=lambda w: config.get("display_strain_field", "strain"), From a157df7838c64215b405960576ded4dc69ec69e7 Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 13:30:00 -0800 Subject: [PATCH 10/12] edit: Use a permalink for each script This would allow us to version the software we use in this workflow without being affected by upstream changes until we want to bump the version. This design adds more maintenance to this workflow, but it also protects users against unexpected issues that are outside of their control. --- Snakefile | 4 ++-- .../snakemake_rules/fetch_sequences.smk | 6 +++--- .../snakemake_rules/slack_notifications.smk | 4 ++-- ingest/workflow/snakemake_rules/transform.smk | 20 +++++++++---------- .../snakemake_rules/trigger_rebuild.smk | 2 +- ingest/workflow/snakemake_rules/upload.smk | 6 +++--- 6 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Snakefile b/Snakefile index a7c16d9..d14db5d 100644 --- a/Snakefile +++ b/Snakefile @@ -53,7 +53,7 @@ rule wrangle_metadata: metadata="results/wrangled_metadata.tsv", params: strain_id=lambda w: config.get("strain_id_field", "strain"), - wrangle_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/scripts/wrangle_metadata.py", + wrangle_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/scripts/wrangle_metadata.py", shell: """ if [[ ! -d bin ]]; then @@ -261,7 +261,7 @@ rule final_strain_name: root_sequence="auspice/ebola_root-sequence.json", params: display_strain_field=lambda w: config.get("display_strain_field", "strain"), - set_final_strain_name_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/scripts/set_final_strain_name.py", + set_final_strain_name_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/scripts/set_final_strain_name.py", shell: """ if [[ ! -d bin ]]; then diff --git a/ingest/workflow/snakemake_rules/fetch_sequences.smk b/ingest/workflow/snakemake_rules/fetch_sequences.smk index 40c57b1..c44c4ab 100644 --- a/ingest/workflow/snakemake_rules/fetch_sequences.smk +++ b/ingest/workflow/snakemake_rules/fetch_sequences.smk @@ -18,9 +18,9 @@ rule fetch_from_genbank: genbank_ndjson=temp("data/genbank.ndjson"), params: serotype_tax_id='186536', # Returns 3530 records, check if we need a more specific Taxon ID - csv_to_ndjson_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/csv-to-ndjson", - fetch_from_genbank_url="https://raw.githubusercontent.com/nextstrain/dengue/new_ingest/ingest/bin/fetch-from-genbank", - genbank_url_url="https://raw.githubusercontent.com/nextstrain/dengue/new_ingest/ingest/bin/genbank-url", # Update if dengue merged + csv_to_ndjson_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/csv-to-ndjson", + fetch_from_genbank_url="https://raw.githubusercontent.com/nextstrain/dengue/ca659008bfbe4b3f799e11ecd106a0b95977fe93/ingest/bin/fetch-from-genbank", + genbank_url_url="https://raw.githubusercontent.com/nextstrain/dengue/ca659008bfbe4b3f799e11ecd106a0b95977fe93/ingest/bin/genbank-url", # Update if dengue merged shell: """ if [[ ! -d bin ]]; then diff --git a/ingest/workflow/snakemake_rules/slack_notifications.smk b/ingest/workflow/snakemake_rules/slack_notifications.smk index 638f84a..91d5ffc 100644 --- a/ingest/workflow/snakemake_rules/slack_notifications.smk +++ b/ingest/workflow/snakemake_rules/slack_notifications.smk @@ -28,7 +28,7 @@ rule notify_on_genbank_record_change: touch("data/notify/genbank-record-change.done"), params: s3_src=S3_SRC, - notify_on_record_change_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/notify-on-record-change", + notify_on_record_change_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/notify-on-record-change", shell: """ if [[ ! -d bin ]]; then @@ -52,7 +52,7 @@ rule notify_on_metadata_diff: touch("data/notify/metadata-diff.done"), params: s3_src=S3_SRC, - notify_on_diff_url = "https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/notify-on-diff", + notify_on_diff_url = "https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/notify-on-diff", shell: """ if [[ ! -d bin ]]; then diff --git a/ingest/workflow/snakemake_rules/transform.smk b/ingest/workflow/snakemake_rules/transform.smk index ea507c2..adfb2a3 100644 --- a/ingest/workflow/snakemake_rules/transform.smk +++ b/ingest/workflow/snakemake_rules/transform.smk @@ -62,15 +62,15 @@ rule transform: metadata_columns=config["transform"]["metadata_columns"], id_field=config["transform"]["id_field"], sequence_field=config["transform"]["sequence_field"], - transform_field_names_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-field-names", - transform_string_fields_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-string-fields", - transform_strain_names_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-strain-names", - transform_date_fields_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-date-fields", - transform_genbank_location_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-genbank-location", - transform_authors_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/transform-authors", - apply_geolocation_rules_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/apply-geolocation-rules", - merge_user_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/merge-user-metadata", - ndjson_to_tsv_and_fasta_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/ndjson-to-tsv-and-fasta", + transform_field_names_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/transform-field-names", + transform_string_fields_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/transform-string-fields", + transform_strain_names_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/transform-strain-names", + transform_date_fields_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/transform-date-fields", + transform_genbank_location_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/transform-genbank-location", + transform_authors_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/transform-authors", + apply_geolocation_rules_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/apply-geolocation-rules", + merge_user_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/merge-user-metadata", + ndjson_to_tsv_and_fasta_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/ndjson-to-tsv-and-fasta", shell: """ if [[ ! -d bin ]]; then @@ -127,7 +127,7 @@ rule post_process_metadata: output: metadata="data/metadata.tsv", params: - post_process_metadata_url="https://raw.githubusercontent.com/nextstrain/zika/ingest/ingest/bin/post_process_metadata.py", + post_process_metadata_url="https://raw.githubusercontent.com/nextstrain/zika/2ae81db362fdeb5e832153dfaf2294fe971e638c/ingest/bin/post_process_metadata.py", shell: """ diff --git a/ingest/workflow/snakemake_rules/trigger_rebuild.smk b/ingest/workflow/snakemake_rules/trigger_rebuild.smk index 6048dd8..aa5e52a 100644 --- a/ingest/workflow/snakemake_rules/trigger_rebuild.smk +++ b/ingest/workflow/snakemake_rules/trigger_rebuild.smk @@ -14,7 +14,7 @@ rule trigger_build: output: touch("data/trigger/rebuild.done") params: - trigger_on_new_data_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/trigger-on-new-data" + trigger_on_new_data_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/trigger-on-new-data" shell: """ if [[ ! -d bin ]]; then diff --git a/ingest/workflow/snakemake_rules/upload.smk b/ingest/workflow/snakemake_rules/upload.smk index 95ad81e..db2de41 100644 --- a/ingest/workflow/snakemake_rules/upload.smk +++ b/ingest/workflow/snakemake_rules/upload.smk @@ -54,9 +54,9 @@ rule upload_to_s3: quiet="" if send_notifications else "--quiet", s3_dst=config["upload"].get("s3", {}).get("dst", ""), cloudfront_domain=config["upload"].get("s3", {}).get("cloudfront_domain", ""), - upload_to_s3_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/upload-to-s3", - sha256sum_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/sha256sum", - cloudfront_invalidate_url="https://raw.githubusercontent.com/nextstrain/monkeypox/master/ingest/bin/cloudfront-invalidate" + upload_to_s3_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/upload-to-s3", + sha256sum_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/sha256sum", + cloudfront_invalidate_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/cloudfront-invalidate" shell: """ if [[ ! -d bin ]]; then From 5a2c5c43e161cc571413f21dc1f15fafaa23c53d Mon Sep 17 00:00:00 2001 From: j23414 Date: Fri, 16 Dec 2022 13:30:34 -0800 Subject: [PATCH 11/12] fixup: change dengue to ebola --- ingest/workflow/snakemake_rules/slack_notifications.smk | 2 +- ingest/workflow/snakemake_rules/trigger_rebuild.smk | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ingest/workflow/snakemake_rules/slack_notifications.smk b/ingest/workflow/snakemake_rules/slack_notifications.smk index 91d5ffc..acf95f3 100644 --- a/ingest/workflow/snakemake_rules/slack_notifications.smk +++ b/ingest/workflow/snakemake_rules/slack_notifications.smk @@ -18,7 +18,7 @@ if not slack_envvars_defined: ) sys.exit(1) -S3_SRC = "s3://nextstrain-data/files/workflows/dengue" +S3_SRC = "s3://nextstrain-data/files/workflows/ebola" rule notify_on_genbank_record_change: diff --git a/ingest/workflow/snakemake_rules/trigger_rebuild.smk b/ingest/workflow/snakemake_rules/trigger_rebuild.smk index aa5e52a..1a1cade 100644 --- a/ingest/workflow/snakemake_rules/trigger_rebuild.smk +++ b/ingest/workflow/snakemake_rules/trigger_rebuild.smk @@ -1,5 +1,5 @@ """ -This part of the workflow handles triggering new Dengue builds after the +This part of the workflow handles triggering new Ebola builds after the latest metadata TSV and sequence FASTA files have been uploaded to S3. Designed to be used internally by the Nextstrain team with hard-coded paths From 6ad16367c48670d692554c0559488f1b2900b6fe Mon Sep 17 00:00:00 2001 From: j23414 Date: Thu, 29 Dec 2022 17:00:12 -0800 Subject: [PATCH 12/12] Pick curl or wget based on availability --- Snakefile | 40 +++++++---- .../snakemake_rules/fetch_sequences.smk | 25 ++++--- .../snakemake_rules/slack_notifications.smk | 45 +++++++----- ingest/workflow/snakemake_rules/transform.smk | 69 +++++++++++++------ .../snakemake_rules/trigger_rebuild.smk | 23 ++++--- ingest/workflow/snakemake_rules/upload.smk | 25 ++++--- 6 files changed, 154 insertions(+), 73 deletions(-) diff --git a/Snakefile b/Snakefile index d14db5d..518fca6 100644 --- a/Snakefile +++ b/Snakefile @@ -56,14 +56,22 @@ rule wrangle_metadata: wrangle_metadata_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/scripts/wrangle_metadata.py", shell: """ - if [[ ! -d bin ]]; then - mkdir bin + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi - cd bin - [[ -f wrangle_metadata.py ]] || wget {params.wrangle_metadata_url} - chmod 755 * - cd .. + + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/wrangle_metadata.py ]] || $download_cmd bin/wrangle_metadata.py {params.wrangle_metadata_url} + chmod +x bin/* + # (3) Run the script python3 ./bin/wrangle_metadata.py --metadata {input.metadata} \ --strain-id {params.strain_id} \ --output {output.metadata} @@ -264,14 +272,22 @@ rule final_strain_name: set_final_strain_name_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/scripts/set_final_strain_name.py", shell: """ - if [[ ! -d bin ]]; then - mkdir bin + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi - cd bin - [[ -f set_final_strain_name.py ]] || wget {params.set_final_strain_name_url} - chmod 755 * - cd .. + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/set_final_strain_name.py ]] || $download_cmd bin/set_final_strain_name.py {params.set_final_strain_name_url} + chmod +x bin/* + + # (3) Run the script python3 bin/set_final_strain_name.py \ --metadata {input.metadata} \ --input-auspice-json {input.auspice_json} \ diff --git a/ingest/workflow/snakemake_rules/fetch_sequences.smk b/ingest/workflow/snakemake_rules/fetch_sequences.smk index c44c4ab..aff8f28 100644 --- a/ingest/workflow/snakemake_rules/fetch_sequences.smk +++ b/ingest/workflow/snakemake_rules/fetch_sequences.smk @@ -23,15 +23,24 @@ rule fetch_from_genbank: genbank_url_url="https://raw.githubusercontent.com/nextstrain/dengue/ca659008bfbe4b3f799e11ecd106a0b95977fe93/ingest/bin/genbank-url", # Update if dengue merged shell: """ - if [[ ! -d bin ]]; then - mkdir bin + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi - cd bin - [[ -f csv-to-ndjson ]] || wget {params.csv_to_ndjson_url} - [[ -f genbank-url ]] || wget {params.genbank_url_url} - [[ -f fetch-from-genbank ]] || wget {params.fetch_from_genbank_url} - chmod 755 * - cd .. + + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/csv-to-ndjson ]] || $download_cmd bin/csv-to-ndjson {params.csv_to_ndjson_url} + [[ -f bin/genbank-url ]] || $download_cmd bin/genbank-url {params.genbank_url_url} + [[ -f bin/fetch-from-genbank ]] || $download_cmd bin/fetch-from-genbank {params.fetch_from_genbank_url} + chmod +x bin/* + + # (3) Fetch the sequences ./bin/fetch-from-genbank {params.serotype_tax_id} > {output.genbank_ndjson} """ diff --git a/ingest/workflow/snakemake_rules/slack_notifications.smk b/ingest/workflow/snakemake_rules/slack_notifications.smk index acf95f3..88ed446 100644 --- a/ingest/workflow/snakemake_rules/slack_notifications.smk +++ b/ingest/workflow/snakemake_rules/slack_notifications.smk @@ -31,16 +31,22 @@ rule notify_on_genbank_record_change: notify_on_record_change_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/notify-on-record-change", shell: """ - if [[ ! -d bin ]]; then - mkdir bin - fi - if [[ ! -f bin/notify-on-record-change ]]; then - cd bin - wget {params.notify_on_record_change_url} - chmod 755 - cd .. + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/notify-on-record-change ]] || $download_cmd bin/notify-on-record-change {params.notify_on_record_change_url} + chmod +x bin/* + + # (3) Run the script ./bin/notify-on-record-change {input.genbank_ndjson} {params.s3_src:q}/genbank.ndjson.xz Genbank """ @@ -55,15 +61,22 @@ rule notify_on_metadata_diff: notify_on_diff_url = "https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/notify-on-diff", shell: """ - if [[ ! -d bin ]]; then - mkdir bin - fi - if [[ ! -f bin/notify-on-diff ]]; then - cd bin - wget {params.notify_on_diff_url} - chmod 755 - cd .. + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi + + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/notify-on-diff ]] || $download_cmd bin/notify-on-diff {params.notify_on_diff_url} + chmod +x bin/* + + # (3) Run the script ./bin/notify-on-diff {input.metadata} {params.s3_src:q}/metadata.tsv.gz """ diff --git a/ingest/workflow/snakemake_rules/transform.smk b/ingest/workflow/snakemake_rules/transform.smk index adfb2a3..0817ece 100644 --- a/ingest/workflow/snakemake_rules/transform.smk +++ b/ingest/workflow/snakemake_rules/transform.smk @@ -20,7 +20,18 @@ rule fetch_general_geolocation_rules: geolocation_rules_url=config["transform"]["geolocation_rules_url"], shell: """ - curl {params.geolocation_rules_url} > {output.general_geolocation_rules} + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 + fi + + # (2) Fetch general geolocation rules + $download_cmd {output.general_geolocation_rules} {params.geolocation_rules_url} """ @@ -73,22 +84,30 @@ rule transform: ndjson_to_tsv_and_fasta_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/ndjson-to-tsv-and-fasta", shell: """ - if [[ ! -d bin ]]; then - mkdir bin + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi - cd bin - [[ -f transform-field-names ]] || wget {params.transform_field_names_url} - [[ -f transform-string-fields ]] || wget {params.transform_string_fields_url} - [[ -f transform-strain-names ]] || wget {params.transform_strain_names_url} - [[ -f transform-date-fields ]] || wget {params.transform_date_fields_url} - [[ -f transform-genbank-location ]] || wget {params.transform_genbank_location_url} - [[ -f transform-authors ]] || wget {params.transform_authors_url} - [[ -f apply-geolocation-rules ]] || wget {params.apply_geolocation_rules_url} - [[ -f merge-user-metadata ]] || wget {params.merge_user_metadata_url} - [[ -f ndjson-to-tsv-and-fasta ]] || wget {params.ndjson_to_tsv_and_fasta_url} - chmod 755 * - cd .. + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/transform-field-names ]] || $download_cmd bin/transform-field-names {params.transform_field_names_url} + [[ -f bin/transform-string-fields ]] || $download_cmd bin/transform-string-fields {params.transform_string_fields_url} + [[ -f bin/transform-strain-names ]] || $download_cmd bin/transform-strain-names {params.transform_strain_names_url} + [[ -f bin/transform-date-fields ]] || $download_cmd bin/transform-date-fields {params.transform_date_fields_url} + [[ -f bin/transform-genbank-location ]] || $download_cmd bin/transform-genbank-location {params.transform_genbank_location_url} + [[ -f bin/transform-authors ]] || $download_cmd bin/transform-authors {params.transform_authors_url} + [[ -f bin/apply-geolocation-rules ]] || $download_cmd bin/apply-geolocation-rules {params.apply_geolocation_rules_url} + [[ -f bin/merge-user-metadata ]] || $download_cmd bin/merge-user-metadata {params.merge_user_metadata_url} + [[ -f bin/ndjson-to-tsv-and-fasta ]] || $download_cmd bin/ndjson-to-tsv-and-fasta {params.ndjson_to_tsv_and_fasta_url} + chmod +x bin/* + + # (3) Transform the sequences (cat {input.sequences_ndjson} \ | ./bin/transform-field-names \ --field-map {params.field_map} \ @@ -131,14 +150,22 @@ rule post_process_metadata: shell: """ - if [[ ! -d bin ]]; then - mkdir bin + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi - cd bin - [[ -f post_process_metadata.py ]] || wget {params.post_process_metadata_url} - chmod 755 * - cd .. + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/post_process_metadata.py ]] || $download_cmd bin/post_process_metadata.py {params.post_process_metadata_url} + chmod +x bin/* + + # (3) Post-process the metadata ./bin/post_process_metadata.py --metadata {input.metadata} --outfile {output.metadata} """ diff --git a/ingest/workflow/snakemake_rules/trigger_rebuild.smk b/ingest/workflow/snakemake_rules/trigger_rebuild.smk index 1a1cade..f6fb5e5 100644 --- a/ingest/workflow/snakemake_rules/trigger_rebuild.smk +++ b/ingest/workflow/snakemake_rules/trigger_rebuild.smk @@ -17,14 +17,21 @@ rule trigger_build: trigger_on_new_data_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/trigger-on-new-data" shell: """ - if [[ ! -d bin ]]; then - mkdir bin - fi - if [[ ! -f bin/trigger-on-new-data ]]; then - cd bin - wget {params.trigger_on_new_data_url} - chmod 755 * - cd .. + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi + + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/trigger-on-new-data ]] || $download_cmd bin/trigger-on-new-data {params.trigger_on_new_data_url} + chmod +x bin/* + + # (3) Trigger the build ./bin/trigger-on-new-data {input.metadata_upload} {input.fasta_upload} """ diff --git a/ingest/workflow/snakemake_rules/upload.smk b/ingest/workflow/snakemake_rules/upload.smk index db2de41..acc4cf8 100644 --- a/ingest/workflow/snakemake_rules/upload.smk +++ b/ingest/workflow/snakemake_rules/upload.smk @@ -59,15 +59,24 @@ rule upload_to_s3: cloudfront_invalidate_url="https://raw.githubusercontent.com/nextstrain/monkeypox/644d07ebe3fa5ded64d27d0964064fb722797c5d/ingest/bin/cloudfront-invalidate" shell: """ - if [[ ! -d bin ]]; then - mkdir bin + # (1) Pick curl or wget based on availability + if which curl > /dev/null; then + download_cmd="curl -fsSL --output" + elif which wget > /dev/null; then + download_cmd="wget -O" + else + echo "ERROR: Neither curl nor wget found. Please install one of them." + exit 1 fi - cd bin - [[ -f upload-to-s3 ]] || wget {params.upload_to_s3_url} - [[ -f sha256sum ]] || wget {params.sha256sum_url} - [[ -f cloudfront-invalidate ]] || wget {params.cloudfront_invalidate_url} - chmod 755 * - cd .. + + # (2) Download the required scripts if not already present + [[ -d bin ]] || mkdir bin + [[ -f bin/upload-to-s3 ]] || $download_cmd bin/upload-to-s3 {params.upload_to_s3_url} + [[ -f bin/sha256sum ]] || $download_cmd bin/sha256sum {params.sha256sum_url} + [[ -f bin/cloudfront-invalidate ]] || $download_cmd bin/cloudfront-invalidate {params.cloudfront_invalidate_url} + chmod +x bin/* + + # (3) Run the upload script ./bin/upload-to-s3 \ {params.quiet} \ {input.file_to_upload:q} \