diff --git a/.gitignore b/.gitignore index 9f56c37d..6012fe8b 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,8 @@ # dependencies /node_modules /node_modules_dev +/node_modules_classic +/node_modules_ang /dev_node_modules /Hantavirus_Testing @@ -62,4 +64,10 @@ slr/* slr_linux.tgz .agignore -.scignore \ No newline at end of file +.scignore + +cypress/screenshots/* +cypress/downloads/* + +# Maven +target/ diff --git a/cypress.config.ts b/cypress.config.ts new file mode 100644 index 00000000..1d09179b --- /dev/null +++ b/cypress.config.ts @@ -0,0 +1,12 @@ +import { defineConfig } from "cypress"; + +export default defineConfig({ + e2e: { + baseUrl: 'http://localhost:4200', // Set your app's base URL + viewportWidth: 1280, + viewportHeight: 720, + setupNodeEvents(on, config) { + // implement node event listeners here + }, + }, +}); diff --git a/cypress/e2e/alignment-plugin.cy.ts b/cypress/e2e/alignment-plugin.cy.ts new file mode 100644 index 00000000..5f5363df --- /dev/null +++ b/cypress/e2e/alignment-plugin.cy.ts @@ -0,0 +1,32 @@ +describe('Alignment View', () => { + const selectors = { + container: '.msa-viewer-container', + settingsBtn: 'a[title="Open Settings"]', + settingsPane: '#alignment-settings-pane', + }; + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); + + cy.contains('button', 'Continue with Sample Dataset', { timeout: 10000 }).click({ force: true }); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Alignment View').click(); + + cy.get(selectors.container, { timeout: 15000 }).should('be.visible'); + }); + + it('renders the alignment viewer with sample data', () => { + cy.get(selectors.container).find('#msa-viewer').should('exist'); + }); + + it('opens and closes the alignment settings', () => { + cy.get(selectors.settingsBtn).click(); + cy.get(selectors.settingsPane, { timeout: 10000 }).should('be.visible'); + + cy.get(selectors.settingsPane).find('.p-dialog-header-icon').click({ force: true }); + cy.get(selectors.settingsPane).should('not.be.visible'); + }); + }); \ No newline at end of file diff --git a/cypress/e2e/bubble-plugin.cy.ts b/cypress/e2e/bubble-plugin.cy.ts new file mode 100644 index 00000000..fd057ef9 --- /dev/null +++ b/cypress/e2e/bubble-plugin.cy.ts @@ -0,0 +1,32 @@ +describe('Bubble View', () => { + const selectors = { + container: '#cyBubble', + settingsBtn: 'a[title="Open Settings"]', + settingsPane: '.p-dialog-header:contains("Bubble Settings")', + }; + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); + + cy.contains('button', 'Continue with Sample Dataset', { timeout: 10000 }).click({ force: true }); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Bubble').click(); + + cy.get(selectors.container, { timeout: 15000 }).should('be.visible'); + }); + + it('renders bubble view canvas', () => { + cy.get(selectors.container).should('exist'); + }); + + it('opens and closes the bubble settings dialog', () => { + cy.get(selectors.settingsBtn).click(); + cy.contains('div.p-dialog', 'Bubble Settings', { timeout: 10000 }).should('be.visible'); + + cy.contains('div.p-dialog', 'Bubble Settings').find('.p-dialog-header-icon').click({ force: true }); + cy.contains('div.p-dialog', 'Bubble Settings').should('not.be.visible'); + }); + }); \ No newline at end of file diff --git a/cypress/e2e/files-plugin.cy.ts b/cypress/e2e/files-plugin.cy.ts new file mode 100644 index 00000000..5f94092f --- /dev/null +++ b/cypress/e2e/files-plugin.cy.ts @@ -0,0 +1,191 @@ +// cypress/e2e/files-plugin.cy.ts +/// + +describe('File Handling and Processing', () => { + const nodeFile = 'AngularTesting_nodelist_withseqs_TN93_BS.csv'; + const linkFile = 'AngularTesting_Epi_linklist_BS.csv'; + + beforeEach(() => { + cy.visit('/'); + // The initial wait is to allow the default session to load, + // which we will clear by uploading our own file. + cy.wait(2000); + }); + + it('uploads multiple files and then sets the datatype and the fields', () => { + // mostly an example of this function + cy.loadFiles([ + {name: 'AngularTesting_DistanceMatrix_TN93_BS.xlsx', datatype: 'matrix'}, + {name: 'AngularTesting_seqs_TN93_BS.fasta', datatype: 'fasta'}, + {name: 'AngularTesting_nodes_Map.csv', datatype: 'node', field1: 'seq', field2: '_id'} + ]) + }) + + it('uploads a single node list, auto-configures it, and enables launch', () => { + // Upload the file from the overlay + cy.attach_file('#fileDropRef', nodeFile); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // Assert the file row is visible + cy.contains('#file-table .file-table-row', nodeFile).should('be.visible'); + cy.get('#launch').should('not.be.disabled'); + + // Assert file type is auto-detected as "Node" + cy.contains('.file-table-row', nodeFile).find('input[data-type="node"]').should('be.checked'); + + // Use attribute selector to handle special characters in the ID + cy.get(`[id="file-${nodeFile}-field-1"]`).should('have.value', '_id'); + cy.get(`[id="file-${nodeFile}-field-2"]`).should('have.value', 'seq'); + }); + + it('updates column mapping labels when file type is changed manually', () => { + cy.attach_file('#fileDropRef', nodeFile); + + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // Initial state: Node - We re-query the row for each assertion for robustness. + cy.contains('#file-table .file-table-row', nodeFile) + .find('label').contains('ID').should('be.visible'); + cy.contains('#file-table .file-table-row', nodeFile) + .find('label').contains('Sequence').should('be.visible'); + cy.contains('#file-table .file-table-row', nodeFile) + .find('label:contains("Distance")').parent().should('not.be.visible'); + + // Change to Link type + cy.contains('#file-table .file-table-row', nodeFile) + .find('input[data-type="link"]').click({ force: true }); + + // Assert labels changed + cy.contains('#file-table .file-table-row', nodeFile) + .find('label').contains('Source').should('be.visible'); + cy.contains('#file-table .file-table-row', nodeFile) + .find('label').contains('Target').should('be.visible'); + cy.contains('#file-table .file-table-row', nodeFile) + .find('label').contains('Distance').should('be.visible'); + cy.contains('#file-table .file-table-row', nodeFile) + .find('label:contains("Sequence")').should('not.exist'); + }); + + it('allows a file to be removed', () => { + cy.attach_file('#fileDropRef', nodeFile); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // Ensure the file row exists + cy.contains('#file-table .file-table-row', nodeFile).should('be.visible'); + + // Click the remove button + cy.contains('.file-table-row', nodeFile).find('.flaticon-delete-1').click(); + + // Assert the file row is gone and the prompt is back + cy.contains('#file-table .file-table-row', nodeFile).should('not.exist'); + cy.get('#file-prompt').should('be.visible'); + }); + + it('opens and closes the sequence controls modal', () => { + cy.attach_file('#fileDropRef', nodeFile); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // The p-dialog component exists in the DOM but isn't visible + cy.get('#sequence-controls-modal').should('not.be.visible'); + + // Click button to open sequence controls + cy.contains('button', 'Sequence Controls').click(); + + // Assert that content inside the modal is now visible + cy.get('#sequence-controls-modal').contains('Alignment').should('be.visible'); + + // Click the "Confirm" button to close it + cy.get('#sequence-controls-modal').contains('button', 'Confirm').click(); + cy.get('#sequence-controls-modal').should('not.be.visible'); + }); + + it('opens and closes the file settings modal', () => { + cy.attach_file('#fileDropRef', nodeFile); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // Modal should not be visible initially + cy.get('#file-settings-pane').should('not.be.visible'); + + // Click the settings icon to open the modal + cy.get('a[title="Settings"]').click(); + cy.get('#file-settings-pane').contains('Distance Metric').should('be.visible'); + + // **FIX**: Target the clickable button, not the inner icon span + cy.get('#file-settings-pane').find('button.p-dialog-close-button').click(); + + cy.get('#file-settings-pane').should('not.be.visible'); + }); + + + it('launches a network from separate node and link lists', () => { + cy.attach_file('#fileDropRef', nodeFile); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.attach_file('#data-files1', linkFile); // Use the "Add File(s)" button + + cy.get('#launch').click(); + cy.get('.lm_tab.lm_active', { timeout: 20000 }).should('contain.text', '2D Network'); + + cy.window().its('commonService.session.data.nodes').should('have.length', 14); + cy.window().its('commonService.session.data.links').should('have.length.greaterThan', 0); + + // Verify data from both files was merged + cy.window().then((win) => { + const node = win.commonService.session.data.nodes.find(n => n._id === 'KF773425'); + expect(node.subtype).to.equal('C'); + + const link = win.commonService.session.data.links.find(l => + (l.source === 'KF773571' && l.target === 'KF773578') + ); + expect(link.Contact).to.equal('Bar'); + }); + }); +}); + +describe('Files Plugin - Settings', () => { + const nodeFile = 'AngularTesting_nodelist_withseqs_TN93_small (2).csv'; + + beforeEach(() => { + cy.visit('/'); + cy.wait(2000);  + cy.attach_file('#fileDropRef', nodeFile); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + cy.get('#tool-btn-container a[title="Settings"]').click(); + }); + + it('should change the Distance Metric and update the session', () => { + cy.window().its('commonService.session.style.widgets.default-distance-metric').should('equal', 'snps'); + cy.get('#default-distance-metric').select('tn93'); + cy.window().its('commonService.session.style.widgets.default-distance-metric').should('equal', 'tn93'); + }); + + it('should change the Ambiguity Resolution Strategy and update the session', () => { + cy.window().its('commonService.session.style.widgets.ambiguity-resolution-strategy').should('equal', 'AVERAGE'); + cy.get('#default-distance-metric').select('tn93'); + cy.get('#ambiguity-resolution-strategy').select('RESOLVE'); + cy.window().its('commonService.session.style.widgets.ambiguity-resolution-strategy').should('equal', 'RESOLVE'); + }); + +// it('should show and update the Ambiguity Threshold when strategy is RESOLVE', () => { +// const newThreshold = '0.025'; +// cy.get('#ambiguity-threshold-row').should('not.be.visible'); +// cy.get('#ambiguity-resolution-strategy').select('RESOLVE'); +// cy.get('#ambiguity-threshold-row').should('be.visible'); +// cy.get('#ambiguity-threshold').clear().type(newThreshold); +// cy.window().its('commonService.session.style.widgets.ambiguity-threshold').should('equal', parseFloat(newThreshold)); +// }); + + it('should change the Link Threshold and update the session', () => { + const newThreshold = '4'; + // snps initally + cy.window().its('commonService.session.style.widgets.link-threshold').should('equal', 164); + cy.get('#default-distance-threshold').clear().type(newThreshold); + cy.window().its('commonService.session.style.widgets.link-threshold').should('equal', parseFloat(newThreshold)); + }); + + it('should change the View to Launch and update the session', () => { + cy.window().its('commonService.session.style.widgets.default-view').should('equal', '2d_network'); + cy.get('#default-view').select('Table'); + cy.window().its('commonService.session.style.widgets.default-view').should('equal', 'Table'); + }); +}); \ No newline at end of file diff --git a/cypress/e2e/journeys/datasets/profile.ts b/cypress/e2e/journeys/datasets/profile.ts new file mode 100644 index 00000000..6ce2062a --- /dev/null +++ b/cypress/e2e/journeys/datasets/profile.ts @@ -0,0 +1,39 @@ +// cypress/e2e/journeys/datasets/profile.ts +// Central registry for dataset profiles used by journey tests. +// Re-export types so flows can keep importing from this file. + +export * from './types'; + +import type { DatasetProfile } from './types'; + +import { NN_PROFILES } from './profiles/nn'; +import { STYLE_PROFILES } from './profiles/style'; +import { GROUPING_PROFILES } from './profiles/grouping'; + +export const DATASET_PROFILES: DatasetProfile[] = [ + ...NN_PROFILES, + ...STYLE_PROFILES, + ...GROUPING_PROFILES, +]; + +export const DATASET_PROFILE_MAP: Record = DATASET_PROFILES + .reduce((acc, p) => { + acc[p.id] = p; + return acc; + }, {} as Record); + +export function getProfile(id: string): DatasetProfile { + const p = DATASET_PROFILE_MAP[id]; + if (!p) { + throw new Error(`Unknown dataset profile id: ${id}`); + } + return p; +} + +export function getProfilesByTag(tag: string): DatasetProfile[] { + return DATASET_PROFILES.filter(p => p.tags.includes(tag)); +} + +export function getProfilesByTags(tags: string[]): DatasetProfile[] { + return DATASET_PROFILES.filter(p => tags.every(t => p.tags.includes(t))); +} diff --git a/cypress/e2e/journeys/datasets/profiles/color-by.ts b/cypress/e2e/journeys/datasets/profiles/color-by.ts new file mode 100644 index 00000000..e69de29b diff --git a/cypress/e2e/journeys/datasets/profiles/grouping.ts b/cypress/e2e/journeys/datasets/profiles/grouping.ts new file mode 100644 index 00000000..f90b9889 --- /dev/null +++ b/cypress/e2e/journeys/datasets/profiles/grouping.ts @@ -0,0 +1,76 @@ +// cypress/e2e/journeys/datasets/profiles/grouping.ts +import type { DatasetProfile } from '../types'; +import { P } from '../types'; + +export const GROUPING_PROFILES: DatasetProfile[] = [ + P({ + id: 'grouping-basic-tn93-epi-linklist-cluster', + title: 'Grouping (basic): Epi link list → group by Cluster (default)', + tags: ['grouping', 'grouping-basic', 'cluster', 'tn93', 'epi'], + files: [ + { + name: 'AngularTesting_Epi_linklist_BS.csv', + datatype: 'link', + field1: 'source', + field2: 'target', + }, + ], + preLaunch: { + metric: 'tn93', + threshold: 0.015, + defaultView: '2D Network', + }, + expectations: { + afterLaunch: { + nodes: 10, + visibleLinks: 7, + clusters: 3, + singletons: 0, + }, + grouping: { + groupBy: 'Cluster', + showGroups: true, + showGroupColors: false, + showGroupLabels: false, + + expectedGroups: { + '2': ['KF773429', 'KF773432', 'KF773430'], + '1': ['KF773576', 'KF773579'], + '0': ['KF773427', 'KF773425', 'KF773426', 'KF773578', 'KF773571'], + }, + }, + }, + }), + + P({ + id: 'grouping-tn93-polygons-subtype', + title: 'Grouping: TN93 polygons grouped by Subtype, colors + labels, threshold change does not break polygons', + tags: ['grouping', 'polygons', 'tn93'], + files: [ + { name: 'AngularTesting_DistanceMatrix_TN93_BS.xlsx', datatype: 'matrix' }, + { name: 'AngularTesting_nodelist_withseqs_TN93_BS.csv', datatype: 'node' }, + ], + preLaunch: { + metric: 'tn93', + threshold: 0.015, + defaultView: '2D Network', + }, + expectations: { + grouping: { + groupBy: 'Subtype', + showGroups: true, + showGroupColors: true, + showGroupLabels: true, + changeGroupColors: { + groups: ['B', 'D'], + }, + thresholdChange: { + from: 0.015, + to: 0.010, + expectedVisibleLinksAfter: 9, + expectPolygonsUnchanged: true, + }, + }, + }, + }), +]; diff --git a/cypress/e2e/journeys/datasets/profiles/nn.ts b/cypress/e2e/journeys/datasets/profiles/nn.ts new file mode 100644 index 00000000..1a1e47f6 --- /dev/null +++ b/cypress/e2e/journeys/datasets/profiles/nn.ts @@ -0,0 +1,80 @@ +// cypress/e2e/journeys/datasets/profiles/nn.ts +import type { DatasetProfile } from '../types'; +import { P } from '../types'; + +export const NN_PROFILES: DatasetProfile[] = [ + P({ + id: 'nn-snps16-edgelist', + title: 'NN: SNPs=16 via distance edgelist', + tags: ['nn', 'snps', 'edgelist'], + files: [ + { + name: 'COVID_Dummy_distance_edgelist_snp.csv', + datatype: 'link', + field1: 'source', + field2: 'target', + field3: 'distance', + }, + ], + preLaunch: { + metric: 'snps', + threshold: 16, + defaultView: '2D Network', + }, + expectations: { + nn: { + labelLinksWith: 'distance', + before: { visibleLinks: 11 }, + after: { visibleLinks: 7 }, + }, + }, + }), + + P({ + id: 'nn-snps16-matrix', + title: 'NN: SNPs=16 via distance matrix', + tags: ['nn', 'snps', 'matrix'], + files: [ + { + name: 'AngularTesting_DistanceMatrix_TN93_BS.xlsx', + datatype: 'matrix', + }, + ], + preLaunch: { + metric: 'snps', + threshold: 16, + defaultView: '2D Network', + }, + expectations: { + nn: { + labelLinksWith: 'distance', + before: { visibleLinks: 11 }, + after: { visibleLinks: 7 }, + }, + }, + }), + + P({ + id: 'nn-snps16-fasta', + title: 'NN: SNPs=16 via FASTA', + tags: ['nn', 'snps', 'fasta'], + files: [ + { + name: 'SARSCoV2_Simulated_Sequences_snp.fas', + datatype: 'fasta', + }, + ], + preLaunch: { + metric: 'snps', + threshold: 16, + defaultView: '2D Network', + }, + expectations: { + nn: { + labelLinksWith: 'distance', + before: { visibleLinks: 11 }, + after: { visibleLinks: 7 }, + }, + }, + }), +]; diff --git a/cypress/e2e/journeys/datasets/profiles/style.ts b/cypress/e2e/journeys/datasets/profiles/style.ts new file mode 100644 index 00000000..161bb019 --- /dev/null +++ b/cypress/e2e/journeys/datasets/profiles/style.ts @@ -0,0 +1,37 @@ +// cypress/e2e/journeys/datasets/profiles/style.ts +import type { DatasetProfile } from '../types'; +import { P } from '../types'; + +export const STYLE_PROFILES: DatasetProfile[] = [ + P({ + id: 'style-apply-cypress-test-style', + title: 'Apply Style: nodes colored by profession, shaped by NodeType, sized by degree; links colored by contact type', + tags: ['style', 'apply-style'], + files: [ + { name: 'TestStyleNodelist_snp.csv', datatype: 'node' }, + { name: 'TestStyleEdgelist_snp.csv', datatype: 'link', field1: 'source', field2: 'target', field3: 'distance' }, + ], + preLaunch: { + metric: 'snps', + threshold: 16, + defaultView: '2D Network', + }, + expectations: { + applyStyle: { + styleFile: 'Cypress_Test_Style.style', + expectWidgets: { + nodeColorVariable: 'profession', + nodeSymbolVariable: 'NodeType', + nodeRadiusVariable: 'degree', + linkColorVariable: 'Contact', + }, + expectTables: { + nodeColorTable: true, + nodeSymbolTable: true, + linkColorTable: true, + nodeSizeTable: false, + }, + }, + }, + }), +]; diff --git a/cypress/e2e/journeys/datasets/types.ts b/cypress/e2e/journeys/datasets/types.ts new file mode 100644 index 00000000..ce976571 --- /dev/null +++ b/cypress/e2e/journeys/datasets/types.ts @@ -0,0 +1,107 @@ +// cypress/e2e/journeys/datasets/types.ts + +export type DistanceMetric = 'tn93' | 'snps'; + +export type DefaultView = + | '2D Network' + | 'Table' + | 'Map' + | 'Phylogenetic Tree' + | 'Alignment View'; + +export type FileDatatype = + | 'link' + | 'node' + | 'matrix' + | 'fasta' + | 'newick' + | 'MT/other'; + +export type PruneWith = 'None' | 'Nearest Neighbor'; + +export type LinkLabelVariable = 'None' | 'distance'; +export type GroupByVariable = 'None' | 'Cluster' | 'Subtype'; + +export type FileLoadSpec = { + name: string; + datatype: FileDatatype; + field1?: string; + field2?: string; + field3?: string; +}; + +export type PreLaunchSettings = { + metric: DistanceMetric; + threshold: number; + defaultView?: DefaultView; +}; + +export type ExpectedCounts = { + nodes?: number; + visibleLinks?: number; + clusters?: number; + singletons?: number; +}; + +export type JourneyExpectations = { + afterLaunch?: ExpectedCounts; + + nn?: { + before: { visibleLinks: number }; + after: { visibleLinks: number }; + }; + + applyStyle?: { + styleFile: string; + expectWidgets: { + nodeColorVariable?: string; + nodeSymbolVariable?: string; + nodeRadiusVariable?: string; + linkColorVariable?: string; + }; + expectTables: { + nodeColorTable: boolean; + nodeSymbolTable: boolean; + linkColorTable: boolean; + nodeSizeTable: boolean; + }; + }; + + grouping?: { + groupBy: GroupByVariable; + showGroups: boolean; + showGroupColors: boolean; + showGroupLabels: boolean; + + /** + * Explicit membership expectations: + * key is the group label (cluster id or subtype, etc). + * The parent cytoscape id might be either '' or `group-` depending on the code path. + */ + expectedGroups?: Record; + + thresholdChange?: { + from: number; + to: number; + expectedVisibleLinksAfter: number; + expectPolygonsUnchanged: boolean; + }; + + changeGroupColors?: { + groups: string[]; + }; + }; + + +}; + +export type DatasetProfile = { + id: string; + title: string; + tags: string[]; + files: FileLoadSpec[]; + preLaunch: PreLaunchSettings; + expectations: JourneyExpectations; +}; + +export const P = (profile: DatasetProfile): DatasetProfile => profile; diff --git a/cypress/e2e/journeys/flows/change-link-color.cy.ts b/cypress/e2e/journeys/flows/change-link-color.cy.ts new file mode 100644 index 00000000..e69de29b diff --git a/cypress/e2e/journeys/flows/change-link-threshold.cy.ts b/cypress/e2e/journeys/flows/change-link-threshold.cy.ts new file mode 100644 index 00000000..e69de29b diff --git a/cypress/e2e/journeys/flows/change-node-color.cy.ts b/cypress/e2e/journeys/flows/change-node-color.cy.ts new file mode 100644 index 00000000..e69de29b diff --git a/cypress/e2e/journeys/flows/grouping-basic-cluster.cy.ts b/cypress/e2e/journeys/flows/grouping-basic-cluster.cy.ts new file mode 100644 index 00000000..f2d36544 --- /dev/null +++ b/cypress/e2e/journeys/flows/grouping-basic-cluster.cy.ts @@ -0,0 +1,44 @@ +/// + +import { getProfilesByTag } from '../datasets/profile'; +import type { DatasetProfile } from '../datasets/profile'; + +import { + visitAppAndAcceptEula, + launchAndWaitForProcessing, + goTo2DNetworkView, + assertAfterLaunchCounts, + enableGroupingShow, + assertGroupedByCluster, + applyPreLaunchSessionSettings, + applyTwoDGroupingFromProfile, + assertGroupingMembershipFromProfile +} from '../../../support/journey-helpers'; + +describe('Journey Flow - Grouping (basic) - Cluster', () => { + const profiles = getProfilesByTag('grouping-basic'); + + profiles.forEach((profile: DatasetProfile) => { + it(profile.title, () => { + visitAppAndAcceptEula(); + + cy.loadFiles(profile.files); + + applyPreLaunchSessionSettings(profile); + + launchAndWaitForProcessing(60000); + + goTo2DNetworkView(); + + assertAfterLaunchCounts(profile); + + // Either keep the old explicit calls... + enableGroupingShow('cluster'); + assertGroupedByCluster(); + assertGroupingMembershipFromProfile(profile); + + // ...or let the profile drive grouping behavior (including colors/labels): + // applyTwoDGroupingFromProfile(profile); + }); + }); +}); diff --git a/cypress/e2e/journeys/flows/nearest-neighbor.cs.ts b/cypress/e2e/journeys/flows/nearest-neighbor.cs.ts new file mode 100644 index 00000000..e69de29b diff --git a/cypress/e2e/journeys/flows/show-node-symbols.cy.ts b/cypress/e2e/journeys/flows/show-node-symbols.cy.ts new file mode 100644 index 00000000..e69de29b diff --git a/cypress/e2e/journeys/flows/upload-launch-twod.cy.ts b/cypress/e2e/journeys/flows/upload-launch-twod.cy.ts new file mode 100644 index 00000000..c56757bb --- /dev/null +++ b/cypress/e2e/journeys/flows/upload-launch-twod.cy.ts @@ -0,0 +1,121 @@ +/// + +import { Core } from 'cytoscape'; + +type WinWithMT = Window & { + commonService: any; + cytoscapeInstance?: Core; + Cypress: any; +}; + +const FIXTURE_LINKLIST = 'AngularTesting_Distance_linklist_BS.csv'; + +const acceptEulaIfPresent = () => { + cy.get('body', { log: false }).then($body => { + const hasEula = + $body.find('.p-dialog-title:contains("License Agreement")').length > 0; + + if (!hasEula) return; + + cy.contains('.p-dialog-title', 'License Agreement') + .parents('.p-dialog') + .within(() => { + cy.contains('button', 'Accept').click({ force: true }); + }); + + cy.contains('.p-dialog-title', 'License Agreement').should('not.exist'); + }); +}; + +describe('Journey - upload -> launch -> 2D Network', () => { + beforeEach(() => { + cy.visit('/'); + cy.get('#fileDropRef', { timeout: 15000 }).should('exist'); + acceptEulaIfPresent(); + }); + + it('uploads a link list fixture, launches, and renders the 2D Network Cytoscape view', () => { + // Upload via overlay + cy.attach_file('#fileDropRef', FIXTURE_LINKLIST); + acceptEulaIfPresent(); + + cy.get('#overlay').should('not.be.visible', { timeout: 15000 }); + + // Ensure file registered + launch enabled + cy.contains('#file-table .file-table-row', FIXTURE_LINKLIST, { timeout: 15000 }) + .should('be.visible'); + + cy.get('#launch', { timeout: 15000 }).should('not.be.disabled'); + + // Launch processing + cy.get('#launch').click({ force: true }); + + // Wait for processing to finish (if modal is used) + cy.get('#loading-information', { timeout: 60000 }).should('not.exist'); + + // Confirm data exists in the session model (independent of which view auto-opens) + cy.window({ timeout: 60000 }).its('commonService').then((cs: any) => { + expect(cs.session.data.nodes.length, 'nodes loaded').to.be.greaterThan(0); + expect(cs.session.data.links.length, 'links loaded').to.be.greaterThan(0); + }); + + // Ensure we are in 2D Network view (do not depend on cached default-view) + // cy.contains('button', 'View').click({ force: true }); + // cy.contains('button[mat-menu-item]', '2D Network').click({ force: true }); + + // Wait for Cytoscape + stats to render + // cy.waitForNetworkToRender(60000); + cy.window({ timeout: 15000 }).should('have.property', 'cytoscapeInstance'); + + cy.get('#cy', { timeout: 15000 }).should('be.visible'); + cy.get('#cy').find('canvas').should('exist'); + + // Assert Cytoscape has elements + cy.window().then((win: unknown) => { + const w = win as WinWithMT; + const cyInstance = w.cytoscapeInstance as Core; + + expect(cyInstance, 'cytoscapeInstance').to.exist; + + const nodeCount = cyInstance.nodes().length; + const edgeCount = cyInstance.edges().length; + + expect(nodeCount, 'Cytoscape nodes').to.be.greaterThan(0); + expect(edgeCount, 'Cytoscape edges').to.be.greaterThan(0); + }); + + // Sanity interaction: drag a safe node via the harness and verify model + geometry sync + // cy.window().then((win: unknown) => { + // const w = win as WinWithMT; + // const cyInstance = w.cytoscapeInstance as Core; + + // const candidate = cyInstance.nodes() + // .toArray() + // .find(n => n.children().length === 0 && !n.hasClass('parent') && !n.hasClass('hidden')); + + // expect(candidate, 'draggable node candidate').to.exist; + + // const node = candidate!; + // const nodeId = node.id(); + // const initial = { ...node.position() }; + + // expect(w.Cypress?.test?.dragNodeDelta, 'TwoD drag harness').to.be.a('function'); + + // const after = w.Cypress.test.dragNodeDelta(nodeId, 25, 10); + // expect(after, 'drag helper returned a position').to.not.be.null; + + // const cyNodeAfter = cyInstance.getElementById(nodeId); + // expect(cyNodeAfter.empty(), `node ${nodeId} still exists`).to.be.false; + + // const posAfter = cyNodeAfter.position(); + // expect(posAfter.x, 'geometry X').to.be.closeTo(initial.x + 25, 2); + // expect(posAfter.y, 'geometry Y').to.be.closeTo(initial.y + 10, 2); + + // const backing = w.commonService.session.data.nodes.find((n: any) => (n._id || n.id) === nodeId); + // expect(backing, 'backing node in session.data.nodes').to.exist; + + // expect(backing.x, 'model X').to.be.closeTo(posAfter.x, 2); + // expect(backing.y, 'model Y').to.be.closeTo(posAfter.y, 2); + // }); + }); +}); diff --git a/cypress/e2e/map-plugin.cy.ts b/cypress/e2e/map-plugin.cy.ts new file mode 100644 index 00000000..6c36eafb --- /dev/null +++ b/cypress/e2e/map-plugin.cy.ts @@ -0,0 +1,1005 @@ +/// + +import * as L from 'leaflet'; +const takeScreenshots: boolean = false; + +/** + * Tests for the Map visualization component. + */ +describe('Map View', () => { + // Selectors for key elements in the Phylogenetic Tree component + const selectors = { + mapContainer: '.mapStyle', + settingsBtn: '#tool-btn-container-map a[title="Settings"]', + }; + + /** + * This block runs before each test. It loads the application, + * continues with the sample dataset, and navigates to the view. + */ + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); // Allow for initial application bootstrap + + cy.get('button:contains("Continue with Sample Dataset")', { timeout: 10000 }) + .click({ force: true }); + + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // Open the "View" menu and click on "Map" + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Map').click(); + + // Wait for the map container to be visible, indicating the view has loaded + cy.get(selectors.mapContainer, { timeout: 15000 }).should('be.visible'); + }); + + /** + * Test suite for toolbar and settings pane interactions. + */ + context('Map Settings and Interactions (Default Dataset)', () => { + beforeEach(() => { + // Open the settings pane + cy.get(selectors.settingsBtn).click(); + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + cy.wait(2000) + + cy.get('#map-field-zipcode').click(); + cy.contains('li[role="option"]', 'Zipcode').click(); + + cy.contains('.p-dialog-title', 'Excluded Nodes').parents('.p-dialog').find('button.p-dialog-close-button').click({force: true}); + cy.contains('.p-dialog-title', 'Excluded Nodes').should('not.exist'); + + cy.get('#tool-btn-container-map a[title="Center Screen"]').click(); + cy.wait(250); + }); + + // Zipcode selection renders nodes on map + it('should confirm zip code variable and close the settings pane', () => { + cy.window().its('commonService.session.style.widgets.map-field-zipcode').should('equal', 'Zip_code'); + cy.closeSettingsPane('Geospatial Settings'); + }); + + // Toggle Collapsing Nodes + it('should toggle Collapsing Nodes', () => { + // initial values + cy.window().its('commonService.visuals.gisMap.SelectedNodeCollapsingTypeVariable').should('equal', 'On') + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').should(layers => { + expect(Object.keys(layers)).to.have.length(7); + }); + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers').should(layers => { + expect(Object.keys(layers)).to.have.length(0); + }); + + // switch tabs and uncollapse + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + cy.get('#map-node-collapsing').contains('Off').click() + cy.wait(100); + cy.window().its('commonService.visuals.gisMap.SelectedNodeCollapsingTypeVariable').should('equal', 'Off') + + // recheck values + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').should(layers => { + expect(Object.keys(layers)).to.have.length(0); + }); + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers').should(layers => { + expect(Object.keys(layers)).to.have.length(30); + }); + + cy.closeSettingsPane('Geospatial Settings'); + // cy.get('#tool-btn-container-map a[title="Center Screen"]').click(); + if (takeScreenshots) cy.screenshot('map/node-not-collapsed', { overwrite: true}); + cy.wait(100) + + // Open the settings pane + cy.get(selectors.settingsBtn).click(); + + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + + // Collapse and check values + cy.get('#map-node-collapsing').contains('On').click() + cy.wait(100); + cy.window().its('commonService.visuals.gisMap.SelectedNodeCollapsingTypeVariable').should('equal', 'On') + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').should(layers => { + expect(Object.keys(layers)).to.have.length(7); + }); + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers').should(layers => { + expect(Object.keys(layers)).to.have.length(0); + }); + + cy.closeSettingsPane('Geospatial Settings'); + if (takeScreenshots) cy.screenshot('map/node-collapsed', { overwrite: true}); + }) + + // Map transparency should scale with slider bar + it('should update transparency of nodes', () => { + // switch tabs + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + + cy.get('#map-node-collapsing').contains('Off').click() + cy.window().its('commonService.visuals.gisMap.SelectedNodeCollapsingTypeVariable').should('equal', 'Off') + cy.wait(100); + + cy.window().its('commonService.session.style.widgets.map-node-transparency').should('equal', 0); + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers').should(layers => { + Object.values(layers).forEach((layer: any) => { + expect(layer.options.fillOpacity).to.equal(1) + }) + }); + + const updatedTransparency = 0.75; + cy.get('#map-node-transparency').invoke('val', updatedTransparency).trigger('input').trigger('change'); + cy.window().its('commonService.session.style.widgets.map-node-transparency').should('equal', updatedTransparency); + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers').should(layers => { + Object.values(layers).forEach((layer: any) => { + expect(layer.options.fillOpacity).to.equal(1-updatedTransparency) + }) + }); + cy.closeSettingsPane('Geospatial Settings'); + if (takeScreenshots) cy.screenshot('map/node-transparency', { overwrite: true}); + }) + + it('should update transparency of links', () => { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Links').click() + cy.window().its('commonService.session.style.widgets.map-link-transparency').should('equal', 0); + + cy.window().its('commonService.visuals.gisMap.layers.links._layers').should(layers => { + Object.values(layers).forEach((layer: any) => { + expect(layer.options.opacity).to.equal(1) + }) + }); + + const updatedTransparency = 0.75; + cy.get('#map-link-transparency').invoke('val', updatedTransparency).trigger('input').trigger('change'); + cy.window().its('commonService.session.style.widgets.map-link-transparency').should('equal', updatedTransparency); + cy.window().its('commonService.visuals.gisMap.layers.links._layers').should(layers => { + Object.values(layers).forEach((layer: any) => { + expect(layer.options.opacity).to.equal(1-updatedTransparency) + }) + }); + + cy.closeSettingsPane('Geospatial Settings'); + if (takeScreenshots) cy.screenshot('map/link-transparency', { overwrite: true}); + }) + + // hide all nodes + it('should hide all nodes', () => { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Components').click() + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Network').click(); + cy.get('#map-node-show-hide').contains('Hide').click(); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(10); + if (takeScreenshots) cy.screenshot('map/no-nodes', { overwrite: true}); + + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').should(layers => { + expect(layers).to.be.empty; + }) + }) + + // hide all links + it('should hide all links', () => { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Components').click() + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Network').click(); + cy.get('#map-link-show-hide').contains('Hide').click(); + + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(10); + if (takeScreenshots) cy.screenshot('map/no-links', { overwrite: true}); + + cy.window().its('commonService.visuals.gisMap.lmap._layers').should(layers => { + expect(Object.values(layers).length).to.equal(249); + }) + }) + + // jitter and re-jitter + it('should jitter and re-jiter the nodes', () => { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + + const updatedJitter = 1.6; + cy.get('#map-node-jitter').invoke('val', updatedJitter).trigger('input').trigger('change'); + cy.window().its('commonService.session.style.widgets.map-node-jitter').should('equal', updatedJitter); + + let theta: number, j: number; + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').then(layers => { + Object.values(layers).forEach((layer: any) => { + if (layer.data && layer.data.ID === 'MZ375596') { + theta = layer.data._theta; + j = layer.data._j + } + }); + }) + + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(10); + if (takeScreenshots) cy.screenshot('map/jitter', { overwrite: true}); + cy.wait(100); + + cy.get(selectors.settingsBtn).click(); + cy.get('#map-node-jitter-reroll').click(); + + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').should(layers => { + Object.values(layers).forEach((layer: any) => { + if (layer.data && layer.data.ID === 'MZ375596') { + expect(layer.data._theta).to.not.equal(theta) + expect(layer.data._j).to.not.equal(j); + } + }); + }) + + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(10); + if (takeScreenshots) cy.screenshot('map/jitter-2', { overwrite: true}); + }) + + // showing base layer, after time to download tile, should render higher resolution map + it('should test offline maps', () => { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Components').click() + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Online').click(); + cy.get('#map-basemap-show-hide').contains('Hide').click(); + + cy.window().its('commonService.session.style.widgets.map-satellite-show').should('equal', false); + cy.window().its('commonService.session.style.widgets.map-basemap-show').should('equal', false); + cy.window().its('commonService.session.style.widgets.map-countries-show').should('equal', true); + cy.window().its('commonService.session.style.widgets.map-states-show').should('equal', true); + cy.window().its('commonService.session.style.widgets.map-counties-show').should('equal', false); + + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Offline').click(); + cy.get('#map-counties-show-hide').contains('Show').click(); + cy.window().its('commonService.session.style.widgets.map-counties-show').should('equal', true); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(1000) + if (takeScreenshots) cy.screenshot('map/map-counties', { overwrite: true}); + cy.wait(100) + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.counties)).to.equal(true) + }); + + cy.get(selectors.settingsBtn).click(); + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + cy.get('#map-counties-show-hide').contains('Hide').click(); + cy.window().its('commonService.session.style.widgets.map-counties-show').should('equal', false); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(200) + if (takeScreenshots) cy.screenshot('map/map-states', { overwrite: true}); + cy.wait(100) + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.counties)).to.equal(false) + expect(mapView.lmap.hasLayer(mapView.layers.states)).to.equal(true) + }); + + cy.get(selectors.settingsBtn).click(); + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + cy.get('#map-states-show-hide').contains('Show').click(); + cy.window().its('commonService.session.style.widgets.map-states-show').should('equal', false); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(200) + if (takeScreenshots) cy.screenshot('map/map-countries', { overwrite: true}); + cy.wait(100) + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.states)).to.equal(false) + expect(mapView.lmap.hasLayer(mapView.layers.countries)).to.equal(true) + }); + }) + + // showing basemap layer, after time to download time + it('should test base map', () => { + cy.window().its('commonService.session.style.widgets.map-basemap-show').should('equal', false); + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Components').click() + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Online').click(); //map-satellite-show-hide + cy.get('#map-basemap-show-hide').contains('Show').click(); + cy.window().its('commonService.session.style.widgets.map-basemap-show').should('equal', true); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(2000) + if (takeScreenshots) cy.screenshot('map/map-basemap', { overwrite: true}); + cy.wait(100) + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.basemap)).to.equal(true) + }); + }) + + // showing satellite layer, after time to download time, should render higher resolution map + it('should test satellite map', () => { + cy.window().its('commonService.session.style.widgets.map-satellite-show').should('equal', false); + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Components').click() + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Online').click(); //map-satellite-show-hide + cy.get('#map-satellite-show-hide').contains('Show').click(); + cy.window().its('commonService.session.style.widgets.map-satellite-show').should('equal', true); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(2000) + if (takeScreenshots) cy.screenshot('map/map-sattellite', { overwrite: true}); + cy.wait(100) + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.satellite)).to.equal(true) + }); + }) + + // make a test for dragging around the map and tests coordinates (lmap._lastCenter is current coordinates) + it('tests panning and centering the map', () => { + cy.closeSettingsPane('Geospatial Settings'); + cy.get('#centerMapButton').click({ force: true }); + + let initialCenter : {lat: number, lng: number}; + let newCenter : {lat: number, lng: number}; + + cy.window().then((win: any) => { + const lmap = win.commonService.visuals.gisMap.lmap; + const c = lmap.getCenter(); + initialCenter = { lat: c.lat, lng: c.lng }; + const container = lmap.getContainer() as HTMLElement; + const start = { clientX: 100, clientY: 400 }; + const end = { clientX: -100, clientY: 600 }; + + const md1 = new MouseEvent('mousedown', Object.assign({ + bubbles: true, cancelable: true, composed: true, + pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0 + }, start)) + container.dispatchEvent(md1); + + const mm1 = new MouseEvent('mousemove', Object.assign({ + bubbles: true, cancelable: true, composed: true, + pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0 + }, end)) + container.dispatchEvent(mm1); + + const me1 = new MouseEvent('mouseend', Object.assign({ + bubbles: true, cancelable: true, composed: true, + pointerId: 1, pointerType: 'mouse', isPrimary: true, button: 0 + }, end)) + container.dispatchEvent(me1); + + newCenter = lmap.getCenter(); + const latDiff = Math.abs(newCenter.lat - initialCenter.lat); + const lngDiff = Math.abs(newCenter.lng - initialCenter.lng); + expect(latDiff > 1 && lngDiff > 1).to.equal(true); + }); + + cy.wait(500); + + cy.get('#centerMapButton').click({ force: true }); + cy.wait(500); + + cy.window().then((win: any) => { + const lmap = win.commonService.visuals.gisMap.lmap; + const c = lmap.getCenter(); + newCenter = { lat: c.lat, lng: c.lng }; + const latDiff = Math.abs(newCenter.lat - initialCenter.lat); + const lngDiff = Math.abs(newCenter.lng - initialCenter.lng); + expect(latDiff < 0.05 && lngDiff < 0.05).to.equal(true); + }) + }); + + it('tests zoom changes from zoom in, zoom out, and center map buttons', () => { + cy.closeSettingsPane('Geospatial Settings'); + cy.get('#centerMapButton').click({ force: true }); + cy.wait(1000) + cy.window().then((win: any) => { + const lmap = win.commonService.visuals.gisMap.lmap; + let zoomLevel = lmap.getZoom(); + expect(zoomLevel).to.equal(5); + }) + + let zoomInButton = cy.get('.leaflet-control-zoom-in span'); + zoomInButton.click() + cy.wait(250) + zoomInButton.click() + cy.wait(250); + zoomInButton.click() + cy.wait(500) + + cy.window().then((win: any) => { + const lmap = win.commonService.visuals.gisMap.lmap; + let zoomLevel = lmap.getZoom(); + expect(zoomLevel).to.equal(8); + }) + + let zoomOutButton = cy.get('.leaflet-control-zoom-out span'); + zoomOutButton.click() + cy.wait(250) + zoomOutButton.click() + cy.wait(250); + zoomOutButton.click() + cy.wait(250); + zoomOutButton.click() + cy.wait(250); + zoomOutButton.click() + cy.wait(500) + + cy.window().then((win: any) => { + const lmap = win.commonService.visuals.gisMap.lmap; + let zoomLevel = lmap.getZoom(); + expect(zoomLevel).to.equal(3); + }) + + cy.get('#centerMapButton').click({ force: true }); + cy.wait(1000) + cy.window().then((win: any) => { + const lmap = win.commonService.visuals.gisMap.lmap; + let zoomLevel = lmap.getZoom(); + expect(zoomLevel).to.equal(5); + }) + }); + + it('test node tooltip', ()=> { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + cy.get('#map-node-tooltip-variable').click() + cy.contains('li[role="option"]', 'Id').click(); + cy.wait(200) + + cy.closeSettingsPane('Geospatial Settings'); + cy.contains('.p-dialog-header', 'Link Color Table') + .parents('.p-dialog') + .find('button.p-dialog-close-button') + .click(); + + let NC_node: any; + cy.window().then((win: any) => { + const layers = win.commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers; + NC_node = Object.values(layers).find((node: any) => node.data && node.data._id == "MZ591568") + expect(NC_node).to.not.be.null; + + const lmap = win.commonService.visuals.gisMap.lmap; + const container = lmap.getContainer() as HTMLElement; + const rect = container.getBoundingClientRect(); + + const point = NC_node._point; + const clientX = Math.round(rect.left + point.x) + const clientY = Math.round(rect.top + point.y) + const eventInit: any = { bubbles: true, cancelable: true, composed: true, + button: 0, x: clientX, y: clientY, pageX: clientX, pageY: clientY + }; + const fakeOriginalEvent = new MouseEvent('mouseover', eventInit); + + const containerPoint = L.point(point.x, point.y); + const latlng = lmap.containerPointToLatLng(containerPoint); + + NC_node.fire('mouseover', {latlng, layer: NC_node, containerPoint, originalEvent: fakeOriginalEvent}); + cy.wait(200); + cy.get('#mapTooltip', { timeout: 2000 }).should('be.visible').and('contain', 'MZ591568'); + + cy.wait(2000).then(() => { + NC_node.fire('mouseout'); + cy.get('#mapTooltip', { timeout: 2000 }).should('not.be.visible'); + }); + }) + }) + + it('test link tooltip', ()=> { + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Links').click() + cy.get('#map-link-tooltip-variable').click() + cy.contains('li[role="option"]', 'Contact type').click(); + cy.wait(200) + + cy.closeSettingsPane('Geospatial Settings'); + cy.contains('.p-dialog-header', 'Link Color Table') + .parents('.p-dialog') + .find('button.p-dialog-close-button') + .click(); + + let test_link: any; + cy.window().then((win: any) => { + const layers = win.commonService.visuals.gisMap.layers.links._layers; + test_link = Object.values(layers).find((node: any) => node.data && node.data.target == "MZ591568") + expect(test_link).to.not.be.null; + + const lmap = win.commonService.visuals.gisMap.lmap; + const container = lmap.getContainer() as HTMLElement; + const rect = container.getBoundingClientRect(); + + const midpoint = {x: (test_link._rawPxBounds.min.x + test_link._rawPxBounds.max.x)/2, y: (test_link._rawPxBounds.min.y + test_link._rawPxBounds.max.y)/2 } + const clientX = rect.left + midpoint.x + const clientY = rect.top + midpoint.y + const eventInit: any = { bubbles: true, cancelable: true, composed: true, + button: 0, x: clientX, y: clientY, pageX: clientX, pageY: clientY + }; + const fakeOriginalEvent = new MouseEvent('mouseover', eventInit); + + const containerPoint = L.point(midpoint.x, midpoint.y); + const latlng = lmap.containerPointToLatLng(containerPoint); + + test_link.fire('mouseover', {latlng, layer: test_link, containerPoint, originalEvent: fakeOriginalEvent}); + cy.wait(200); + cy.get('#mapTooltip', { timeout: 2000 }).should('be.visible').and('contain', 'sports team'); + + cy.wait(2000).then(() => { + test_link.fire('mouseout'); + cy.get('#mapTooltip', { timeout: 2000 }).should('not.be.visible'); + }); + }) + }) + + it('should select a node by clicking on it', () => { + cy.closeSettingsPane('Geospatial Settings'); + cy.contains('.p-dialog-header', 'Link Color Table') + .parents('.p-dialog') + .find('button.p-dialog-close-button') + .click(); + + let NC_node: any; + cy.window().then((win: any) => { + const layers = win.commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers; + NC_node = Object.values(layers).find((node: any) => node.data && node.data._id == "MZ591568") + expect(NC_node).to.not.be.null; + expect(NC_node.data.selected).to.be.false; + expect(NC_node.options.color).to.be.eq('#000000') + + const point = NC_node._point; + const eventInit: any = { bubbles: true, cancelable: true, composed: true }; + const fakeOriginalEvent = new MouseEvent('click', eventInit); + + const lmap = win.commonService.visuals.gisMap.lmap; + const containerPoint = L.point(point.x, point.y); + const latlng = lmap.containerPointToLatLng(containerPoint); + + NC_node.fire('click', {latlng, layer: NC_node, containerPoint, originalEvent: fakeOriginalEvent}); + cy.wait(100); + + NC_node = Object.values(layers).find((node: any) => node.data && node.data._id == "MZ591568") + expect(NC_node).to.not.be.null; + expect(NC_node.data.selected).to.be.true; + expect(NC_node.options.color).to.be.eq('#ff8300') + // ensure selection is transferred to node stored in commonService + let cs_Node = win.commonService.getVisibleNodes().find(n => n._id == 'MZ591568') + expect(cs_Node.selected).to.be.true; + }) + }) + + it('should download map view as a png', () => { + cy.closeSettingsPane('Geospatial Settings'); + cy.get('#tool-btn-container-map a[title="Export Screen"]').click(); // #tool-btn-container-map a[title="Export Screen"]' + cy.contains('.p-dialog-title', 'Export Geospatial Data').should('be.visible'); + + cy.get('#map-export-filename').invoke('val', 'cypress_map').trigger('input').trigger('change'); + cy.get('#map-export').click(); + + cy.wait(7000); + cy.readFile('cypress/downloads/cypress_map.png').should('exist') + }) + + // open map, select detailed or satellite basemap. Then close map and re-open. Confirm that map layer settings are maintained and that map renders accurately. + it('should maintain selected map type (satellite) after opening and closing map view', () => { + cy.window().its('commonService.session.style.widgets.map-satellite-show').should('equal', false); + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Components').click() + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('.p-accordionheader', 'Online').click(); + cy.get('#map-satellite-show-hide').contains('Show').click(); + cy.window().its('commonService.session.style.widgets.map-satellite-show').should('equal', true); + cy.closeSettingsPane('Geospatial Settings'); + cy.wait(2000) + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.satellite)).to.equal(true) + }); + + cy.get('.lm_tab[title="Map"]>.lm_close_tab').click(); + cy.wait(500) + cy.get(selectors.mapContainer, { timeout: 15000 }).should('not.exist'); + + // Open the "View" menu and click on "Map" + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Map').click(); + + // Wait for the map container to be visible, indicating the view has loaded + cy.get(selectors.mapContainer, { timeout: 15000 }).should('be.visible'); + cy.wait(2000); + cy.window().its('commonService.visuals.gisMap').then(mapView => { + expect(mapView.lmap.hasLayer(mapView.layers.satellite)).to.equal(true) + }); + }) + }) + + context('Global Settings updating Map', () => { + beforeEach(() => { + // Open the settings pane + cy.get(selectors.settingsBtn).click(); + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + + cy.get('#map-field-zipcode').click(); + cy.contains('li[role="option"]', 'Zipcode').click(); + cy.get('#tool-btn-container-map a[title="Center Screen"]').click(); + cy.wait(1000) + + + cy.closeSettingsPane('Geospatial Settings') + cy.contains('.p-dialog-title', 'Excluded Nodes').parents('.p-dialog').find('button.p-dialog-close-button').click({force: true}); + cy.contains('.p-dialog-title', 'Excluded Nodes').should('not.exist'); + cy.openGlobalSettings(); + }); + + // Map node colors should be mappable and remappable + it('should update node color to red', () => { + cy.get('#node-color-variable').click() + cy.get('li[role="option"]').contains('None').click() + + cy.wait(250); + cy.get('#node-color').invoke('val', '#ff0000').trigger('input'); + + // wait for the session model to update + cy.window().its('commonService.session.style.widgets.node-color', { timeout: 5000 }) + .should('equal', '#ff0000'); + + // check collapsed markers (markerClusterGroup -> internal featureGroup layers) + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers', { timeout: 5000 }) + .should(layers => { + Object.values(layers).forEach((layer: any) => { + if (layer._childCount > 0) { + return; + } else { + expect(layer.options.fillColor).to.equal('#ff0000'); + } + }); + }); + + cy.contains('#link-color-table-row p-selectButton span', 'Hide').parent().click(); + cy.closeGlobalSettings(); + cy.wait(250); + if (takeScreenshots) cy.screenshot('map/node-color-red', { overwrite: true}); + + cy.get(selectors.settingsBtn).click(); + + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + cy.get('#map-node-collapsing').contains('Off').click() + cy.wait(100); + + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers', { timeout: 5000 }) + .should(layers => { Object.values(layers).forEach((layer: any) => { + expect(layer.options.fillColor).to.equal('#ff0000'); + }); + }); + }) + + it('should update node color by to lineage and then change one of the colors', () => { + cy.get('#node-color-variable').click() + cy.get('li[role="option"]').contains('Lineage').click() + cy.wait(250); + cy.closeGlobalSettings(); + + cy.get('#node-color-table td input').first().invoke('val', '#777777').trigger('input').trigger('change'); + cy.window().its('commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers').should(layers => { + Object.values(layers).forEach((layer: any) => { + if (layer.data && layer.data.ID === 'MZ375596') { + expect(layer.options.fillColor).to.equal('#777777'); + } + }); + }); + + cy.get('.leaflet-control-zoom-out').click({force: true}); + cy.wait(1000); + if (takeScreenshots) cy.screenshot('map/node-colorado-gray', { overwrite: true}); + }) + + // Map link colors should be mappable and remappable + it('should update link colors to red', () => { + cy.get('#link-tooltip-variable').click() + cy.get('li[role="option"]').contains('None').click() + + cy.wait(250); + cy.get('#link-color').invoke('val', '#ff0000').trigger('input'); + cy.wait(100); + + cy.closeGlobalSettings(); + if (takeScreenshots) cy.screenshot('map/links-color-red', { overwrite: true}) + + cy.window().its('commonService.visuals.gisMap.layers.links._layers', { timeout: 5000 }) + .should(layers => { Object.values(layers).forEach((layer: any) => { + expect(layer.options.color).to.equal('#ff0000'); + }); + }); + }) + + it('should update link colors variable to Cluster and then change one of the colors', () => { + cy.get('#link-tooltip-variable').click() + cy.get('li[role="option"]').contains('Cluster').click() + + cy.wait(250); + cy.get('#link-color-table td input').first().invoke('val', '#777777').trigger('input').trigger('change'); + cy.wait(100); + + cy.closeGlobalSettings(); + if (takeScreenshots) cy.screenshot('map/link-color-var-change-gray', { overwrite: true}) + + cy.window().its('commonService.visuals.gisMap.layers.links._layers', { timeout: 5000 }) + .should(layers => { Object.values(layers).forEach((layer: any) => { + if ( layer.data.cluster == 0) { + expect(layer.options.color).to.equal('#777777'); + } + }); + }); + }) + + it('should update link threshold and confirm links are updated on map', () => { + cy.contains('#global-settings-modal .nav-link', 'Filtering').click(); + for (let i = 0; i < 4; i++) { + cy.get('#link-threshold').type('{uparrow}'); + } + cy.wait(2000) + cy.window().then((win: any) => { + expect(win.commonService.session.style.widgets["link-threshold"]).to.eq(20) + // duo links have 2 links/layers/polylines in map view; 1 has data the other doesn't + let links = win.commonService.visuals.gisMap.layers.links._layers; + expect(Object.values(links).length).to.eq(89) + //.forEach((layer: any) => { }) + + }); + for (let i = 0; i < 8; i++) { + cy.get('#link-threshold').type('{downarrow}'); + } + cy.wait(2000) + cy.window().then((win: any) => { + expect(win.commonService.session.style.widgets["link-threshold"]).to.eq(12) + let links = win.commonService.visuals.gisMap.layers.links._layers; + expect(Object.values(links).length).to.eq(52) + }) + }) + + it('should set node color variable and link color varialbe to cluster, then update link threshold to update node color', () => { + cy.get(selectors.settingsBtn).click(); + + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + cy.get('#map-node-collapsing').contains('Off').click() + cy.closeSettingsPane('Geospatial Settings') + + cy.get('#node-color-variable').click() + cy.get('li[role="option"]').contains('Cluster').click() + + cy.get('#link-tooltip-variable').click() + cy.get('li[role="option"]').contains('Cluster').click() + + cy.contains('#global-settings-modal .nav-link', 'Filtering').click(); + for (let i = 0; i < 6; i++) { + cy.get('#link-threshold').type('{uparrow}'); + } + cy.wait(2000); + cy.window().then((win: any) => { + expect(win.commonService.session.style.widgets["link-threshold"]).to.eq(22) + + let links = win.commonService.visuals.gisMap.layers.links._layers; + Object.values(links).filter((l: any) => l.data && l.data.source == 'MZ787305').forEach((l: any) => { + expect(l.options.color).to.be.eq('#1f78b4') + }) + + let nodes = win.commonService.visuals.gisMap.layers.featureGroup._layers; + Object.values(nodes).filter((node: any) => node.data && (node.data._id == 'MZ787305' || node.data._id == 'MZ740979')).forEach((node: any) => { + expect(node.options.fillColor).to.be.eq('#f22020') + }) + }) + + for (let i = 0; i < 8; i++) { + cy.get('#link-threshold').type('{downarrow}'); + } + cy.wait(2000); + cy.window().then((win: any) => { + expect(win.commonService.session.style.widgets["link-threshold"]).to.eq(14) + + let links = win.commonService.visuals.gisMap.layers.links._layers; + expect((Object.values(links).filter((l: any) => l.data && l.data.source == 'MZ787305')[0] as any).options.color).to.be.eq('#b2df8a') + let nodes = win.commonService.visuals.gisMap.layers.featureGroup._layers; + Object.values(nodes).filter((node: any) => node.data && (node.data._id == 'MZ787305' || node.data._id == 'MZ740979')).forEach((node: any) => { + expect(node.options.fillColor).to.be.eq('#f47a22'); + }) + Object.values(nodes).filter((node: any) => node.data && node.data._id == 'MZ744285').forEach((node: any) => { + expect(node.options.fillColor).to.be.eq('#b732cc') + }) + }) + }) + + it('should load style file', () => { + cy.contains('#global-settings-modal .nav-link', 'Styling').click(); + cy.get('#apply-style').should('exist'); + + cy.attach_file('#apply-style', 'Cypress_Test_Style.style', 'application/json'); + + cy.window() + .its('commonService.session.style.widgets', { timeout: 5000 }) + .should(widgets => { + expect(widgets['node-color-variable']).to.equal('Profession'); + expect(widgets['link-color-variable']).to.equal('Contact type'); + expect(widgets['map-countries-show']).to.equal(false); + expect(widgets['map-basemap-show']).to.equal(true); + expect(widgets['map-collapsing-on']).to.equal(false); + expect(widgets['map-node-tooltip-variable']).to.equal('Lineage') + }); + + cy.contains('#global-settings-modal .nav-link', 'Styling').click(); + cy.get('#node-color-variable .p-select-label').should('contain', 'Profession'); + + cy.closeGlobalSettings(); + cy.contains('.p-dialog-title', 'Excluded Nodes').parents('.p-dialog').find('button.p-dialog-close-button').click({force: true}); + cy.contains('.p-dialog-title', 'Excluded Nodes').should('not.exist'); + + cy.window().its('commonService.visuals.gisMap').then(mapView => { + let nodeLayers = mapView.layers.featureGroup._layers; + expect(Object.keys(nodeLayers)).to.have.length(30); + Object.values(nodeLayers).forEach((node: any) => { + if (node.data && node.data.Profession === 'Education') { + expect(node.options.fillColor).to.equal('#f22020'); + } + }); + let linkLayers = mapView.layers.links._layers; + Object.values(linkLayers).forEach((link: any) => { + if (link.data && link.data['Contact Type'] == 'sports team') { + expect(link.options.color).to.equal('#33a02c') + } + }) + expect(mapView.lmap.hasLayer(mapView.layers.countries)).to.equal(false) + expect(mapView.lmap.hasLayer(mapView.layers.basemap)).to.equal(true) + }); + + let NC_node: any; + cy.window().then((win: any) => { + const layers = win.commonService.visuals.gisMap.layers.featureGroup._layers; + NC_node = Object.values(layers).find((node: any) => node.data && node.data._id == "MZ591568") + expect(NC_node).to.not.be.null; + + const lmap = win.commonService.visuals.gisMap.lmap; + const container = lmap.getContainer() as HTMLElement; + const rect = container.getBoundingClientRect(); + + const point = NC_node._point; + const clientX = Math.round(rect.left + point.x) + const clientY = Math.round(rect.top + point.y) + const eventInit: any = { bubbles: true, cancelable: true, composed: true, + button: 0, x: clientX, y: clientY, pageX: clientX, pageY: clientY + }; + const fakeOriginalEvent = new MouseEvent('mouseover', eventInit); + + const containerPoint = L.point(point.x, point.y); + const latlng = lmap.containerPointToLatLng(containerPoint); + + NC_node.fire('mouseover', {latlng, layer: NC_node, containerPoint, originalEvent: fakeOriginalEvent}); + cy.wait(200); + cy.get('#mapTooltip', { timeout: 2000 }).should('be.visible').and('contain', 'B.1.351'); + }) + }) + }) + + context('Timeline Mode Testing', () => { + beforeEach(() => { + cy.openGlobalSettings().enableTimelineMode().closeGlobalSettings(); + + cy.get(selectors.settingsBtn).click(); + + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + cy.wait(2000) + + cy.get('#map-field-zipcode').click(); + cy.contains('li[role="option"]', 'Zipcode').click(); + cy.get('#tool-btn-container-map a[title="Center Screen"]').click(); + cy.wait(250); + cy.closeSettingsPane('Geospatial Settings') + cy.contains('.p-dialog-title', 'Excluded Nodes').parents('.p-dialog').find('button.p-dialog-close-button').click({force: true}); + cy.contains('.p-dialog-title', 'Excluded Nodes').should('not.exist'); + }); + + it('starts and stops the timeline and also checks that play button is updated', () => { + cy.get('svg g.slider text.label').should('contain', 'Jun 28') + cy.get('svg g.slider circle.handle').should('not.have.attr', 'cx') + cy.get('#timeline-play-button').should('contain', 'Play').click(); + cy.wait(7500) + cy.get('#timeline-play-button').should('contain', 'Pause').click(); + cy.get('svg g.slider text.label').should('not.contain', 'Jun 28') + cy.get('svg g.slider circle.handle').invoke('attr', 'cx').then(Number).should('be.gt', 0) + cy.window().then((win: any) => { + let visNodeCount_map = win.commonService.getVisibleNodes().filter((node) => node.Zip_code).length; + + let mapNodeCount = 0; + Object.values(win.commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers).forEach((layer: any) => { + if (layer._childCount) mapNodeCount += layer._childCount; + else mapNodeCount += 1; + }) + expect(visNodeCount_map).to.eq(mapNodeCount); + }) + }) + + it('changes color of node and link during timeline and then ensures color is kept after timeline ends', () => { + cy.get('#timeline-play-button').should('contain', 'Play').click(); + cy.wait(7500) + cy.get('#timeline-play-button').should('contain', 'Pause').click(); + + cy.get('#node-color-table').contains('td', 'Pennsylvania').parent('tr').find('input[type="color"]').first().invoke('val', '#777777').trigger('input').trigger('change'); + cy.get('#link-color-table td input').first().invoke('val', '#000000').trigger('input').trigger('change'); + + cy.window().its('commonService.visuals.gisMap.layers').then(layers => { + let penNode: any = Object.values(layers.markerClusterGroup._featureGroup._layers).find((layer: any) => layer.data && layer.data.ID === 'MZ415508') + expect(penNode.options.fillColor).to.equal('#777777'); + let penLink: any = Object.values(layers.links._layers).find((layer: any) => layer.data && layer.data.id === 'MZ415508-MZ797703') + expect(penLink.options.color).to.equal('#000000'); + }) + + cy.openGlobalSettings().enableTimelineMode('None').closeGlobalSettings().wait(1000) + cy.window().its('commonService.visuals.gisMap.layers').then(layers => { + let penNode: any = Object.values(layers.markerClusterGroup._featureGroup._layers).find((layer: any) => layer.data && layer.data.ID === 'MZ415508') + expect(penNode.options.fillColor).to.equal('#777777'); + let penLink: any = Object.values(layers.links._layers).find((layer: any) => layer.data && layer.data.id === 'MZ415508-MZ797703') + expect(penLink.options.color).to.equal('#000000'); + }) + }) + + it('clicks slider midway and then back to start', () => { + + cy.get('#global-timeline svg line.track-overlay').first().click(300, 0, {force: true}); + cy.wait(1500) + cy.get('svg g.slider text.label').should('contain', 'Jul 15') + cy.window().then((win: any) => { + let visNodeCount_map = win.commonService.getVisibleNodes().filter((node) => node.Zip_code).length; + let mapNodeCount = 0; + Object.values(win.commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers).forEach((layer: any) => { + if (layer._childCount) mapNodeCount += layer._childCount; + else mapNodeCount += 1; + }) + expect(visNodeCount_map).to.eq(mapNodeCount).to.eq(16); + }) + + cy.get('#global-timeline svg line.track-overlay').first().click(0, 0, {force: true}); + cy.wait(1500) + cy.get('svg g.slider text.label').should('contain', 'Jun 27') + cy.window().then((win: any) => { + let visNodeCount_map = win.commonService.getVisibleNodes().filter((node) => node.Zip_code).length; + let mapNodeCount = 0; + Object.values(win.commonService.visuals.gisMap.layers.markerClusterGroup._featureGroup._layers).forEach((layer: any) => { + if (layer._childCount) mapNodeCount += layer._childCount; + else mapNodeCount += 1; + }) + expect(visNodeCount_map).to.eq(mapNodeCount).to.eq(0); + }) + }) + }) +}) + +context('Settings and Interactions (Alternative [Lat/Long] Dataset)', () => { + const nodeFile = 'AngularTesting_nodes_Map.csv'; + beforeEach(() => { + cy.visit('/'); + cy.wait(2000); + + // Upload the file from the overlay + cy.loadFiles([{name: nodeFile, datatype: 'node', field1: '_id', field2: 'seq'}]) + + cy.get('#launch').click() + cy.get('#loading-information', { timeout: 20000 }).should('not.exist'); + + // Open the "View" menu and click on "Map" + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Map').click(); + + // Wait for the map container to be visible, indicating the view has loaded + cy.get('.mapStyle', { timeout: 15000 }).should('be.visible'); + + // Open the settings pane + cy.get('#tool-btn-container-map a[title="Settings"]').click(); + + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Geospatial Settings').should('be.visible'); + + cy.get('#map-field-lat').click(); + cy.contains('li[role="option"]', 'Lat').click(); + + cy.get('#map-field-lon').click(); + cy.contains('li[role="option"]', 'Long').click(); + + cy.contains('.p-dialog-title', 'Geospatial Settings').parents('.p-dialog').contains('Nodes').click() + cy.get('#map-node-collapsing').contains('Off').click() + + cy.closeSettingsPane('Geospatial Settings'); + cy.get('#tool-btn-container-map a[title="Center Screen"]').click(); + }) + + // Lat-Lon selection renders nodes on map + it('should load data and center view on London', () => { + cy.window().its('commonService.visuals.gisMap.SelectedNodeCollapsingTypeVariable').should('equal', 'Off') + cy.wait(2000) + + if (takeScreenshots) cy.screenshot('map/map-latlong', { overwrite: true}); + + cy.window().its('commonService.visuals.gisMap.layers.featureGroup._layers').then(layers => { + Object.values(layers).forEach((layer: any) => { + if (layer.data) { + expect(String(layer._latlng.lat)).to.equal(String(layer.data.lat)) + expect(String(layer._latlng.lng)).to.equal(String(layer.data.long)); + } + }); + }) + }) +}) \ No newline at end of file diff --git a/cypress/e2e/microbetrace-next.cy.ts b/cypress/e2e/microbetrace-next.cy.ts new file mode 100644 index 00000000..e36f317c --- /dev/null +++ b/cypress/e2e/microbetrace-next.cy.ts @@ -0,0 +1,195 @@ +/// + +/** + * High-value integration tests for MicrobeTrace Next (TS) + * Uses Angular-exposed window.commonService to assert internal state. + */ + +const FIXTURE_CSV = 'AngularTesting_Distance_linklist_small.csv'; + +type Selectors = { + eula_modal: string; + eula_accept_btn: string; + eula_reject_btn: string; + + search_field: string; + link_sort_variable: string; + node_color_variable: string; + default_distance_metric: string; + link_color_variable: string; + + link_threshold_input: string; + link_threshold_histogram: string; + + stats_nodes: string; + stats_links: string; + stats_singletons: string; + stats_components: string; + + files_tab: string; + file_input: string; + global_settings_btn: string; + + link_color_table_modal: string; + node_color_table_modal: string; +}; + +const sel: Selectors = { + eula_modal: '#eula-modal', + eula_accept_btn: '#eula-accept', + eula_reject_btn: '#eula-reject', + + search_field: '#search-field', + link_sort_variable: '#link-sort-variable', + node_color_variable: '#node-color-variable', + default_distance_metric: '#default-distance-metric', + link_color_variable: '#link-color-variable', + + link_threshold_input: '#link-threshold', + link_threshold_histogram: '#linkThresholdSparkline, #link-threshold-sparkline, #link-threshold-histogram', + + stats_nodes: '#numberOfNodes', + stats_links: '#numberOfVisibleLinks', + stats_singletons: '#numberOfSingletonNodes', + stats_components: '#numberOfDisjointComponents', + + files_tab: '#FilesTab, [data-test=files-tab]', + file_input: 'input[type=file]', + global_settings_btn: '#SettingsTab, [data-test=open-global-settings]', + + link_color_table_modal: '#global-settings-link-color-table', + node_color_table_modal: '#global-settings-node-color-table' +}; + +function parse_int_text(el: JQuery): number { + return parseInt(el.text().replace(/,/g, ''), 10); +} + +describe('microbetrace core flows (ts)', () => { + beforeEach(() => { + cy.visit('/'); + cy.get_common_service(); + }); + + it('eula appears once and persists acceptance', () => { + cy.get(sel.eula_modal, { timeout: 10000 }).should('be.visible'); + cy.get(sel.eula_accept_btn).click(); + cy.get(sel.eula_modal).should('not.exist'); + + cy.reload(); + cy.get(sel.eula_modal).should('not.exist'); + }); + + it('load csv and compute network stats', () => { + cy.get(sel.files_tab).click({ force: true }); + cy.attach_file(sel.file_input, FIXTURE_CSV, 'text/csv'); + + cy.get(sel.stats_nodes, { timeout: 30000 }).should($n => { + const v = parse_int_text($n); + expect(v).to.be.greaterThan(0); + }); + cy.get(sel.stats_links).should($n => { + const v = parse_int_text($n); + expect(v).to.be.greaterThan(0); + }); + + cy.get_common_service().then((cs: any) => { + expect(cs.session.data.nodes.length).to.be.greaterThan(0); + expect(cs.session.data.links.length).to.be.greaterThan(0); + expect(cs.session.network.isFullyLoaded).to.equal(true); + }); + }); + + it('threshold filtering changes link counts and updates widget', () => { + cy.get(sel.files_tab).click({ force: true }); + cy.attach_file(sel.file_input, FIXTURE_CSV, 'text/csv'); + + let initial_links = 0; + cy.get(sel.stats_links, { timeout: 30000 }).then($n => { + initial_links = parse_int_text($n); + expect(initial_links).to.be.greaterThan(0); + }); + + cy.get('body').then($b => { + if ($b.find(sel.link_threshold_input).length) { + cy.get(sel.link_threshold_input).clear().type('0.030').blur(); + } else { + cy.click_histogram_at(sel.link_threshold_histogram, 0.75); + } + }); + + cy.get(sel.stats_links, { timeout: 10000 }).should($n => { + const after = parse_int_text($n); + expect(after).to.be.a('number'); + }); + + cy.get_common_service().then((cs: any) => { + const thr = cs.session.style.widgets['link-threshold']; + expect(thr).to.be.a('number'); + expect(thr).to.be.greaterThan(0); + }); + }); + + it('switch distance metric tn93 ↔ snps and keeps threshold coherent', () => { + cy.get(sel.default_distance_metric).should('be.visible'); + + cy.get(sel.default_distance_metric).select('snps'); + cy.get_common_service().then((cs: any) => { + expect(cs.session.style.widgets['default-distance-metric']).to.equal('snps'); + expect(cs.session.style.widgets['link-threshold']).to.be.a('number'); + }); + + cy.get(sel.default_distance_metric).select('tn93'); + cy.get_common_service().then((cs: any) => { + expect(cs.session.style.widgets['default-distance-metric']).to.equal('tn93'); + expect(cs.session.style.widgets['link-threshold']).to.be.a('number'); + }); + }); +}); + +describe('microbetrace color tables (ts)', () => { + beforeEach(() => { + cy.visit('/'); + cy.get_common_service(); + cy.get(sel.files_tab).click({ force: true }); + cy.attach_file(sel.file_input, FIXTURE_CSV, 'text/csv'); + cy.get(sel.stats_nodes, { timeout: 30000 }).should('be.visible'); + }); + + it('link color table populates when variable is origin', () => { + cy.get(sel.link_color_variable).select('origin', { force: true }); + cy.get(sel.global_settings_btn).click({ force: true }); + + cy.get(sel.link_color_table_modal).should('exist'); + cy.get(sel.link_color_table_modal).find('table tr').its('length').should('be.greaterThan', 0); + }); + + it('node color table populates when variable is _id', () => { + cy.get(sel.node_color_variable).select('_id', { force: true }); + cy.get(sel.global_settings_btn).click({ force: true }); + + cy.get(sel.node_color_table_modal).should('exist'); + cy.get(sel.node_color_table_modal).find('table tr').its('length').should('be.greaterThan', 0); + }); +}); + +describe('microbetrace color tables (ts)', () => { + beforeEach(() => { + cy.visit('/'); + cy.waitForNetworkToRender(); // Wait for the default network + }); + + it('shows Link Color table when variable=origin and table visibility=Show', () => { + cy.get('#link-color-variable').select('origin'); + cy.get('#LinkColorTableTypes').select('Show'); + cy.get('#link-color-table').should('exist').and('be.visible'); + cy.get('#link-color-table').find('tr').its('length').should('be.greaterThan', 1); + }); + + it('shows Node Color table when variable is selected and table visibility=Show', () => { + cy.get('#node-color-variable').select('cluster'); // Use 'cluster' or another default field + cy.get('#NodeColorTableTypes').select('Show'); + cy.get('#node-color-table').should('exist').and('be.visible'); + cy.get('#node-color-table').find('tr').its('length').should('be.greaterThan', 1); + }); +}); diff --git a/cypress/e2e/phylogenetic-plugin.cy.ts b/cypress/e2e/phylogenetic-plugin.cy.ts new file mode 100644 index 00000000..6f802851 --- /dev/null +++ b/cypress/e2e/phylogenetic-plugin.cy.ts @@ -0,0 +1,555 @@ +/// + +/** + * Tests for the Phylogenetic Tree visualization component. + */ +describe('Phylogenetic Tree View', () => { + + // Selectors for key elements in the Phylogenetic Tree component + const selectors = { + treeContainer: '#phylocanvas', + treeSvg: '#phylocanvas svg', // Target the SVG element directly + settingsBtn: '#tool-btn-container-phylo a[title="Settings"]', + settingsPane: '#phylotree-settings-pane', // Used only to check for non-visibility + layoutDropdown: '#tree-layout', + leafLabelsToggle: '#leaf-label-visibility' + }; + + /** + * This block runs before each test. It loads the application, + * continues with the sample dataset, and navigates to the view. + */ + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); // Allow for initial application bootstrap + + cy.get('button:contains("Continue with Sample Dataset")', { timeout: 10000 }) + .click({ force: true }); + + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + // Open the "View" menu and click on "Phylogenetic Tree" + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Phylogenetic Tree').click(); + + // Wait for the tree container to be visible, indicating the view has loaded + cy.get(selectors.treeContainer, { timeout: 15000 }).should('be.visible'); + }); + + // probably should move these test at some point + context('Global Settings', () => { + it('should update node color to all green nodes', () => { + cy.openGlobalSettings(); + + cy.get('#node-color-variable').click() + cy.get('li[role="option"]').contains('None').click() + cy.wait(100); + cy.get('#node-color').invoke('val', '#00ff00').trigger('input'); + + cy.wait(100); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().should('have.css', 'fill', 'rgb(0, 255, 0)'); + cy.closeGlobalSettings(); + }) + + it('should update color by to lineage and then change one of the colors', () => { + cy.openGlobalSettings(); + + cy.get('#node-color-variable').click() + cy.get('li[role="option"]').contains('Lineage').click() + + cy.wait(100); + cy.closeGlobalSettings(); + + cy.get('#node-color-table td input').first().invoke('val', '#777777').trigger('input').trigger('change'); // invoke('val', 24).trigger('input').trigger('change'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().should('have.css', 'fill', 'rgb(119, 119, 119)'); // make sure it works and we are good + + cy.wait(100); + }) + + it('should set node color variable to cluster, then update link threshold to update node color', () => { + cy.openGlobalSettings(); + cy.get('#node-color-variable').click() + cy.get('li[role="option"]').contains('Cluster').click() + + cy.get(selectors.treeSvg) + .find('g.tidytree-node-leaf circle[title="MZ740979"]') + .as('cluster2_node1'); + cy.get(selectors.treeSvg) + .find('g.tidytree-node-leaf circle[title="MZ787305"]') + .as('cluster2_node2'); + + cy.get('@cluster2_node1').should('have.css', 'fill', 'rgb(183, 50, 204)'); + cy.get('@cluster2_node2').should('have.css', 'fill', 'rgb(183, 50, 204)'); + + cy.contains('#global-settings-modal .nav-link', 'Filtering').click(); + for (let i = 0; i < 6; i++) { + cy.get('#link-threshold').type('{uparrow}'); + } + cy.wait(2000); + cy.window().then((win: any) => { expect(win.commonService.session.style.widgets["link-threshold"]).to.eq(22)}) + cy.get('@cluster2_node1').should('have.css', 'fill', 'rgb(242, 32, 32)'); + cy.get('@cluster2_node2').should('have.css', 'fill', 'rgb(242, 32, 32)'); + + for (let i = 0; i < 8; i++) { + cy.get('#link-threshold').type('{downarrow}'); + } + cy.wait(2000); + cy.window().then((win: any) => { expect(win.commonService.session.style.widgets["link-threshold"]).to.eq(14)}) + cy.get('@cluster2_node1').should('have.css', 'fill', 'rgb(244, 122, 34)'); + cy.get('@cluster2_node2').should('have.css', 'fill', 'rgb(244, 122, 34)'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle[title="MZ744285"]').should('have.css', 'fill', 'rgb(183, 50, 204)') + }) + + it('should load style file', () => { + cy.openGlobalSettings(); + + cy.contains('#global-settings-modal .nav-link', 'Styling').click(); + cy.get('#apply-style').should('exist'); + cy.attach_file('#apply-style', 'Cypress_Test_Style.style', 'application/json'); + cy.wait(1000) + cy.contains('#global-settings-modal .nav-link', 'Styling').click(); + cy.get('#node-color-variable .p-select-label').should('contain', 'Profession'); + cy.closeGlobalSettings(); + + cy.window().its('commonService.session.style.widgets').should(widgets => { + expect(widgets['node-color-variable']).to.equal('Profession'); + // updated tree-layout to circular, tree mode to smooth, and tree-leaf-size to 12 + expect(widgets['tree-layout-circular']).to.equal(true); + expect(widgets['tree-layout-horizontal']).to.equal(false); + expect(widgets['tree-mode-smooth']).to.equal(true); + expect(widgets['tree-mode-square']).to.equal(false); + expect(widgets['tree-type']).to.equal('dendrogram') + expect(widgets['tree-leaf-node-radius-variable']).to.equal('degree'); + expect(widgets['tree-branch-distances-hide']).to.equal(false); + expect(widgets['tree-branch-distance-size']).to.equal(8); + }); + cy.window().its('commonService.visuals.phylogenetic').should(tree => { + expect(tree.SelectedTreeLayoutVariable).to.equal('circular'); + expect(tree.SelectedTreeModeVariable).to.equal('smooth'); + expect(tree.SelectedTreeTypeVariable).to.equal('dendrogram') + expect(tree.SelectedLeafNodeSizeVariable).to.equal('degree'); + expect(tree.SelectedBranchDistanceShowVariable).to.equal(true); + expect(tree.SelectedBranchDistanceSizeVariable).to.equal(8); + }) + + // node color and size + cy.get(selectors.treeSvg) + .find('g.tidytree-node-leaf circle') + .first() + .should('have.css', 'fill', 'rgb(242, 32, 32)') + .invoke('attr', 'r') + .then(value => { + const radius = Number.parseFloat(value || ''); + expect(radius).to.be.closeTo(8.333, 0.01); + }); + + // node distance and font size + cy.get(selectors.treeSvg) + .find('g.tidytree-link text') + .first() + .should('have.css', 'font-size', '8px') + .should('have.css', 'opacity', '1') + + // Layout, Mode, and Type + cy.get(selectors.treeSvg) + .find('g.tidytree-link path') + .first() + .should('have.attr', 'd', 'M0,0C126.82141082593625,20.702167908678085,84.04340685431595,-97.20573935894896,168.0868137086319,-194.41147871789792') + }) + }) + + context('Export', () => { + beforeEach(() => { + // Open the settings pane + cy.get('#tool-btn-container-phylo a[title="Export Screen"]').click(); + + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Export Phylogenetic Tree').should('be.visible'); + }); + + it('should change name and export the image (as png)', () => { + cy.get('#tree-image-filename').invoke('val', 'cypress_tree_test').trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeImageFilenameVariable').should('equal', 'cypress_tree_test'); + + cy.get('#export-tree').click(); + cy.wait(5000); + cy.readFile('cypress/downloads/cypress_tree_test.png').should('exist') + }) + + it('should change name and export the image (as svg)', () => { + cy.get('#tree-image-filename').invoke('val', 'cypress_tree_test').trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeImageFilenameVariable').should('equal', 'cypress_tree_test'); + + cy.window().its('commonService.visuals.phylogenetic.SelectedNetworkExportFileTypeListVariable').should('equal', 'png'); + cy.get('#network-export-filetype').click(); + cy.contains('li[role="option"]', 'svg').click(); + cy.window().its('commonService.visuals.phylogenetic.SelectedNetworkExportFileTypeListVariable').should('equal', 'svg'); + cy.get('#export-tree').click(); + cy.wait(1000); + cy.readFile('cypress/downloads/cypress_tree_test.svg').should('exist') + }) + + it('should change name and export newick string', () => { + cy.contains('.p-dialog-title', 'Export Phylogenetic Tree').parents('.p-dialog').contains('Newick').click() + cy.get('#newick-string-filename').invoke('val', 'cypress_tree_test_nwk').trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedNewickStringFilenameVariable').should('equal', 'cypress_tree_test_nwk'); + + cy.get('#export-newick').click(); + cy.wait(1000); + cy.window().its('commonService.session.data.newickString').then(expectedString => { + cy.readFile('cypress/downloads/cypress_tree_test_nwk.txt').should('equal', expectedString); + }); + }) + }) + + /** + * Test suite for toolbar and settings pane interactions. + */ + context('Settings and Interactions', () => { + beforeEach(() => { + // Open the settings pane + cy.get(selectors.settingsBtn).click(); + + // Verify it's open by finding the title anywhere on the page. This is robust. + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings').should('be.visible'); + }); + + it('should open and close the settings pane', () => { + + // ✅ FINAL FIX: Find the title, traverse up to the '.p-dialog' container, + // then find and click the close button inside it. + cy.closeSettingsPane('Phylogenetic Tree Settings'); + }); + + it('should change the tree layout to vertical', () => { + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeLayoutVariable').should('equal', 'horizontal'); + + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Perform actions within the found container + cy.get('@dialogContainer').contains('p-accordionTab', 'Layout').click(); + cy.get('@dialogContainer').find(selectors.layoutDropdown).click(); + cy.contains('li[role="option"]', 'Vertical').click(); + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeLayoutVariable').should('equal', 'vertical'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.attr', 'd', 'M189.3152573529412 0 H 22.647058823529413 V 36.457115511109684') + }); + + it('should change the tree layout to circular', () => { + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeLayoutVariable').should('equal', 'horizontal'); + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + cy.get('@dialogContainer').contains('p-accordionTab', 'Layout').click(); + cy.get('@dialogContainer').find(selectors.layoutDropdown).click(); + cy.contains('li[role="option"]', 'Circular').click(); + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeLayoutVariable').should('equal', 'circular'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.attr', 'd', 'M0,0A0,0 0 0 0 0,0L11.92210191297659,-13.789264078412542') + }); + + it('should change the tree mode to smooth', () => { + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeModeVariable').should('equal', 'square'); + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + cy.get('@dialogContainer').contains('p-accordionTab', 'Mode').click(); + cy.get('@dialogContainer').find('#tree-mode').click(); + cy.contains('li[role="option"]', 'Smooth').click(); + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeModeVariable').should('equal', 'smooth'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.attr', 'd', 'M0,84.24938725490196C40.96105876977791,84.24938725490196,40.96105876977791,10.07843137254902,81.92211753955581,10.07843137254902') + }); + + it('should change the tree mode to straight', () => { + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeModeVariable').should('equal', 'square'); + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + cy.get('@dialogContainer').contains('p-accordionTab', 'Mode').click(); + cy.get('@dialogContainer').find('#tree-mode').click(); + cy.contains('li[role="option"]', 'Straight').click(); + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeModeVariable').should('equal', 'straight'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.attr', 'd', 'M0 84.24938725490196 L 81.92211753955581 10.07843137254902') + }); + + it('should change the tree type to Unweighted (Tree)', () => { + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeTypeVariable').should('equal', 'weighted'); + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + cy.get('@dialogContainer').contains('p-accordionTab', 'Type').click(); + cy.get('@dialogContainer').find('#tree-type').click(); + cy.contains('li[role="option"]', 'Unweighted (Tree)').click(); + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeTypeVariable').should('equal', 'tree'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.attr', 'd', 'M0 139.5232843137255 V 129.44485294117646 H 115.5') + }); + + it('should change the tree type to Dendrogram', () => { + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeTypeVariable').should('equal', 'weighted'); + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + cy.get('@dialogContainer').contains('p-accordionTab', 'Type').click(); + cy.get('@dialogContainer').find('#tree-type').click(); + cy.contains('li[role="option"]', 'Dendrogram').click(); + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.window().its('commonService.visuals.phylogenetic.SelectedTreeTypeVariable').should('equal', 'dendrogram'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.attr', 'd', 'M0 84.24938725490196 V 10.07843137254902 H 1155') + }); + + it('should toggle leaf labels on and off', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Labels and Tooltips').click(); + + // Assert initial state and interact with elements + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelShowVariable').should('be.true'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf text').first().should('be.visible'); + + cy.get('@dialogContainer').find(selectors.leafLabelsToggle).contains('Hide').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelShowVariable').should('be.false'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf text').first().should('not.be.visible'); + + cy.get('@dialogContainer').find(selectors.leafLabelsToggle).contains('Show').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelShowVariable').should('be.true'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf text').first().should('be.visible'); + }); + + it('should change leaf label to Lineage and increase size', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Labels and Tooltips').click(); + + // Assert initial state and interact with elements + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelVariable').should('equal', '_id'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf text').first().should('have.text', 'MZ798055'); + + cy.get('@dialogContainer').find('#leaf-label-variable').click(); + cy.contains('li[role="option"]', 'Lineage').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelVariable').should('equal', 'Lineage'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf text').first().should('have.text', 'B.1.617.2'); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelSizeVariable').should('equal', 12); + cy.get('@dialogContainer').find('#leaf-label-size').invoke('val', 24).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafLabelSizeVariable').should('equal', 24); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf text').first().should('have.css', 'font-size', '24px'); + }); + + it('should toggle on/off leaf tooltip', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Labels and Tooltips').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafTooltipShowVariable').should('be.true'); + + cy.get('@dialogContainer').find('#leaf-tooltip-visibility').contains('Hide').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafTooltipShowVariable').should('be.false'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().trigger('mouseenter', {force: true}); + cy.get('#phyloTooltip').should('not.be.visible'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().trigger('mouseout', {force: true}); + cy.wait(200); + cy.get('#phyloTooltip').should('not.be.visible'); + + cy.get('@dialogContainer').find('#leaf-tooltip-visibility').contains('Show').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafTooltipShowVariable').should('be.true'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().trigger('mouseenter', {force: true}); + cy.get('#phyloTooltip').should('be.visible'); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().trigger('mouseout', {force: true}); + cy.wait(200); + cy.get('#phyloTooltip').should('not.be.visible'); + }); + + it('should change leaf tooltip variable', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Labels and Tooltips').click(); + + // // Assert initial state and interact with elements + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafTooltipVariable').should('equal', '_id'); + + cy.get('@dialogContainer').find('#leaf-tooltip-variable').click(); + cy.contains('li[role="option"]', 'Lineage').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafTooltipVariable').should('equal', 'Lineage'); + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafTooltipShowVariable').should('be.true'); + + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().trigger('mouseenter', {force: true}); + cy.get('#phyloTooltip').should('be.visible').should('have.text', 'B.1.617.2'); + + cy.closeSettingsPane('Phylogenetic Tree Settings'); + }); + + it('should toggle leaf nodes', () => { + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Leaf Size').click(); + + cy.get('@dialogContainer').contains('Show Leaf Nodes').parent().as('showHideLeafNodes') + cy.get('@showHideLeafNodes').contains('Hide').click(); + // check variable + + cy.get(selectors.treeSvg) + .find('g.tidytree-node-leaf circle') + .first() + .should('have.css', 'opacity', '0') + + cy.get('@showHideLeafNodes').contains('p-togglebutton', 'Show').click(); + + cy.get(selectors.treeSvg) + .find('g.tidytree-node-leaf circle') + .first() + .should('have.css', 'opacity', '1') + + cy.closeSettingsPane('Phylogenetic Tree Settings'); + }) + + it('should select a node by clicking on it', () => { + cy.closeSettingsPane('Phylogenetic Tree Settings'); + + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().trigger('click', {force: true}).should('have.css', 'stroke', 'rgb(255, 131, 0)') + cy.window().then((win: any) => { + let node = win.commonService.getVisibleNodes().find(n => n._id == 'MZ798055') + expect(node).to.not.be.null; + expect(node.selected).to.be.true; + }) + }) + + it('should change leaf size variable and update min and max size', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Leaf Size').click(); + + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().should('have.attr', 'r', 5); + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafNodeSizeVariable').should('equal', 'None'); + cy.get('@dialogContainer').find('#leaf-size-var').click(); + cy.contains('li[role="option"]', 'Degree').click(); + + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().invoke('attr', 'r').then(r => {expect(Number(r)).to.be.closeTo(8.33334, 0.001)}); + + cy.window().its('commonService.visuals.phylogenetic.minNodeWidth').should('equal', 5); + cy.get('@dialogContainer').find('#leaf-size-min').invoke('val', 10).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.minNodeWidth').should('equal', 10); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().invoke('attr', 'r').then(r => {expect(Number(r)).to.be.closeTo(11.66666, 0.001)}); + + cy.window().its('commonService.visuals.phylogenetic.maxNodeWidth').should('equal', 15); + cy.get('@dialogContainer').find('#leaf-size-max').invoke('val', 30).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.maxNodeWidth').should('equal', 30); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().invoke('attr', 'r').then(r => {expect(Number(r)).to.be.closeTo(16.66666, 0.001)}); + }) + + it('should change leaf size', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Leaves').click(); + cy.get('@dialogContainer').contains('Leaf Size').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafNodeSize').should('equal', 5); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().invoke('attr', 'r').should('equal', '5') + cy.get('@dialogContainer').find('#leaf-size').invoke('val', 20).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedLeafNodeSize').should('equal', 20); + cy.get(selectors.treeSvg).find('g.tidytree-node-leaf circle').first().invoke('attr', 'r').should('equal', '20') + }) + + it('should show branch labels and change branch label size', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Branches').click(); + cy.get('@dialogContainer').contains('Branch Labels').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchDistanceShowVariable').should('be.false'); + cy.get(selectors.treeSvg).find('g.tidytree-link text').first().should('have.css', 'opacity', '0') + cy.get('@dialogContainer').find('#branch-distance-visibility').contains('Show').click(); + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchDistanceShowVariable').should('be.true'); + cy.get(selectors.treeSvg).find('g.tidytree-link text').first().should('have.css', 'opacity', '1') + + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchDistanceSizeVariable').should('equal', 12); + cy.get(selectors.treeSvg).find('g.tidytree-link text').first().should('have.css', 'font-size', '12px') + cy.get('@dialogContainer').find('#link-size').invoke('val', 16).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchDistanceSizeVariable').should('equal', 16); + cy.get(selectors.treeSvg).find('g.tidytree-link text').first().should('have.css', 'font-size', '16px') + }) + + it('should show branch nodes, update branch node size, and update branch size', () => { + // Use the robust method to find the dialog container + cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog').as('dialogContainer'); + + // Navigate to the correct settings tab + cy.get('@dialogContainer').contains('Branches').click(); + cy.get('@dialogContainer').contains('Branch Size').click(); + + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchNodeShowVariable').should('be.false'); + cy.get('@dialogContainer').find('#branch-node-visibility').contains('Show').click(); + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchNodeShowVariable').should('be.true'); + cy.get(selectors.treeSvg).find('g.tidytree-node-internal circle').first().should('have.css', 'opacity', '1') + + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchNodeSizeVariable').should('equal', 5); + cy.get('@dialogContainer').find('#branch-node-size').invoke('val', 8).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchNodeSizeVariable').should('equal', 8); + cy.get(selectors.treeSvg).find('g.tidytree-node-internal circle').first().should('have.attr', 'r', '8') + + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchSizeVariable').should('equal', 3); + cy.get('@dialogContainer').find('#branch-size').invoke('val', 7).trigger('input').trigger('change'); + cy.window().its('commonService.visuals.phylogenetic.SelectedBranchSizeVariable').should('equal', 7); + cy.get(selectors.treeSvg).find('g.tidytree-link path').first().should('have.css', 'stroke-width', '7px') + }) + + it('should root tree on a branch', () => { + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').eq(42).should('have.attr', 'd', 'M877.4060254027639 401.87745098039215 V 382.98039215686276 H 973.9957166831973') + cy.get(selectors.treeSvg).find('g.tidytree-node-internal circle').eq(21).trigger('contextmenu'); + cy.get('#reroot').click() + cy.get(selectors.treeSvg).find('g.tidytree-link path').eq(37).should('have.attr', 'd', 'M0 78.95263352736929 V 10.07843137254902 H 112.03413679966168') + }) + + it('should rotate tree at a branch', () => { + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').eq(42).should('have.attr', 'd', 'M877.4060254027639 401.87745098039215 V 382.98039215686276 H 973.9957166831973') + cy.get(selectors.treeSvg).find('g.tidytree-node-internal circle').eq(21).trigger('contextmenu'); + cy.get('#rotate').click() + cy.get(selectors.treeSvg).find('g.tidytree-link path').eq(42).should('have.attr', 'd', 'M877.4060254027639 416.9950980392157 V 433.37254901960785 H 973.9957166831973') + }) + + it('should flip tree at a branch', () => { + cy.closeSettingsPane('Phylogenetic Tree Settings'); + cy.get(selectors.treeSvg).find('g.tidytree-link path').eq(42).should('have.attr', 'd', 'M877.4060254027639 401.87745098039215 V 382.98039215686276 H 973.9957166831973') + cy.get(selectors.treeSvg).find('g.tidytree-node-internal circle').eq(21).trigger('contextmenu'); + cy.get('#flip').click() + cy.get(selectors.treeSvg).find('g.tidytree-link path').eq(42).should('have.attr', 'd', 'M877.4060254027639 414.47549019607845 V 433.37254901960785 H 973.9957166831973') + }) + }); +}); \ No newline at end of file diff --git a/cypress/e2e/sankey-plugin.cy.ts b/cypress/e2e/sankey-plugin.cy.ts new file mode 100644 index 00000000..1d06c677 --- /dev/null +++ b/cypress/e2e/sankey-plugin.cy.ts @@ -0,0 +1,33 @@ +describe('Sankey View', () => { + const selectors = { + container: '#sankey-container', + settingsBtn: 'a[title="Settings"]', + settingsPane: '#sankey-settings-pane', + }; + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); + + cy.contains('button', 'Continue with Sample Dataset', { timeout: 10000 }).click({ force: true }); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Sankey').click(); + + cy.get(selectors.container, { timeout: 15000 }).should('be.visible'); + }); + + it('shows the sankey container when the view loads', () => { + cy.get(selectors.container).should('exist'); + }); + + it('opens the sankey settings and shows guidance text', () => { + cy.get(selectors.settingsBtn).click(); + cy.get(selectors.settingsPane, { timeout: 10000 }).should('be.visible'); + cy.get(selectors.settingsPane).contains('Sankey Chart Settings').should('be.visible'); + + cy.get(selectors.settingsPane).find('.p-dialog-header-icon').click({ force: true }); + cy.get(selectors.settingsPane).should('not.be.visible'); + }); + }); \ No newline at end of file diff --git a/cypress/e2e/table-plugin.cy.ts b/cypress/e2e/table-plugin.cy.ts new file mode 100644 index 00000000..292fb1ab --- /dev/null +++ b/cypress/e2e/table-plugin.cy.ts @@ -0,0 +1,32 @@ +describe('Table View', () => { + const selectors = { + container: '.table-wrapper', + settingsBtn: 'a[title="Settings"]', + settingsPane: '#table-settings-pane', + }; + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); + + cy.contains('button', 'Continue with Sample Dataset', { timeout: 10000 }).click({ force: true }); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Table').click(); + + cy.get(selectors.container, { timeout: 15000 }).should('be.visible'); + }); + + it('shows table view content for the sample dataset', () => { + cy.get(selectors.container).find('p-table').should('exist'); + }); + + it('opens and closes the table settings pane', () => { + cy.get(selectors.settingsBtn).first().click(); + cy.get(selectors.settingsPane, { timeout: 10000 }).should('be.visible'); + + cy.get(selectors.settingsPane).find('.p-dialog-header-icon').click({ force: true }); + cy.get(selectors.settingsPane).should('not.be.visible'); + }); + }); \ No newline at end of file diff --git a/cypress/e2e/timeline-plugin.cy.ts b/cypress/e2e/timeline-plugin.cy.ts new file mode 100644 index 00000000..3f2e465a --- /dev/null +++ b/cypress/e2e/timeline-plugin.cy.ts @@ -0,0 +1,33 @@ +describe('Epi Curve / Timeline View', () => { + const selectors = { + container: '#epiCurve', + settingsBtn: 'a[title="Settings"]', + settingsPane: '#epiCurve-settings-pane', + }; + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); + + cy.contains('button', 'Continue with Sample Dataset', { timeout: 10000 }).click({ force: true }); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.contains('button', 'View').click(); + cy.contains('button[mat-menu-item]', 'Epi Curve').click(); + + cy.get(selectors.container, { timeout: 15000 }).should('be.visible'); + }); + + it('renders the epi curve canvas for the sample dataset', () => { + cy.get('#epiCurveSVG').should('exist'); + }); + + it('opens the epi curve settings dialog', () => { + cy.get(selectors.settingsBtn).click(); + cy.get(selectors.settingsPane, { timeout: 10000 }).should('be.visible'); + cy.get(selectors.settingsPane).contains('Epi Curve Settings').should('be.visible'); + + cy.get(selectors.settingsPane).find('.p-dialog-header-icon').click({ force: true }); + cy.get(selectors.settingsPane).should('not.be.visible'); + }); + }); \ No newline at end of file diff --git a/cypress/e2e/twod-plugin.cy.ts b/cypress/e2e/twod-plugin.cy.ts new file mode 100644 index 00000000..99ce375a --- /dev/null +++ b/cypress/e2e/twod-plugin.cy.ts @@ -0,0 +1,713 @@ +/// + +/** + * Tests for the 2D Network visualization component. + * + * These tests seed a minimal session via window.commonService to ensure + * they are fast and not dependent on the file upload UI. Tests cover core rendering, + * toolbar actions, and interactions with the settings pane to manipulate the + * network's appearance and behavior. + */ + +type WinWithCS = Window & { commonService: any }; + +import { Core } from 'cytoscape'; + +const getCy = () => cy.window({ log: false }).its('cytoscapeInstance') as Cypress.Chainable; + + +/** + * Seeds a minimal session with two nodes and one link, then launches the 2D view. + * This function provides a consistent starting state for all tests. + * + * @param {object} [options] - Optional parameters. + * @param {boolean} [options.withGroup=false] - Whether to add a 'group' property to nodes for testing clustering. + */ +const seedAndLaunch2DNetwork = (options: { withGroup?: boolean } = {}) => { + cy.window().then((win: unknown) => { + const w = win as WinWithCS; + const cs = w.commonService; + + // Reset data to a clean state + cs.resetData(); + + // Add two nodes + cs.addNode({ _id: 'A', origin: ['test.csv'], group: options.withGroup ? 'G1' : undefined }, true); + cs.addNode({ _id: 'B', origin: ['test.csv'], group: options.withGroup ? 'G1' : undefined }, true); + + // Add a link connecting the nodes + cs.addLink({ + source: 'A', + target: 'B', + distance: 0.01, + origin: ['Genetic Distance'], + hasDistance: true, + }, true); + + // Finalize data processing + cs.finishUp(); + + // Programmatically launch the 2D Network view + cs.launchView('2D Network'); + }); + // Wait for the view to fully render + cy.waitForNetworkToRender(); +}; + +// Selectors for key elements in the 2D component +const selector : any = { + canvas: '#cy', + settingsBtn: 'TwoDComponent #tool-btn-container [title="Settings"]', + pinAllBtn: 'TwoDComponent #tool-btn-container [title="Pin All Nodes"]', + refreshBtn: 'TwoDComponent #tool-btn-container [title="Recalculate Layout"]', + statsNodes: '#numberOfNodes', + statsLinks: '#numberOfVisibleLinks', + settingsPane: '#network-settings-pane', + nodeLabelVar: '#node-label-variable', + nodeRadiusSize: '#node-radius', + linkWidthSize: '#link-width', + showGroupsToggle: '#polygons-show-toggle', + groupByVar: '#polygons-foci', + nodeBorderWidth: '#node-border-width', + showArrowsToggle: '#link-directed-undirected', + showGridlinesToggle: '#network-gridlines-show-hide', + nodeLabelSize: '#node-label-size', + nodeLabelOrientation: '#node-label-orientation', + nodeRadiusVar: '#node-radius-variable', + linkOpacity: '#link-opacity', + groupLabelToggle: '#polygons-label-visibility', + linkWidthVar: '#link-width-variable', + linkLengthSlider: '#link-length', + neighborHighlightToggle: '#dont-highlight-neighbors-highlight-neighbors', + groupLabelSize: '#polygons-label-size', + groupLabelOrientation: '#polygon-label-orientation' +}; + + +// Test suite for core rendering and functionality +describe('2D Network - Core Rendering and Stats', () => { + beforeEach(() => { + cy.visit('/'); + // seedAndLaunch2DNetwork(); + cy.waitForNetworkToRender(); + }); + + it('should render the Cytoscape canvas with nodes and links', () => { + // The canvas should exist and be visible + cy.get(selector.canvas).should('be.visible'); + + // Check for the presence of a canvas element, indicating Cytoscape has rendered + cy.get(selector.canvas).find('canvas').should('exist'); + }); + + it('should display correct initial statistics', () => { + // Assert that the stats panel shows the correct counts from the seeded data + cy.get(selector.statsNodes).should('contain.text', '33'); + cy.get(selector.statsLinks).should('contain.text', '74'); + }); +}); + +// Test suite for toolbar actions +// describe('2D Network - Toolbar Actions', () => { + +// beforeEach(() => { +// cy.visit('/'); +// cy.wait(6000); // Allow for initial application bootstrap + +// cy.get('button:contains("Continue with Sample Dataset")', { timeout: 10000 }) +// .click({ force: true }); + +// cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + +// // Wait for the tree container to be visible, indicating the view has loaded +// cy.get(selector.canvas, { timeout: 15000 }).should('be.visible'); +// }); + +// it('should toggle the pin all nodes state and disable the refresh button', () => { +// // The refresh button should initially be enabled +// cy.get(selector.refreshBtn).should('not.have.class', 'disabled'); + +// // Click to pin all nodes +// cy.get(selector.pinAllBtn).click(); + +// // Assert the state change in the commonService +// cy.window().its('commonService.session.network.allPinned').should('be.true'); + +// // The refresh button should now be disabled +// cy.get(selector.refreshBtn).should('have.class', 'disabled'); + +// // Click to unpin all nodes +// cy.get(selector.pinAllBtn).click(); + +// // Assert the state is reverted in the commonService +// cy.window().its('commonService.session.network.allPinned').should('be.false'); + +// // The refresh button should be enabled again +// cy.get(selector.refreshBtn).should('not.have.class', 'disabled'); +// }); + +// it('should open and close the settings pane', () => { +// // The settings pane should not be visible initially +// cy.get(selector.settingsPane).should('not.be.visible'); + +// // Click the settings button to open the pane +// cy.get(selector.settingsBtn).click(); +// cy.get(selector.settingsPane).should('be.visible'); + +// // Click the close button (part of the PrimeNG dialog component) +// cy.get(selector.settingsPane).find('.p-dialog-header-close-icon').click(); +// cy.get(selector.settingsPane).should('not.be.visible'); +// }); +// }); + + +// Test suite for the settings pane functionality +describe('2D Network - Settings Pane Interactions', () => { + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); // Allow for initial application bootstrap + + cy.get('button:contains("Continue with Sample Dataset")', { timeout: 10000 }) + .click({ force: true }); + + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.get(selector.canvas, { timeout: 15000 }).should('be.visible'); + cy.get(selector.settingsBtn).click(); + + // Verify it's open and alias the container for use in tests + cy.contains('.p-dialog-title', '2D Network Settings').should('be.visible') + .parents('.p-dialog').as('dialogContainer'); + }); + + context('Node settings', () => { + + beforeEach(() => { + // First, ensure the "Nodes" tab is active + cy.get('@dialogContainer').contains('.nav-link', 'Nodes').click(); + }); + + it('should update node size by clicking the UI and reflect in the network', () => { + const initialSize = 20; + const newSize = 75; + const expectedStyledSize = (newSize / 100 * 40) + 10; + + cy.window().its('commonService.session.style.widgets.node-radius').should('equal', initialSize); + + cy.get('@dialogContainer').contains('p-accordionTab', 'Shapes and Sizes').click(); + + cy.get('@dialogContainer').find(selector.nodeRadiusSize) + .invoke('val', newSize) + .trigger('change', { force: true }); + + cy.window().its('commonService.session.style.widgets.node-radius').should('equal', newSize); + + getCy().then((cyInstance) => { + const node = cyInstance.nodes().first(); + expect(parseFloat(node.style('width'))).to.be.closeTo(expectedStyledSize, 1); + }); + }); + + it('should update node label via dropdown', () => { + cy.get('@dialogContainer').contains('p-accordionTab', 'Labels and Tooltips').click(); + cy.window().its('commonService.session.style.widgets.node-label-variable').should('equal', 'None'); + + cy.get('@dialogContainer').find(selector.nodeLabelVar).click(); + cy.contains('li[role="option"]', 'Id').click(); + + cy.window().its('commonService.session.style.widgets.node-label-variable').should('equal', '_id'); + getCy().then(cy => { + const node = cy.nodes().first(); + expect(node.data('label')).to.equal(node.id()); + }); + }); + + it('should update node label size and orientation', () => { + const newSize = 36; + const newOrientation = 'Top'; + + cy.get('@dialogContainer').contains('p-accordionTab', 'Labels and Tooltips').click(); + cy.window().invoke('Cypress.test.setNodeLabel', '_id'); // Ensure labels are visible for testing + + cy.window().its('commonService.session.style.widgets.node-label-size').should('equal', 16); + cy.get('@dialogContainer').find(selector.nodeLabelSize).invoke('val', newSize).trigger('change', { force: true }); + cy.window().its('commonService.session.style.widgets.node-label-size').should('equal', newSize); + + cy.window().its('commonService.session.style.widgets.node-label-orientation').should('equal', 'Right'); + cy.get('@dialogContainer').find(selector.nodeLabelOrientation).select(newOrientation); + cy.window().its('commonService.session.style.widgets.node-label-orientation').should('equal', newOrientation); + + getCy().then(cy => { + const node = cy.nodes().first(); + expect(node.style('font-size')).to.contain(newSize); + expect(node.style('text-valign')).to.equal('top'); + }); + }); + + it('should update node border width via input', () => { + const initialWidth = 2.0; + const newWidth = 5; + + cy.get('@dialogContainer').contains('p-accordionTab', 'Shapes and Sizes').click(); + + cy.window().its('commonService.session.style.widgets.node-border-width').should('equal', initialWidth); + + cy.get('@dialogContainer').find(selector.nodeBorderWidth).clear().type(newWidth.toString()).blur(); + + cy.window().its('commonService.session.style.widgets.node-border-width').should('equal', newWidth); + getCy().then(cy => { + const node = cy.nodes().first(); + expect(parseFloat(node.style('border-width'))).to.be.closeTo(newWidth, 0.1); + }); + }); + + it('should update node tooltip variable and reflect in tooltip content', () => { + cy.get('@dialogContainer').contains('p-accordionTab', 'Labels and Tooltips').click(); + + cy.window().its('commonService.session.style.widgets.node-tooltip-variable').should('deep.equal', ['_id']); + + cy.get('@dialogContainer').contains('.form-group', 'Tooltip').find('p-multiselect').click(); + cy.contains('li[role="option"]', 'cluster').click(); + + cy.window().its('commonService.session.style.widgets.node-tooltip-variable').should('include', '_id'); + cy.window().its('commonService.session.style.widgets.node-tooltip-variable').should('include', 'cluster'); + + // Verify the tooltip content now includes both fields + const nodeId = 'MZ375596'; + cy.window().invoke('Cypress.test.tooltip', 'show', nodeId); + // Corrected Assertion: Check for the text inside the generated table within the tooltip + cy.get('#tooltip #tooltip-table').should('be.visible').within(() => { + cy.contains('td', 'id').should('be.visible'); + cy.contains('td', 'Cluster').should('be.visible'); + }); + }); + + it('should change node sizing to be by variable and reflect in the network', () => { + cy.get('@dialogContainer').contains('p-accordionTab', 'Shapes and Sizes').click(); + + cy.window().its('commonService.session.style.widgets.node-radius-variable').should('equal', 'None'); + cy.get('@dialogContainer').find('#node-radius-row').should('be.visible'); + cy.get('@dialogContainer').find('#node-max-radius-row').should('not.be.visible'); + + cy.get('@dialogContainer').find(selector.nodeRadiusVar).click(); + cy.contains('li[role="option"]', 'Degree').click(); + + cy.window().its('commonService.session.style.widgets.node-radius-variable').should('equal', 'degree'); + cy.get('@dialogContainer').find('#node-radius-row').should('not.be.visible'); + cy.get('@dialogContainer').find('#node-max-radius-row').should('be.visible'); + cy.get('@dialogContainer').find('#node-min-radius-row').should('be.visible'); + + getCy().then(cytoscapeInstance => { + // Select nodes with known different degrees for a reliable comparison + const nodeWithLowDegree = cytoscapeInstance.getElementById('MZ762276'); // A singleton, degree 0 + const nodeWithHighDegree = cytoscapeInstance.getElementById('MZ797703'); // High degree + + + // Log the underlying data for debugging + console.log('Low degree node data:', nodeWithLowDegree.data()); + console.log('High degree node data:', nodeWithHighDegree.data()); + + // CORRECTED: Use .style('width') which gets the computed style value after rendering. + const lowDegreeWidth = parseFloat(nodeWithLowDegree.style('width')); + const highDegreeWidth = parseFloat(nodeWithHighDegree.style('width')); + + console.log(`Low degree width: ${lowDegreeWidth}, High degree width: ${highDegreeWidth}`); + expect(lowDegreeWidth).to.be.lessThan(highDegreeWidth); + }); + }); + }); + context('Link settings', () => { + beforeEach(() => { + cy.get('@dialogContainer').contains('.nav-link', 'Links').click(); + }); + + it('should update link width by clicking the UI and reflect in the network', () => { + const initialWidth = 3; + const newWidth = 15; + + cy.window().its('commonService.session.style.widgets.link-width').should('equal', initialWidth); + + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Shapes and Sizes').click(); + + cy.get('@dialogContainer').find(selector.linkWidthSize) + .invoke('val', newWidth) + .trigger('change', { force: true }); + + cy.window().its('commonService.session.style.widgets.link-width').should('equal', newWidth); + + getCy().then((cyInstance) => { + const edge = cyInstance.edges().first(); + expect(parseFloat(edge.style('width'))).to.be.closeTo(newWidth, 1); + }); + }); + + it('should update link opacity via the slider', () => { + const newOpacity = 0.5; + + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Shapes and Sizes').click(); + + cy.window().its('commonService.session.style.widgets.link-opacity').should('equal', 0); + + cy.get('@dialogContainer').find(selector.linkOpacity).invoke('val', newOpacity).trigger('change', { force: true }); + + cy.window().its('commonService.session.style.widgets.link-opacity').should('equal', newOpacity); + + getCy().then(cy => { + const edge = cy.edges().first(); + expect(parseFloat(edge.style('line-opacity'))).to.be.closeTo(newOpacity, 0.01); + }); + }); + + it('should toggle link directionality arrows', () => { + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Shapes and Sizes').click(); + + cy.window().its('commonService.session.style.widgets.link-directed').should('be.false'); + getCy().then(cy => expect(cy.edges().first().style('target-arrow-shape')).to.equal('none')); + + cy.get('@dialogContainer').find(selector.showArrowsToggle).contains('Show').click(); + cy.window().its('commonService.session.style.widgets.link-directed').should('be.true'); + getCy().then(cy => expect(cy.edges().first().style('target-arrow-shape')).to.equal('triangle')); + + cy.get('@dialogContainer').find(selector.showArrowsToggle).contains('Hide').click(); + cy.window().its('commonService.session.style.widgets.link-directed').should('be.false'); + getCy().then(cy => expect(cy.edges().first().style('target-arrow-shape')).to.equal('none')); + }); + + it('should update link tooltip variable', () => { + cy.get('@dialogContainer').find('.tab-pane.active').should('be.visible').contains('p-accordionTab', 'Labels and Tooltips').click(); + + cy.window().its('commonService.session.style.widgets.link-tooltip-variable').should('be.empty'); + + cy.get('@dialogContainer').find('.tab-pane.active').contains('.form-group', 'Tooltip').find('p-multiselect').click(); + cy.contains('li[role="option"]', 'Distance').click(); + + cy.window().its('commonService.session.style.widgets.link-tooltip-variable').should('include', 'distance'); + + getCy().then((cyInstance: Core) => { + const edgeId = cyInstance.edges().first().id(); + cy.window().invoke('Cypress.test.linkTooltip', 'show', edgeId); + cy.get('#tooltip').should('be.visible').and('not.be.empty'); + }); + }); + + + // it('should change link sizing to be by variable', () => { + // cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Shapes and Sizes').click(); + + // cy.window().its('commonService.session.style.widgets.link-width-variable').should('equal', 'None'); + // cy.get('@dialogContainer').find('#link-width-row').should('be.visible'); + // cy.get('@dialogContainer').find('#link-max-width-row').should('not.be.visible'); + + // cy.get('@dialogContainer').find(selector.linkWidthVar).click(); + // cy.contains('li[role="option"]', 'Distance').click(); + + // cy.window().its('commonService.session.style.widgets.link-width-variable').should('equal', 'distance'); + // cy.get('@dialogContainer').find('#link-width-row').should('not.be.visible'); + // cy.get('@dialogContainer').find('#link-max-width-row').should('be.visible'); + // cy.get('@dialogContainer').find('#link-min-width-row').should('be.visible'); + // cy.get('@dialogContainer').find('#link-reciprocalthickness-row').should('be.visible'); + + // getCy().then(cy => { + // const edgeWithSmallDistance = cy.edges().filter(edge => edge.data('distance') < 0.01)[0]; + // const edgeWithLargeDistance = cy.edges().filter(edge => edge.data('distance') > 0.02)[0]; + + + // console.log(edgeWithLargeDistance); + // console.log(edgeWithSmallDistance); + // const smallDistWidth = parseFloat(edgeWithSmallDistance.style('width')); + // const largeDistWidth = parseFloat(edgeWithLargeDistance.style('width')); + + // // Because reciprocal is on by default, a smaller distance should result in a larger width. + // expect(smallDistWidth).to.be.greaterThan(largeDistWidth); + // }); + // }); + + // it('should update link length via the slider', () => { + // const newLength = 100; + + // cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Shapes and Sizes').click(); + + // cy.window().its('commonService.session.style.widgets.link-length').should('equal', 50); + + // cy.get('@dialogContainer').find(selector.linkLengthSlider).invoke('val', newLength).trigger('change', { force: true }); + + // cy.window().its('commonService.session.style.widgets.link-length').should('equal', newLength); + + // // This is an indirect visual test. We check that node positions have changed, + // // which implies the layout force was updated with the new link length. + // getCy().then(cyto => { + // const node1_initial_pos = cyto.nodes().first().position(); + // cy.get('@dialogContainer').find('[title="Recalculate Layout"]').click().then(() => { + // const node1_new_pos = cyto.nodes().first().position(); + // expect(node1_initial_pos.x).to.not.equal(node1_new_pos.x); + // }); + // }); + // }); + }); + context('Network settings', () => { + beforeEach(() => { + cy.get('@dialogContainer').contains('.nav-link', 'Network').click(); + }); + + it('should toggle network gridlines and update visibility', () => { + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Display').click(); + + cy.window().its('commonService.session.style.widgets.network-gridlines-show').should('be.false'); + cy.get('.grid-overlay').should('have.class', 'hidden'); + + cy.get('@dialogContainer').find(selector.showGridlinesToggle).contains('Show').click(); + cy.window().its('commonService.session.style.widgets.network-gridlines-show').should('be.true'); + cy.get('.grid-overlay').should('not.have.class', 'hidden'); + + cy.get('@dialogContainer').find(selector.showGridlinesToggle).contains('Hide').click(); + cy.window().its('commonService.session.style.widgets.network-gridlines-show').should('be.false'); + cy.get('.grid-overlay').should('have.class', 'hidden'); + }); + + it('should toggle neighbor highlighting', () => { + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Display').click(); + + cy.window().its('commonService.session.style.widgets.node-highlight').should('be.false'); + + cy.get('@dialogContainer').find(selector.neighborHighlightToggle).contains('Highlighted').click(); + cy.window().its('commonService.session.style.widgets.node-highlight').should('be.true'); + + cy.get('@dialogContainer').find(selector.neighborHighlightToggle).contains('Normal').click(); + cy.window().its('commonService.session.style.widgets.node-highlight').should('be.false'); + }); + }); + + context('Grouping settings', () => { + beforeEach(() => { + cy.get('@dialogContainer').contains('.nav-link', 'Grouping').click(); + }); + + it('should create and remove grouping polygons', () => { + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Controls').click(); + + cy.window().its('commonService.session.style.widgets.polygons-show').should('be.false'); + getCy().then(cy => expect(cy.nodes('.parent').length).to.equal(0)); + + cy.get('@dialogContainer').find(selector.showGroupsToggle).contains('Show').click(); + cy.window().its('commonService.session.style.widgets.polygons-show').should('be.true'); + getCy().then(cy => expect(cy.nodes('.parent').length).to.be.greaterThan(0)); + + cy.get('@dialogContainer').find(selector.showGroupsToggle).contains('Hide').click(); + cy.window().its('commonService.session.style.widgets.polygons-show').should('be.false'); + getCy().then(cy => expect(cy.nodes('.parent').length).to.equal(0)); + }); + + it('should toggle group label visibility', () => { + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Controls').click(); + cy.get('@dialogContainer').find(selector.showGroupsToggle).contains('Show').click(); + + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Labels').click(); + + cy.window().its('commonService.session.style.widgets.polygons-label-show').should('be.false'); + + cy.get('@dialogContainer').find(selector.groupLabelToggle).contains('Show').click(); + cy.window().its('commonService.session.style.widgets.polygons-label-show').should('be.true'); + getCy().then(cy => expect(cy.nodes('.parent').first().style('label')).to.not.be.empty); + + cy.get('@dialogContainer').find(selector.groupLabelToggle).contains('Hide').click(); + cy.window().its('commonService.session.style.widgets.polygons-label-show').should('be.false'); + getCy().then(cy => expect(cy.nodes('.parent').first().style('label')).to.be.empty); + }); + + // it('should change the grouping variable', () => { + // cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Controls').click(); + // cy.get('@dialogContainer').find(selector.showGroupsToggle).contains('Show').click(); + + // cy.window().its('commonService.session.style.widgets.polygons-foci').should('equal', 'cluster'); + + // cy.get('@dialogContainer').find(selector.groupByVar).click(); + // cy.contains('li[role="option"]', 'Subtype').click(); + + // cy.window().its('commonService.session.style.widgets.polygons-foci').should('equal', 'subtype'); + // getCy().then(cy => { + // const parent = cy.getElementById('30578_KF773488_D99cl05').parent(); + // expect(parent.id()).to.contain('B'); + // }); + // }); + + it('should update group label size and orientation', () => { + const newSize = 40; + const newOrientation = 'bottom'; + + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Controls').click(); + cy.get('@dialogContainer').find(selector.showGroupsToggle).contains('Show').click(); + cy.get('@dialogContainer').find('.tab-pane.active').contains('p-accordionTab', 'Labels').click(); + cy.get('@dialogContainer').find(selector.groupLabelToggle).contains('Show').click(); + + cy.window().its('commonService.session.style.widgets.polygons-label-size').should('equal', 16); + cy.get('@dialogContainer').find(selector.groupLabelSize).invoke('val', newSize).trigger('change', { force: true }); + cy.window().its('commonService.session.style.widgets.polygons-label-size').should('equal', newSize); + + cy.window().its('commonService.session.style.widgets.polygon-label-orientation').should('equal', 'top'); + cy.get('@dialogContainer').find(selector.groupLabelOrientation).select(newOrientation); + cy.window().its('commonService.session.style.widgets.polygon-label-orientation').should('equal', newOrientation); + + getCy().then(cy => { + const parentNode = cy.nodes('.parent').first(); + expect(parentNode.style('font-size')).to.contain(newSize); + expect(parentNode.style('text-valign')).to.equal(newOrientation); + }); + }); + }); +}); + + + // Test suite for mouse interactions + + describe('2D Network - Mouse Interactions', () => { + const getCy = () => cy.window({ log: false }).its('cytoscapeInstance'); + + beforeEach(() => { + cy.visit('/'); + cy.wait(6000); + + cy.get('button:contains("Continue with Sample Dataset")', { timeout: 10000 }) + .click({ force: true }); + + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + + cy.window({ timeout: 15000 }).should('have.property', 'cytoscapeInstance'); + }); + + it('should select a single node and reflect the change visually', () => { + const nodeIdToSelect = 'MZ375596'; + + // 1. Verify nothing is selected + getCy().then((cyInstance: Core) => { + expect(cyInstance.elements(':selected').length).to.equal(0); + }); + + // 2. Manually set the selection state in the application's data model + cy.window().then(win => { + const node = win.commonService.session.data.nodes.find(n => n._id === nodeIdToSelect); + win.commonService.session.data.nodes.forEach(n => n.selected = false); + node.selected = true; + }); + + // 3. Manually trigger the event that tells the component to update its view from the data model + cy.document().trigger("node-selected"); + + // 4. Verify the node is now visually selected in Cytoscape + getCy().then((cyInstance: Core) => { + cy.wrap(cyInstance.elements(':selected')).should('have.length', 1) + .then(selected => { + expect(selected.id()).to.equal(nodeIdToSelect); + }); + }); + }); + + it('should select multiple nodes by simulating a shift-click', () => { + const node1_id = 'MZ375596'; + const node2_id = 'MZ696569'; + + getCy().then((cyInstance: Core) => { + const node1 = cyInstance.getElementById(node1_id); + const node2 = cyInstance.getElementById(node2_id); + + // 1. Programmatically select the first node. This uses Cytoscape's internal selection. + node1.select(); + cy.wrap(cyInstance.elements(':selected')).should('have.length', 1); + + // 2. Simulate a SHIFT-CLICK on the second node. This triggers Cytoscape's + // internal multi-select logic because the 'shiftKey' is present. + node2.emit('tap', { originalEvent: { shiftKey: true } }); + + // 3. Directly select the second node as well to ensure the state is additive. + node2.select(); + + // 4. FINAL VERIFICATION: Check if both nodes are now selected in the view. + cy.wrap(cyInstance.elements(':selected')).should('have.length', 2) + .then(selectedElements => { + const selectedIds = selectedElements.map(el => el.id()); + expect(selectedIds).to.include(node1_id); + expect(selectedIds).to.include(node2_id); + }); + }); + }); + + // it('should show and hide a tooltip on node hover', () => { + // cy.get('#tooltip').should('not.be.visible'); + + // getCy().then((cyInstance: Core) => { + // const nodeToHover = cyInstance.nodes()[0]; + // const nodeId = nodeToHover.id(); + + // // 1. Use the reliable helper to show the tooltip + // cy.window().invoke('Cypress.testTooltip', 'show', nodeId); + + // // 2. Verify visibility and content + // cy.get('#tooltip').should('be.visible').and('contain.text', nodeId); + + // // 3. Use the helper to hide the tooltip + // cy.window().invoke('Cypress.testTooltip', 'hide', nodeId); + + // // 4. Verify it's hidden + // cy.get('#tooltip').should('not.be.visible'); + // }); + // }); + + // it('should show and hide a tooltip on link hover', () => { + // // 1. Initial State: Verify the tooltip is not visible. + // cy.get('#tooltip').should('not.be.visible'); + + // getCy().then((cyInstance: Core) => { + // // Find the first visible edge to make the test robust. + // const edgeToHover = cyInstance.edges(':visible')[0]; + // const edgeId = edgeToHover.id(); + // const sourceNodeId = edgeToHover.source().id(); // Get source ID for content check + + // // 2. Action: Use the reliable helper to show the tooltip. + // cy.window().invoke('Cypress.linkTooltip', 'show', edgeId); + + // // 3. Verification: Check that the tooltip is visible and contains relevant info (like the source node's ID). + // cy.get('#tooltip').should('be.visible').and('contain.text', sourceNodeId); + + // // 4. Action: Use the helper to hide the tooltip. + // cy.window().invoke('Cypress.linkTooltip', 'hide', edgeId); + + // // 5. Final State: Verify the tooltip is hidden again. + // cy.get('#tooltip').should('not.be.visible'); + // }); + // }); + + // This test in twod-plugin.cy.ts is now correct and will pass. + it('should allow node MZ740979 to be dragged to a new position', () => { + const nodeId = 'MZ740979'; + + getCy().then((cyInstance: Core) => { + const node = cyInstance.getElementById(nodeId); + + // sanity checks + expect(node.empty(), `node ${nodeId} should exist in Cytoscape`).to.be.false; + expect(node.children().length, 'should not be compound parent').to.equal(0); + expect(node.hasClass('parent'), 'should not have parent class').to.be.false; + expect(node.hasClass('hidden'), 'should not be hidden').to.be.false; + + const initial = { ...node.position() }; + + cy.window().then(win => { + const after = win.Cypress.test.dragNodeDelta(nodeId, 100, 50); + // guard in case helper returned null + expect(after, 'drag helper returned a position').to.not.be.null; + + expect(after.x, 'rendered X').to.be.closeTo(initial.x + 100, 1); + expect(after.y, 'rendered Y').to.be.closeTo(initial.y + 50, 1); + + // optional: also assert the backing data model saw the change + const backingNode = + win.commonService.session.data.nodes.find((n: any) => n._id === nodeId); + expect(backingNode.x, 'model X').to.be.closeTo(after.x, 1); + expect(backingNode.y, 'model Y').to.be.closeTo(after.y, 1); + }); + }); + }); + +}); + +// \u00A0 \ No newline at end of file diff --git a/cypress/fixtures/AngularTesting_DistanceMatrix_TN93_BS.xlsx b/cypress/fixtures/AngularTesting_DistanceMatrix_TN93_BS.xlsx new file mode 100644 index 00000000..6242a1fa Binary files /dev/null and b/cypress/fixtures/AngularTesting_DistanceMatrix_TN93_BS.xlsx differ diff --git a/cypress/fixtures/AngularTesting_Distance_linklist_BS.csv b/cypress/fixtures/AngularTesting_Distance_linklist_BS.csv new file mode 100644 index 00000000..b17ed433 --- /dev/null +++ b/cypress/fixtures/AngularTesting_Distance_linklist_BS.csv @@ -0,0 +1,92 @@ +source,target,distance +KF773571,KF773578,0.00071 +KF773579,KF773578,0.000711 +KF773579,KF773571,0.001421 +KF773576,KF773578,0.001421 +KF773576,KF773571,0.002133 +KF773576,KF773579,0.002134 +KF773472,KF773426,0.005722 +KF773429,KF773432,0.00787 +KF773425,KF773426,0.007872 +KF773425,KF773472,0.010769 +KF773430,KF773432,0.010783 +KF773426,KF773578,0.013647 +KF773426,KF773579,0.014373 +KF773440,KF773430,0.014375 +KF773426,KF773571,0.014379 +KF773431,KF773430,0.014389 +KF773429,KF773430,0.014409 +KF773472,KF773578,0.0151 +KF773426,KF773576,0.015105 +KF773431,KF773440,0.015815 +KF773431,KF773578,0.015819 +KF773472,KF773579,0.015826 +KF773472,KF773571,0.015834 +KF773440,KF773578,0.016528 +KF773431,KF773579,0.01654 +KF773431,KF773571,0.016555 +KF773472,KF773576,0.01656 +KF773440,KF773432,0.016568 +KF773431,KF773432,0.016584 +KF773440,KF773579,0.017253 +KF773440,KF773571,0.017263 +KF773431,KF773576,0.017276 +KF773429,KF773431,0.017282 +KF773430,KF773578,0.017283 +KF773477,KF773476,0.017295 +KF773440,KF773576,0.017987 +KF773432,KF773578,0.018002 +KF773430,KF773579,0.018002 +KF773430,KF773571,0.018022 +KF773432,KF773579,0.018724 +KF773432,KF773571,0.018741 +KF773430,KF773576,0.018741 +KF773432,KF773576,0.019463 +KF773425,KF773578,0.020254 +KF773476,KF773578,0.020257 +KF773425,KF773579,0.020987 +KF773476,KF773579,0.020996 +KF773425,KF773571,0.020997 +KF773476,KF773571,0.020998 +KF773429,KF773578,0.021657 +KF773429,KF773440,0.021711 +KF773425,KF773576,0.021731 +KF773476,KF773576,0.021737 +KF773431,KF773472,0.022371 +KF773431,KF773426,0.022384 +KF773429,KF773579,0.022385 +KF773429,KF773571,0.0224 +KF773440,KF773426,0.023102 +KF773429,KF773576,0.023128 +KF773430,KF773472,0.023821 +KF773430,KF773426,0.023832 +KF773429,KF773472,0.023844 +KF773429,KF773426,0.023859 +KF773476,KF773426,0.023929 +KF773432,KF773472,0.024572 +KF773440,KF773472,0.024574 +KF773432,KF773426,0.024586 +KF773476,KF773472,0.025406 +KF773431,KF773425,0.026074 +KF773477,KF773578,0.026224 +KF773476,KF773432,0.026839 +KF773477,KF773579,0.026954 +KF773477,KF773571,0.026983 +KF773425,KF773430,0.027532 +KF773477,KF773576,0.027713 +KF773425,KF773440,0.028293 +KF773429,KF773425,0.029049 +KF773476,KF773429,0.029119 +KF773476,KF773425,0.029158 +KF773425,KF773432,0.029788 +KF773476,KF773440,0.029833 +KF773477,KF773426,0.029971 +KF773476,KF773430,0.030567 +KF773477,KF773432,0.031318 +KF773477,KF773472,0.031472 +KF773477,KF773430,0.033578 +KF773476,KF773431,0.033637 +KF773477,KF773429,0.033648 +KF773477,KF773440,0.034373 +KF773477,KF773425,0.035249 +KF773477,KF773431,0.038236 diff --git a/cypress/fixtures/AngularTesting_Epi_linklist_BS.csv b/cypress/fixtures/AngularTesting_Epi_linklist_BS.csv new file mode 100644 index 00000000..c5573564 --- /dev/null +++ b/cypress/fixtures/AngularTesting_Epi_linklist_BS.csv @@ -0,0 +1,8 @@ +source,target,Contact +KF773571,KF773578,Bar +KF773576,KF773579,Dating app +KF773426,KF773427,Bar +KF773432,KF773429,Dating app +KF773426,KF773425,Friend +KF773430,KF773429,Friend +KF773426,KF773578,Friend diff --git a/cypress/fixtures/AngularTesting_nodelist_withseqs_TN93_BS.csv b/cypress/fixtures/AngularTesting_nodelist_withseqs_TN93_BS.csv new file mode 100644 index 00000000..2a916b3e --- /dev/null +++ b/cypress/fixtures/AngularTesting_nodelist_withseqs_TN93_BS.csv @@ -0,0 +1,15 @@ +_id,selected,cluster,seq,gender,transmission risk,subtype,Co-infection with other STIs,Diagnosis date,ipstart,ipend,age,zip +KF773425,FALSE,0,aatttggccttccaacaaggggaggccagggaatttccttcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccaaagcaggaatcgaaagacaaggaaccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggccagataaaggaagctctcttagatacgggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaggttaaacaatggccattgacagaagaaaaaataaaagcattaacagcgatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagcagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgagaaaattaaattgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttaggggagtcaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatggcccatca-,F,PWID,C,N,7/4/2007,7/26/2013,11/27/2014,40,47112 +KF773426,FALSE,0,aatttggccttccaacaaggggaggccagggaatttccttcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccaaagcaggaatcgaaagacaaggaaccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaggttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtgctggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccggggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca-,F,HET,C,N,8/1/2007,1/28/2014,7/14/2014,47,47112 +KF773427,FALSE,0,aatttggccttccaacaaggggaggccagggaatttccttcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccaaagcaggaatcgaaagacagggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggcccgataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaggaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtgctggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtagaatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca-,F,PWID,C,N,7/30/2007,5/3/2014,7/29/2014,51,47112 +KF773576,FALSE,1,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtgtgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaatccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,M,PWID,B,N,4/29/2005,12/27/2007,6/2/2009,37,47112 +KF773578,FALSE,1,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,M,MSM-PWID,B,N,3/27/2005,Tue Oct 28 2003 00:00:00 GMT-0500 (Eastern Standard Time),Sun Jun 06 2004 00:00:00 GMT-0400 (Eastern Daylight Time),52,47112 +KF773571,FALSE,1,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaagttacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,M,PWID,B,Y,9/25/2005,6/13/2004,10/10/2004,33,47112 +KF773579,FALSE,1,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtacattatgacccatca-,M,MSM,B,N,8/7/2005,Tue Oct 28 2003 00:00:00 GMT-0500 (Eastern Standard Time),Sun Jun 06 2004 00:00:00 GMT-0400 (Eastern Daylight Time),52,47112 +KF773429,FALSE,2,aatttggccttcccacaaggggaggccagggaatttcattcagaacag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaaataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactagaaaaggatggaaaaattacaaaaattgggcctgacaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagtccaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcaattcctttagatgagagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttatggaggtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaggaaagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcaaatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,F,PWID,D,N,10/1/2014,6/23/2014,10/23/2014,41,40117 +KF773430,FALSE,2,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacctccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaaataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctgtaggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactggaaaaggatggaaaaattacaaaaattgggcctgacaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactagatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttatggaagtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagaaaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,F,PWID,D,N,9/24/2014,Tue Oct 28 2003 00:00:00 GMT-0500 (Eastern Standard Time),Sun Jun 06 2004 00:00:00 GMT-0400 (Eastern Daylight Time),50,40117 +KF773431,FALSE,2,aatctggccttccaacaaggggaggccagggaatttcattcagaacag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaagaacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcctacttttcagttcctttagatgaaagcttcaggaagtatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttatggaggtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaggagagctggactgtcaatgacatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggaaccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,F,PWID,D,N,10/26/2014,6/20/2014,12/6/2014,18,40117 +KF773432,FALSE,2,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactggaaaaggatggaaaaattacaaaaattgggcctgacaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagtccaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcaattcctttagatgagagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagaacaaaaatagaggagttaagagaacatttatggaagtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaggaaagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaggtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,F,PWID,D,N,8/29/2014,Tue Oct 28 2003 00:00:00 GMT-0500 (Eastern Standard Time),Sun Jun 06 2004 00:00:00 GMT-0400 (Eastern Daylight Time),30,40117 +KF773440 ,FALSE,4,aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------gctagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgcgccgaagcaggaatcgaaggacaaggagccacccttaacctccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacgcctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaattggaaaaggaaggaaaaatttcaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagaacaaaaatagaggagttaagagaacatttatggaagtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaattatgtaaactccttagaggaaccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,F,PWID,C,N,4/27/2015,10/21/2014,5/21/2015,26,40117 +KF773476,FALSE,5,aatttggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttctctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaggtaaaggaagctctcttagatacaggagcagatgatacagtattagaagacttaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaaggaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattgaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgctataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagtccaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgagagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccttttaggacaaaaaacccaaacatagttatctatcagtatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaagagttaagagaacatttattgaagtggggacttaccactccagataagaagcatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagctagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaagcaactatgtaaactccttaggggagccaaagcactaacagacatagtaccactgactgaagaggcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca-,F,HET,C,N,6/22/2013,Tue Oct 28 2003 00:00:00 GMT-0500 (Eastern Standard Time),Sun Jun 06 2004 00:00:00 GMT-0400 (Eastern Daylight Time),47,47136 +KF773477,FALSE,6,aatttggccttccaacaaggggaggccaggaaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaggtaatggaagctctcttagatacaggagcagatgatacagtattagaagacataaatttgccaggaaaatggaaaccaaaaatggtaggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctatagggtcagtgttagtaggacctacacctgtcaacataattggaaggaatatgttgactcaacttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttagacaatggccattgacagaagaaaagataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctagatgtgggggatgcatatttttcagttcctttagataagagctttaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggatgagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacgaaaaacccaaacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaagtggggacttaccactccagataagaagcatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagaaagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaagcaactatgtaaactccttaggggagccaaagcactaacagacatagtaccactgactgaagaggcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca-,F,PWID,C,N,5/14/2010,Tue Oct 28 2003 00:00:00 GMT-0500 (Eastern Standard Time),Sun Jun 06 2004 00:00:00 GMT-0400 (Eastern Daylight Time),37,47136 diff --git a/cypress/fixtures/AngularTesting_nodes_Map.csv b/cypress/fixtures/AngularTesting_nodes_Map.csv new file mode 100644 index 00000000..da8d43a6 --- /dev/null +++ b/cypress/fixtures/AngularTesting_nodes_Map.csv @@ -0,0 +1,5 @@ +_id,seq,subtype,lat,long +KF773425,tgctccaaagcaggaatcgaaagacaaggaaccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggccagataaaggaagctctcttagatacgggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaggttaaacaatggccattgacagaagaaaaaataaaagcattaacagcgatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagcagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgagaaaattaaattgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttaggggagtcaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatggcccatca-,F,51.495,-0.1407 +KF773426,tgctccaaagcaggaatcgaaagacaaggaaccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaggttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtgctggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccggggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca-,F,51.513333,-0.136667 +KF773427,tgctccaaagcaggaatcgaaagacagggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggcccgataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaggaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtgctggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtagaatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca-,F,51.499,-0.1315 +KF773576,tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtgtgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaatccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca-,M,51.514,-0.129 \ No newline at end of file diff --git a/cypress/fixtures/AngularTesting_seqs_TN93_BS.fasta b/cypress/fixtures/AngularTesting_seqs_TN93_BS.fasta new file mode 100644 index 00000000..050363c1 --- /dev/null +++ b/cypress/fixtures/AngularTesting_seqs_TN93_BS.fasta @@ -0,0 +1,28 @@ +>KF773425 +aatttggccttccaacaaggggaggccagggaatttccttcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccaaagcaggaatcgaaagacaaggaaccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggccagataaaggaagctctcttagatacgggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaggttaaacaatggccattgacagaagaaaaaataaaagcattaacagcgatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagcagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgagaaaattaaattgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttaggggagtcaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatggcccatca- +>KF773426 +aatttggccttccaacaaggggaggccagggaatttccttcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccaaagcaggaatcgaaagacaaggaaccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaggttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtgctggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccggggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca- +>KF773427 +aatttggccttccaacaaggggaggccagggaatttccttcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccaaagcaggaatcgaaagacagggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtctcaataaaagtagggggcccgataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaggaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtgctggatgtgggggatgcatacttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgataaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtagaatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctatacatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca- +>KF773576 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtgtgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaatccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773578 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773571 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaagttacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773579 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacacaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaggtggggatttaccactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaagacaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtacattatgacccatca- +>KF773429 +aatttggccttcccacaaggggaggccagggaatttcattcagaacag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaaataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactagaaaaggatggaaaaattacaaaaattgggcctgacaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagtccaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcaattcctttagatgagagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttatggaggtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaggaaagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcaaatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773430 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacctccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaaataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctgtaggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactggaaaaggatggaaaaattacaaaaattgggcctgacaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactagatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttatggaagtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagaaaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773431 +aatctggccttccaacaaggggaggccagggaatttcattcagaacag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatctgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccaatatttgccataaaaaagaagaacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcctacttttcagttcctttagatgaaagcttcaggaagtatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaacccagacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttatggaggtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaggagagctggactgtcaatgacatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaactatgtaaactccttagaggaaccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773432 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaactggaaaaggatggaaaaattacaaaaattgggcctgacaatccatataacactccagtatttgccataaaaaagaaggacagtactaagtggagaaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagtccaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcaattcctttagatgagagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagaacaaaaatagaggagttaagagaacatttatggaagtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaagctgccagaaaaggaaagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaggtaaggcaactatgtaaactccttagaggagccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773440 +aatctggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------gctagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgcgccgaagcaggaatcgaaggacaaggagccacccttaacctccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccagataaaggaagctctcttagatacaggagcagatgatacagtattagaagaattaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacaatatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacgcctgtcaacataattggaagaaatatgttgactcagcttggatgtacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagaaatttgtgaagaattggaaaaggaaggaaaaatttcaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaagaagtcagtgacagtactggatgtgggggatgcatatttttcagttcctttagatgaaagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacagggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacaaaaaaccctgacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagaacaaaaatagaggagttaagagaacatttatggaagtggggattttacactccagacaagaaacatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaggcaattatgtaaactccttagaggaaccaaagcactaacagacatagtaccactgactgaagaagcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggggtatattatgacccatca- +>KF773476 +aatttggccttccaacaaggggaggccagggaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaagacaaggagccacccttaacttctctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaggtaaaggaagctctcttagatacaggagcagatgatacagtattagaagacttaaatttgccaggaaaatggaaaccaaaaatgataggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctataggttcagtattagtaggacctacacctgtcaacataattggaaggaatatgttgactcagcttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattgaagccaggaatggatggcccaaaagttaaacaatggccattgacagaagaaaaaataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgctataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagtccaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctggatgtgggggatgcatatttttcagttcctttagatgagagcttcaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggattagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccttttaggacaaaaaacccaaacatagttatctatcagtatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaagagttaagagaacatttattgaagtggggacttaccactccagataagaagcatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagagagctggactgtcaatgatatacagaagctagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaagcaactatgtaaactccttaggggagccaaagcactaacagacatagtaccactgactgaagaggcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca- +>KF773477 +aatttggccttccaacaaggggaggccaggaaatttcattcagagcag---------------------------------actagagccaacagccccaccagcagagagcttcaagttcgaggagacaacccc---------------------tgctccgaagcaggaatcgaaggacaaggagccacccttaacttccctcaaatcactctttggcagcgaccccttgtcacaataaaagtagggggccaggtaatggaagctctcttagatacaggagcagatgatacagtattagaagacataaatttgccaggaaaatggaaaccaaaaatggtaggaggaattggaggttttatcaaagtaagacagtatgatcaaatagttatagaaatttgtgggaaaaaagctatagggtcagtgttagtaggacctacacctgtcaacataattggaaggaatatgttgactcaacttggatgcacactaaattttccaattagtcccattgagactgtaccagtaaaattaaagccaggaatggatggcccaaaagttagacaatggccattgacagaagaaaagataaaagcattaacagcaatttgtgaagaaatggaaaaggaaggaaaaattacaaaaattgggcctgaaaatccatataacactccagtatttgccataaaaaagaaggacagtactaaatggaggaaattagtagatttcagggaactcaataaaagaactcaagacttttgggaagttcaattaggaataccacacccagcagggttaaaaaagaaaaagtcagtgacagtgctagatgtgggggatgcatatttttcagttcctttagataagagctttaggaaatatactgcattcaccatacctagtataaacaatgaaacaccagggatgagatatcaatataatgtacttccacaaggatggaaaggatcaccagcaatattccagagtagcatgacaaaaatcttagagccctttaggacgaaaaacccaaacatagttatctatcaatatatggatgacttgtatgtaggatctgacttagaaatagggcaacatagagcaaaaatagaggagttaagagaacatttattgaagtggggacttaccactccagataagaagcatcagaaagaacccccatttctgtggatggggtatgaactccatcctgacaaatggacagtacagcctataaatctgccagaaaaagaaagctggactgtcaatgatatacagaagttagtgggaaaattaaactgggcaagtcagatttacccagggattaaagtaaagcaactatgtaaactccttaggggagccaaagcactaacagacatagtaccactgactgaagaggcagaattagaattggcagagaacagggaaattctaaaagaaccagtacatggagtatattatgacccatca- diff --git a/cypress/fixtures/AngularTesting_seqs_TN93_BS.nwk b/cypress/fixtures/AngularTesting_seqs_TN93_BS.nwk new file mode 100644 index 00000000..36f84c02 --- /dev/null +++ b/cypress/fixtures/AngularTesting_seqs_TN93_BS.nwk @@ -0,0 +1 @@ +((((((KF773429:0.00510968,KF773432:0.00283059)0.9410:0.00347970,KF773430:0.00533432)0.7240:0.00220379,KF773431:0.00730644)0.4220:0.00059841,KF773440:0.00798117)0.9390:0.00500202,(KF773578:0.00000000,(KF773579:0.00070210,(KF773576:0.00143018,KF773571:0.00070736)0.4730:0.00001045)0.5370:0.00002647)1.0000:0.00385468)0.5960:0.00129384,(KF773427:0.00323458,(KF773425:0.00680612,KF773426:0.00113684)0.7890:0.00113016)0.9990:0.00687637,(KF773476:0.00598886,KF773477:0.01158715)1.0000:0.01002916); diff --git a/cypress/fixtures/COVID-19_simulated_ContactTracing_snp.csv b/cypress/fixtures/COVID-19_simulated_ContactTracing_snp.csv new file mode 100644 index 00000000..ce1eaff1 --- /dev/null +++ b/cypress/fixtures/COVID-19_simulated_ContactTracing_snp.csv @@ -0,0 +1,41 @@ +source,target,Contact type,,Exposure,Case status confirmed? +MZ797703,MZ797980,sports team,,high,Y +MZ797703,MZ745515,sports team,,med,N +MZ797703,MZ797832,classroom,,high,N +MZ797703,MZ415508,classroom,,low,N +MZ797703,MZ505967,classroom,,high,Y +MZ727698,MZ727700,party,,med,Y +MZ727698,MZ759709,party,,low,Y +MZ375596,MZ797980,classroom,,low,Y +MZ797832,MZ375596,classroom,,high,N +MZ505967,MZ415508,sports team,,low,N +MZ797703,MZ375596,family member,,med,N +MZ797965,MZ375596,family member,,low,Y +MZ745181,MZ375596,family member,,high,Y +MZ798055,MZ375596,family member,,high,Y +MZ797839,MZ375596,classroom,,high,Y +MZ727700,MZ727701,classroom,,high,Y +MZ637292,MZ375596,sports team,,med,Y +MZ637292,MZ797748,sports team,,med,N +MZ712879,MZ745515,sports team,,med,N +MZ787305,MZ740979,sports team,,med,N +MZ696569,MZ591568,sports team,,high,N +MZ727698,MZ727689,classroom,,high,Y +MZ797980,MZ762276,family member,,high,Y +MZ797735,MZ744384,family member,,low,Y +MZ797519,MZ797735,classroom,,low,Y +P1,MZ727700,,,low,Y +P1,MZ727701,,,low,N +P1,MZ591568,,,low,N +P1,MZ727689,,,low,N +P1,MZ744384,,,low,N +P1,MZ797735,,,low,N +P2,MZ797980,,,low,N +P2,MZ745515,,,low,N +P2,MZ797832,,,low,N +P2,MZ415508,,,low,N +P3,MZ375596,,,low,N +P3,MZ797832,,,low,N +P3,MZ505967,,,low,N +P3,MZ797703,,,low,N +P3,MZ797965,,,low,N diff --git a/cypress/fixtures/COVID-19_simulated_NodeList_snp.csv b/cypress/fixtures/COVID-19_simulated_NodeList_snp.csv new file mode 100644 index 00000000..cebd142d --- /dev/null +++ b/cypress/fixtures/COVID-19_simulated_NodeList_snp.csv @@ -0,0 +1,34 @@ +ID,seq,Virus_Name,Lineage,WHO_class,Collection_Date,Date of symptom onset Date,Date symptoms resolved,State,Co-infected wuth flu,Zip_code,Node_Class,Profession,Viral loads,Node type,Virus source +MZ505967,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaagacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaagtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttatcttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcaactggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggattattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacttatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagcatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgttacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttattaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaacaaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgttatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttagggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagactcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttcaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacatgaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacagactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcacaaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcaccacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaattacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtcttataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,SARS-CoV-2/human/USA/AZ-4001/2021,B.1.617.1,,7/12/2021,7/9/2021,7/15/2021,Arizona,Y,85123,VOI,Other ,,Person,Human +MZ375596,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagatttgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/CO-CDC-MMB08712754/2021,B.1.617.2,Delta,8/8/2021,8/5/2021,8/11/2021,Colorado,Y,80301,VOC,service industry,,Person,Human +MZ727698,--atctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctnnnnnnnnnnnnnnnnttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcatacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataacnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagyacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctttagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagawgtatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaatagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacttttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcttcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttttctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagttcagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaacagggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcg-gtgtac--------------------------------------------------------------------------,hCoV-19/USA/CT-CDC-2-4651563/2021,B.1.621,,7/5/2021,7/2/2021,7/8/2021,Connecticut,Y,32803,Lineage,service industry,,Person,Human +MZ727689,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcatacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccagcagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctggttttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgactagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctttagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaataaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaatagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacttttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcttcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagtttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttttctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttc-tctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagttcagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaacagggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtac--------------------------------------------------------------------------,hCoV-19/USA/FL-CDC-2-4653463/2021,B.1.621,,7/18/2021,7/15/2021,7/21/2021,Florida,N,32803,Lineage,service industry,,Person,Human +MZ740979,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataattaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcaactcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaatatcataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagatggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctatctgtgtggaaactaaagctatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtactnnnattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctgtttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagggaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcctacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaatctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttacttacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgatcctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattacgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcnnnnnnnnaccattcttatgttgtaaatgctgttannnnnnnntcatatcaacatcacataaattagtcttgtctgttnnnnnnnntgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacacgtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttctagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcacctttagaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactacacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaggctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaactacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgttttttttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtggttcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggcnnnnnnnncaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccatgttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttactacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaataacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgatactgatacaagcctcactccttttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgatgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacgnngtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcataactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctattaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactctaggcagcagtaggggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatatctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggttccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgnnnnnnnnnnnnnnntgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/FL-CDC-ASC210158290/2021,B.1.526,Iota,7/15/2021,7/12/2021,7/18/2021,Florida,N,32804,VOI,Education,,Person,Human +MZ759709,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtatacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcctacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgtattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacacgtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcgaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgttttttttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtggttcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttctgattttgttcgcgctactgcaacgataccgatacaagcctcactccttttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctctaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatagcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgattttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcataactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactctaggcagcagtaaacgaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatatctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctatacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttctgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/FL-CDC-QDX27028134/2021,B.1.526,Iota,7/17/2021,7/14/2021,7/20/2021,Florida,N,32807,VOI,Education,,Person,Human +MZ761907,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaagnnnnnnnggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatnnnntggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtnnnnnnnnnnnnnnnnnnnnattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaaggtgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcnnnnnnnnnnnnnnnnnnnnnttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgnnnnnnnnnnnnnnncacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctnnaaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagtnntctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagannnnnnnnnnnnnnnnnnnnnttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaanactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatgnnnnnnctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttannnnnnnnnnnnnnnnnnnagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttnntagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggnnnnnnnnnnnnnnnnnnnnnnnnnntaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtatttccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatnngaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttgnnnnnnncgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctannnnnnnnnaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtgatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatctctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/FL-CDC-FG-058353/2021,B.1.617.2,Delta,8/1/2021,7/29/2021,8/4/2021,Florida,N,32804,VOC,Manufacturing,,Person,Human +MZ787305,------------------aactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatttaaagttgcgtagtgatgtgctattacctcctacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaattcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaaggtgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcgcgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttattggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacacgtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattgagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgttttttttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtggttcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccttttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcataactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctattaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactctaggcagcagtaggggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatatctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaacctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgagtccacgcggagtacgatcgagtgtacattgaacaatgctagggagagctg--------------------------------------------------,hCoV-19/USA/FL-CDC-LC0100283/2021,B.1.526,Iota,7/1/2021,6/28/2021,7/4/2021,Florida,N,32804,VOI,Other ,,Person,Human +MZ797519,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattattttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccatctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattacaatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggctttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcgggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgatgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataggcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaggctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgatgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcacttttttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaataatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaattttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaatttttctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacacacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtgcatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtggacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/FL-CDC-QDX27272258/2021,B.1.1.7,Alpha,7/25/2021,7/22/2021,7/28/2021,Florida,N,32789,VOC,Hospitality,,Person,Human +MZ797735,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaacagctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattacaatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgtaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttattaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaacagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcttattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaatttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgatgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaactgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaacccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattatatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctatttacttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaattgtgcgtggatgaggctggttcttaatcacccattcagtgcatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/FL-CDC-QDX27272212/2021,B.1.1.7,Alpha,7/28/2021,7/25/2021,7/31/2021,Florida,Y,32801,VOC,Student,,Person,Human +MZ797839,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagattgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatatctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatattttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacatatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgtcctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtttgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattatgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcatttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattacccccttcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaattcaattgagtacagacactggtgttgaacatgttacattcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcataaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/FL-CDC-QDX27272273/2021,B.1.617.2,Delta,7/31/2021,7/28/2021,8/3/2021,Florida,Y,32807,VOC,Healthcare,,Person,Human +MZ637292,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattgtacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgttgcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtgagtgtggagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaattacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgactacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttaattttaatctaaacgaacaaactaaaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccc---------------------------------,hCoV-19/USA/LA-BIE-LSUH001140/2021,B.1.617.2,Delta,7/19/2021,7/16/2021,7/22/2021,Louisiana,Y,70114,VOC,Healthcare,,Person,Human +MZ712835,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacnnctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaagtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcccatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaatttcttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagtaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggntgtttatt---accacaaaaacaacaaaagttggatggaaagtgnnnnnngagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccaggtcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaanatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgannacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttannnttaatctaaacgaacaaactnaaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggagtacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccc---------------------------------,hCoV-19/USA/LA-BIE-LSUH001778/2021,B.1.617.2,Delta,8/1/2021,7/29/2021,8/4/2021,Louisiana,N,70117,VOC,Education,,Person,Human +MZ712879,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagattgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacagacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgattactaccacacaactgatcttagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacnctttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcatcacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagttctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaattgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaataagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtntacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtttagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaactagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggntgtttatt---accacaaaaacaacaaaagttggatggaaagtgnnnnnngagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggttttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctatagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaanatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgannacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttannnttaatctaaacgaacaaactnaaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttgttggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccc---------------------------------,hCoV-19/USA/LA-BIE-LSUH001786/2021,B.1.617.2,Delta,8/1/2021,7/29/2021,8/4/2021,Louisiana,N,70113,VOC,Student,,Person,Human +MZ744285,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaatatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacctacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagacaacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttattagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattacaatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcattccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaacactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgctaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaatcctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgatgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgttgtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttcttttttttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaatcttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctataagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaattgtgcgtggatgaggctggttcttaatcacccattcagtgcatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacttggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/LA-CDC-ASC210160735/2021,B.1.1.7,Alpha,7/18/2021,7/15/2021,7/21/2021,Louisiana,N,70032,VOC,Healthcare,,Person,Human +MZ744384,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaatatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattacaatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcattccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaggacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttctcttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgctaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgatgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaattgttcgtggatgaggctggttcttaatcacccattcagtgcatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcaccctgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcattgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/LA-CDC-ASC210160862/2021,B.1.1.7,Alpha,7/20/2021,7/17/2021,7/23/2021,Louisiana,N,70043,VOC,Education,,Person,Human +MZ591568,------------------aactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcttctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggtttgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattttaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagtcatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaattggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttatttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttagggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttataagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgctaaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttttgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcatggtctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaa---------ctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaatattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacacaaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattactttaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcttgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcttgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagattttatctaaacgaacaaactaaaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatct-------------------------------------------------------------------------------------------------------------------------------------------------------------------------,hCoV-19/USA/NC-CDC-LC0089831/2021,B.1.351,Beta,7/1/2021,6/28/2021,7/4/2021,North Carolina,N,27511,VOC,Other ,,Person,Human +MZ415508,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcatcaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtagtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttatcttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaatgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggattattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataattactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactattgtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttattaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttataccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttagggaagcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagactcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatgaaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttcaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacatgaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttttttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaatttttctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctagcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaagacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/PA-CDC-STM-000072865/2021,B.1.617.1,,7/10/2021,7/7/2021,7/13/2021,Pennsylvania,N,19019,VOI,Other ,,Person,Human +MZ696569,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcttctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaagnnnnnnnggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatnnnntggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtnnnnnnnnnnnnnnnnnnnnattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcnnnnnnnnnnnnnnnnnnnnnttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagccttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgnnnnnnnnnnnnnnncacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctnnaaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagtnntctgggtaggtacatgtcagcattaaatcacactaaaaattggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagannnnnnnnnnnnnnnnnnnnnttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaanaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatgnnnnnnctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgttggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttannnnnnnnnnnnnnnnnnnagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttnntagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggnnnnnnnnnnnnnnnnnnnnnnnnnntaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttagggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggaaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactattttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtactttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgacagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaattgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttgnnnnnnncgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattacccccttcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgctaaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtggtctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaa---------ctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaatattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacttcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaagatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattactttaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcttgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgtggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagattttatctaaacgaacaaactaaaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctacggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagcttttggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-FG-041684/2021,B.1.351,Beta,7/11/2021,7/8/2021,7/14/2021,Texas,N,75001,VOC,Manufacturing,,Person,Human +MZ727700,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccggtctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccagcagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaatttaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggatttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccccgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaaaagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcttattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccaggtcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-2-4651373/2021,B.1.621,,7/6/2021,7/3/2021,7/9/2021,Texas,N,75039,Lineage,service industry,,Person,Human +MZ727701,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccagcagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccattcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaattggcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgttaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagataacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaaaagttggatggaaagtgagtccagagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactttcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacatacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatttcatctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-2-4651455/2021,B.1.621,,7/10/2021,7/7/2021,7/13/2021,Texas,N,75039,Lineage,service industry,,Person,Human +MZ745181,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttattggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttattcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaatatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctatctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatttgtagttgatgacccgtgtcccattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtttaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccaatcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-ASC210115019/2021,B.1.617.2,Delta,7/14/2021,7/11/2021,7/17/2021,Texas,N,75019,VOC,Hospitality,,Person,Human +MZ745515,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagattgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgattactaccacacaactgatcttagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacgctttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagttctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaattgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaataagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtttacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggttttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctatagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaattttttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttgttggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-ASC210114966/2021,B.1.617.2,Delta,7/14/2021,7/11/2021,7/17/2021,Texas,N,75039,VOC,Other ,,Person,Human +MZ762276,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaagnnnnnnnggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatnnnntggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtnnnnnnnnnnnnnnnnnnnnattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcnnnnnnnnnnnnnnnnnnnnnttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgnnnnnnnnnnnnnnncacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctnnaaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcttagtnntctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagannnnnnnnnnnnnnnnnnnnnttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacgctttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaanaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatgnnnnnnctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggcccctatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttannnnnnnnnnnnnnnnnnnagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttnntagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggnnnnnnnnnnnnnnnnnnnnnnnnnntaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagttctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaattgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatnngaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtttacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcatacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttgnnnnnnncgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaactagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctannnnnnnnnaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccgtttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggttttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgatacctatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacacttgtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcnnnnngctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacaatcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgaaggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctactcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcatgcctaaactcatgcagaccacacaaggcatatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggacactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-FG-057513/2021,B.1.617.2,Delta,8/1/2021,7/29/2021,8/4/2021,Texas,N,75039,VOC,Healthcare,,Person,Human +MZ797703,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgttgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttttatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattatcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccattgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaacagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaattgtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcataagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-QDX27272171/2021,B.1.617.2,Delta,7/6/2021,7/3/2021,7/9/2021,Texas,N,75039,VOC,Healthcare,,Person,Human +MZ797748,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgttacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaattataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctatttttttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattgtacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaattacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgactacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-QDX27272178/2021,B.1.617.2,Delta,7/10/2021,7/7/2021,7/13/2021,Texas,N,75039,VOC,Healthcare,,Person,Human +MZ797832,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagatttgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggactcgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-QDX27272181/2021,B.1.617.2,Delta,8/12/2021,8/9/2021,8/15/2021,Texas,N,75032,VOC,Healthcare,,Person,Human +MZ797965,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgttcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatggtgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagatttgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttatatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacattcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-QDX27272175/2021,B.1.617.2,Delta,8/24/2021,8/21/2021,8/27/2021,Texas,N,75039,VOC,Healthcare,,Person,Human +MZ797980,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcactaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggtgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcttagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagtaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtacttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagrgctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacttaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattttgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccgttactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacattcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-QDX27272170/2021,B.1.617.2,Delta,8/18/2021,8/15/2021,8/21/2021,Texas,Y,75039,VOC,Education,,Person,Human +MZ798055,agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttagtgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcgtctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatctaggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacgagaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtggctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcacttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgttcatcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagcagaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctcatgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaaggagctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttggcactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttacccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaacttctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaaagcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactgctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatgaattgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatgtccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaagaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaatgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttcatggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgactaaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattgtccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatgaatctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgtgttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaacataggttgtaaccatacaggtgttgttggagaaggttccgaagttcttaatgacaaccttcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaatgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaactgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaaagttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatactgagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccgcactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatactagatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgatttggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttcgcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattggcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaaatttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaaggaaattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgctgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgtcacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggtctactcatgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacagaagtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctactagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgttgctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaacaataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgtgatagaagtgcaaggttacaagagtgttaatatcacttttgaacttgatgaaaggattgataaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatgagttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattacttacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatgagtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgaggatgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatggtactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttcaacctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtcaacaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacctcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtggttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaaaaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggaggtgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgattacatagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatcttgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaacttcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatcagctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcgcacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctttttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagaggaagttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataagaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcacagaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactcttgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgttgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactactgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttacccgggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaaaagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaactgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcctgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaaaatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaactgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccacttggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaaagtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatcttacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttcctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagagaggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagttatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggtgtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacatatggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctcataattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttgaggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcattaaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggcagataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtttaatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaacttttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagagaaacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgtggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgtacatgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtggtaaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcaccacctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaattaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacggtgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaagaaaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtacagaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagcaaccaattgatcttgtaccaaaccaaccatatccaaacgcaagctttgataattttaagtttgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacctgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctattgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctattgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtatacgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtcagaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaagaagtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccgaagttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggttggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacctaatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgttaatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgttagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgccttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaattaaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttgtctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattataatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgctttaggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggctatttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgtttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattaccatttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggcatatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtttttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaatcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcattttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtatgatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgttagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattggaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgcgagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacatcgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtcaaaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaataacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtgaagaatcatctgtaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatactgttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaatgtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaaaacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtcttatctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaagatgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttgtaataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgcttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgctttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacgtagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagttgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggttgaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaataacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaaggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaaacatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagcttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcctggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttagtgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaacatcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccattaccatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccctgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttgaaggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtgaaagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgattattacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatatgtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctggtggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagcttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcactgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttacttgtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggttatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccacaaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgtttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgtatctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctctttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgcttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttctttaccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggcattcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacacttaacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctgaagacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttcttggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtacttaagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattcaaccaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttaccaatgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtagtgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaattaccaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttgacaggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttggttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactcttaatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgttgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttcattaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttattagaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaagtgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttcacttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgcctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaaacataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattttaatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggttgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggtgttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggacacttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagccatttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaactgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttcttcataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttgtacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgtttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactcccacccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaaaccttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagtagtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctcaatgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaaaatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagctttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttcccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaatggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctgaatttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgacccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgcagacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaacaatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaactaatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttacttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttcaacttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagctttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacgacagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagcttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacaggatttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactggaaccaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactttattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagtacgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctgtgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaaccaatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagttacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactgccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgtacaaatacctacaacttgtactaatgaccctgtgggttttacacttaaaaacacagtctgtaccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccatgcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgtcttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctacaatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaaaaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctctaactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaacatgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgtcttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaattgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaataaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaacttaggtgaacgtgtacgccaagctttgttaaaaacagtacaagtctgtgatgccatgcgaaatgctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgatttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattattcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgacactgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagagaggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgtgttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctctacagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgttccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggatgtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccctgctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagtagctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagacttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaacacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttataatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataagtactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaacctagacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattcaatgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctactataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagctggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatcaatagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttggcacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggattatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttcttgctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgagtgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggtggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaagctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataagtatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgacacagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactctctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagcataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaatgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatgctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatcctaggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacggttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgctgatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacacatgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacctgagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgttctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgttgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaatccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttaggaggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaatggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgactttaatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgtactgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaactgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttcatgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgtgtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggtgatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtgctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactatgttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgttgcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtactggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtatacagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcctatagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattcaaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacgacagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgttgtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacctgcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgtagacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgctgaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagacaaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatctgcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttggagaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttgggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattcactcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattaccagagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaatttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaacaggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctacacacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcatacctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaagttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgcatggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaatttacctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgttgatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaatttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaagattgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtcttatgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgcacctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcctgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaacaatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggtaatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgctttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagattaatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaattcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgatgtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaattattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttggaattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtgctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgcattccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttctattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattatgtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtagacatcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggctttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaagacttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaacagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgttgatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgggctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggacattgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctactattggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcaccactcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgtaatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaacaagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattattataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtagaaatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatggatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatggagattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgttttaaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactatttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttattacttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtcaaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgtagaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcctaatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgatagtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaatatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgctggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggtacgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgattggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtacgaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttacatttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataacagaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcctttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatcttggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggaggaatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttccccttaaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgattttatctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagtgatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagtctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattctttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaactcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctctgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgtttattttgcttccactgagaagtctaacataataagaggctggatttttggtactactttagattcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctgtgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaaaagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaatatgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttagggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctattaatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgccaataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgactcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatcttcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtagactgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaaaggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcctaatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgtttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataattccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatctctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaatcgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttacaggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataattaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaactgaaatctatcaggctggtagcaaaccttgtaatggtgttgaaggttttaattgttactttcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagtagtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtctactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacaggtgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgctgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatgttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgttctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttactcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgtttaataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtatatgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtcaatccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataactctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtctatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcagcaatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaatagctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaaaacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatcaaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcagatgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcatttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgattgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgcaggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattggagttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgctattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaatgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattttggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctgaagtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactcaacaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtcagagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttatgtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgcacaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcctcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaatttttatgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaataggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaaggaggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctctggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgccaagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatataaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggtgacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttgtggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaattacattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgtaactttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgcaacgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttcttgctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactctccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacaccttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctacttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgccgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgttacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgatggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgggaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccagctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctacaataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatccggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtgcctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagacaggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagttacactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtgagtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctagagttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactttaattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctccttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaatttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgttatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatcaccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttcattgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaactaacattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtgaactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctaggacgctgtgacattaaggacctgcctaaagaaatcactgttgctacatcacgaacgctttcttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcatacagtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaatattgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttactatagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgattacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattctcaattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttcttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggtacaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccatttcatcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgcttgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactgttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggcaatagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcattaattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgcttattatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacgaacatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaatgtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattcacttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaattgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattatacagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtagtgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta------atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcaccccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcagtggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggttcaccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttccaattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacgaattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacctaggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggttgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaacaatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgcagaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacagttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaatggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaaaatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctgaggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagctttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcagacaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagcgttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgacctacacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgctgaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaagaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgactcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcagtgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaacgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaactacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgtgtaacattggggaggacttgaaagagccaccacattttcaccgaggccactcggagtacgatcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgtaaaattaattttagtagtgctatcc,hCoV-19/USA/TX-CDC-QDX27272166/2021,B.1.617.2,Delta,8/4/2021,8/1/2021,8/7/2021,Texas,Y,75039,VOC,Education,,Person,Human +P1,,,,,,,,,,,,,,Place, +P2,,,,,,,,,,,,,,Place, +P3,,,,,,,,,,,,,,Place, diff --git a/cypress/fixtures/COVID_Dummy_distance_edgelist_snp.csv b/cypress/fixtures/COVID_Dummy_distance_edgelist_snp.csv new file mode 100644 index 00000000..f5b41845 --- /dev/null +++ b/cypress/fixtures/COVID_Dummy_distance_edgelist_snp.csv @@ -0,0 +1,437 @@ +source,target,distance +MZ375596,MZ797980,24 +MZ745515,MZ797980,22 +MZ745515,MZ375596,28 +MZ797832,MZ797980,25 +MZ797832,MZ375596,1 +MZ797832,MZ745515,29 +MZ415508,MZ797980,40 +MZ415508,MZ375596,40 +MZ415508,MZ745515,42 +MZ415508,MZ797832,41 +MZ505967,MZ797980,41 +MZ505967,MZ375596,41 +MZ505967,MZ745515,43 +MZ505967,MZ797832,42 +MZ505967,MZ415508,26 +MZ797748,MZ797980,27 +MZ797748,MZ375596,9 +MZ797748,MZ745515,31 +MZ797748,MZ797832,10 +MZ797748,MZ415508,43 +MZ797748,MZ505967,44 +MZ797703,MZ797980,28 +MZ797703,MZ375596,10 +MZ797703,MZ745515,32 +MZ797703,MZ797832,11 +MZ797703,MZ415508,42 +MZ797703,MZ505967,45 +MZ797703,MZ797748,13 +MZ797965,MZ797980,26 +MZ797965,MZ375596,4 +MZ797965,MZ745515,32 +MZ797965,MZ797832,5 +MZ797965,MZ415508,44 +MZ797965,MZ505967,45 +MZ797965,MZ797748,13 +MZ797965,MZ797703,14 +MZ745181,MZ797980,31 +MZ745181,MZ375596,13 +MZ745181,MZ745515,33 +MZ745181,MZ797832,14 +MZ745181,MZ415508,45 +MZ745181,MZ505967,48 +MZ745181,MZ797748,16 +MZ745181,MZ797703,15 +MZ745181,MZ797965,17 +MZ798055,MZ797980,31 +MZ798055,MZ375596,13 +MZ798055,MZ745515,35 +MZ798055,MZ797832,14 +MZ798055,MZ415508,47 +MZ798055,MZ505967,48 +MZ798055,MZ797748,16 +MZ798055,MZ797703,17 +MZ798055,MZ797965,17 +MZ798055,MZ745181,20 +MZ797839,MZ797980,34 +MZ797839,MZ375596,16 +MZ797839,MZ745515,36 +MZ797839,MZ797832,17 +MZ797839,MZ415508,48 +MZ797839,MZ505967,51 +MZ797839,MZ797748,19 +MZ797839,MZ797703,18 +MZ797839,MZ797965,20 +MZ797839,MZ745181,21 +MZ797839,MZ798055,23 +MZ727701,MZ797980,54 +MZ727701,MZ375596,56 +MZ727701,MZ745515,56 +MZ727701,MZ797832,57 +MZ727701,MZ415508,57 +MZ727701,MZ505967,59 +MZ727701,MZ797748,59 +MZ727701,MZ797703,58 +MZ727701,MZ797965,60 +MZ727701,MZ745181,59 +MZ727701,MZ798055,63 +MZ727701,MZ797839,64 +MZ727700,MZ797980,55 +MZ727700,MZ375596,57 +MZ727700,MZ745515,57 +MZ727700,MZ797832,58 +MZ727700,MZ415508,57 +MZ727700,MZ505967,59 +MZ727700,MZ797748,60 +MZ727700,MZ797703,59 +MZ727700,MZ797965,61 +MZ727700,MZ745181,60 +MZ727700,MZ798055,64 +MZ727700,MZ797839,65 +MZ727700,MZ727701,12 +MZ759709,MZ797980,52 +MZ759709,MZ375596,56 +MZ759709,MZ745515,54 +MZ759709,MZ797832,57 +MZ759709,MZ415508,52 +MZ759709,MZ505967,54 +MZ759709,MZ797748,59 +MZ759709,MZ797703,58 +MZ759709,MZ797965,60 +MZ759709,MZ745181,59 +MZ759709,MZ798055,63 +MZ759709,MZ797839,64 +MZ759709,MZ727701,50 +MZ759709,MZ727700,50 +MZ637292,MZ797980,26 +MZ637292,MZ375596,8 +MZ637292,MZ745515,28 +MZ637292,MZ797832,9 +MZ637292,MZ415508,48 +MZ637292,MZ505967,49 +MZ637292,MZ797748,5 +MZ637292,MZ797703,12 +MZ637292,MZ797965,12 +MZ637292,MZ745181,13 +MZ637292,MZ798055,15 +MZ637292,MZ797839,18 +MZ637292,MZ727701,62 +MZ637292,MZ727700,63 +MZ637292,MZ759709,62 +MZ744384,MZ797980,60 +MZ744384,MZ375596,62 +MZ744384,MZ745515,60 +MZ744384,MZ797832,63 +MZ744384,MZ415508,61 +MZ744384,MZ505967,60 +MZ744384,MZ797748,65 +MZ744384,MZ797703,66 +MZ744384,MZ797965,66 +MZ744384,MZ745181,67 +MZ744384,MZ798055,69 +MZ744384,MZ797839,72 +MZ744384,MZ727701,59 +MZ744384,MZ727700,59 +MZ744384,MZ759709,53 +MZ744384,MZ797519,4 +MZ744384,MZ637292,68 +MZ712879,MZ797980,22 +MZ712879,MZ375596,28 +MZ712879,MZ745515,5 +MZ712879,MZ797832,29 +MZ712879,MZ415508,42 +MZ712879,MZ505967,43 +MZ712879,MZ797748,31 +MZ712879,MZ797703,32 +MZ712879,MZ797965,32 +MZ712879,MZ745181,34 +MZ712879,MZ798055,35 +MZ712879,MZ797839,36 +MZ712879,MZ727701,58 +MZ712879,MZ727700,59 +MZ712879,MZ759709,55 +MZ712879,MZ637292,29 +MZ712879,MZ744384,61 +MZ797735,MZ797980,62 +MZ797735,MZ375596,64 +MZ797735,MZ745515,62 +MZ797735,MZ797832,65 +MZ797735,MZ415508,63 +MZ797735,MZ505967,62 +MZ797735,MZ797748,67 +MZ797735,MZ797703,68 +MZ797735,MZ797965,68 +MZ797735,MZ745181,69 +MZ797735,MZ798055,71 +MZ797735,MZ797839,74 +MZ797735,MZ727701,61 +MZ797735,MZ727700,61 +MZ797735,MZ759709,55 +MZ797735,MZ637292,70 +MZ797735,MZ744384,18 +MZ797735,MZ712879,63 +MZ712835,MZ797980,29 +MZ712835,MZ375596,7 +MZ712835,MZ745515,32 +MZ712835,MZ797832,8 +MZ712835,MZ415508,45 +MZ712835,MZ505967,46 +MZ712835,MZ797748,14 +MZ712835,MZ797703,15 +MZ712835,MZ797965,11 +MZ712835,MZ745181,17 +MZ712835,MZ798055,18 +MZ712835,MZ797839,21 +MZ712835,MZ727701,61 +MZ712835,MZ727700,62 +MZ712835,MZ759709,60 +MZ712835,MZ637292,12 +MZ712835,MZ744384,66 +MZ712835,MZ712879,33 +MZ712835,MZ797735,68 +MZ744285,MZ797980,65 +MZ744285,MZ375596,67 +MZ744285,MZ745515,65 +MZ744285,MZ797832,68 +MZ744285,MZ415508,66 +MZ744285,MZ505967,65 +MZ744285,MZ797748,70 +MZ744285,MZ797703,71 +MZ744285,MZ797965,71 +MZ744285,MZ745181,72 +MZ744285,MZ798055,74 +MZ744285,MZ797839,77 +MZ744285,MZ727701,64 +MZ744285,MZ727700,64 +MZ744285,MZ759709,58 +MZ744285,MZ637292,73 +MZ744285,MZ744384,15 +MZ744285,MZ712879,66 +MZ744285,MZ797735,23 +MZ744285,MZ712835,71 +MZ797519,MZ797980,65 +MZ797519,MZ375596,67 +MZ797519,MZ745515,65 +MZ797519,MZ797832,68 +MZ797519,MZ415508,63 +MZ797519,MZ505967,64 +MZ797519,MZ797748,70 +MZ797519,MZ797703,71 +MZ797519,MZ797965,71 +MZ797519,MZ745181,72 +MZ797519,MZ798055,74 +MZ797519,MZ797839,77 +MZ797519,MZ727701,62 +MZ797519,MZ727700,62 +MZ797519,MZ759709,56 +MZ797519,MZ637292,73 +MZ797519,MZ744384,23 +MZ797519,MZ712879,66 +MZ797519,MZ797735,25 +MZ797519,MZ712835,71 +MZ797519,MZ744285,28 +MZ740979,MZ797980,64 +MZ740979,MZ375596,68 +MZ740979,MZ745515,66 +MZ740979,MZ797832,69 +MZ740979,MZ415508,65 +MZ740979,MZ505967,67 +MZ740979,MZ797748,71 +MZ740979,MZ797703,70 +MZ740979,MZ797965,72 +MZ740979,MZ745181,71 +MZ740979,MZ798055,74 +MZ740979,MZ797839,76 +MZ740979,MZ727701,63 +MZ740979,MZ727700,63 +MZ740979,MZ759709,37 +MZ740979,MZ637292,74 +MZ740979,MZ744384,70 +MZ740979,MZ712879,67 +MZ740979,MZ797735,72 +MZ740979,MZ712835,72 +MZ740979,MZ744285,75 +MZ740979,MZ797519,73 +MZ787305,MZ797980,51 +MZ787305,MZ375596,55 +MZ787305,MZ745515,53 +MZ787305,MZ797832,56 +MZ787305,MZ415508,51 +MZ787305,MZ505967,53 +MZ787305,MZ797748,58 +MZ787305,MZ797703,57 +MZ787305,MZ797965,59 +MZ787305,MZ745181,58 +MZ787305,MZ798055,62 +MZ787305,MZ797839,63 +MZ787305,MZ727701,48 +MZ787305,MZ727700,48 +MZ787305,MZ759709,22 +MZ787305,MZ637292,61 +MZ787305,MZ744384,57 +MZ787305,MZ712879,54 +MZ787305,MZ797735,59 +MZ787305,MZ712835,59 +MZ787305,MZ744285,62 +MZ787305,MZ797519,60 +MZ787305,MZ740979,33 +MZ727689,MZ797980,61 +MZ727689,MZ375596,63 +MZ727689,MZ745515,63 +MZ727689,MZ797832,64 +MZ727689,MZ415508,63 +MZ727689,MZ505967,65 +MZ727689,MZ797748,66 +MZ727689,MZ797703,65 +MZ727689,MZ797965,67 +MZ727689,MZ745181,66 +MZ727689,MZ798055,70 +MZ727689,MZ797839,71 +MZ727689,MZ727701,18 +MZ727689,MZ727700,8 +MZ727689,MZ759709,56 +MZ727689,MZ637292,69 +MZ727689,MZ744384,65 +MZ727689,MZ712879,65 +MZ727689,MZ797735,67 +MZ727689,MZ712835,68 +MZ727689,MZ744285,70 +MZ727689,MZ797519,67 +MZ727689,MZ740979,69 +MZ727689,MZ787305,53 +MZ591568,MZ797980,51 +MZ591568,MZ375596,53 +MZ591568,MZ745515,51 +MZ591568,MZ797832,53 +MZ591568,MZ415508,52 +MZ591568,MZ505967,52 +MZ591568,MZ797748,56 +MZ591568,MZ797703,57 +MZ591568,MZ797965,57 +MZ591568,MZ745181,57 +MZ591568,MZ798055,59 +MZ591568,MZ797839,63 +MZ591568,MZ727701,47 +MZ591568,MZ727700,47 +MZ591568,MZ759709,42 +MZ591568,MZ637292,59 +MZ591568,MZ744384,55 +MZ591568,MZ712879,52 +MZ591568,MZ797735,57 +MZ591568,MZ712835,56 +MZ591568,MZ744285,60 +MZ591568,MZ797519,57 +MZ591568,MZ740979,55 +MZ591568,MZ787305,37 +MZ591568,MZ727689,53 +MZ696569,MZ797980,55 +MZ696569,MZ375596,57 +MZ696569,MZ745515,55 +MZ696569,MZ797832,58 +MZ696569,MZ415508,56 +MZ696569,MZ505967,56 +MZ696569,MZ797748,60 +MZ696569,MZ797703,61 +MZ696569,MZ797965,61 +MZ696569,MZ745181,62 +MZ696569,MZ798055,63 +MZ696569,MZ797839,65 +MZ696569,MZ727701,50 +MZ696569,MZ727700,50 +MZ696569,MZ759709,45 +MZ696569,MZ637292,63 +MZ696569,MZ744384,58 +MZ696569,MZ712879,56 +MZ696569,MZ797735,60 +MZ696569,MZ712835,61 +MZ696569,MZ744285,63 +MZ696569,MZ797519,61 +MZ696569,MZ740979,58 +MZ696569,MZ787305,43 +MZ696569,MZ727689,56 +MZ696569,MZ591568,21 +MZ761907,MZ797980,27 +MZ761907,MZ375596,5 +MZ761907,MZ745515,31 +MZ761907,MZ797832,6 +MZ761907,MZ415508,43 +MZ761907,MZ505967,44 +MZ761907,MZ797748,12 +MZ761907,MZ797703,13 +MZ761907,MZ797965,9 +MZ761907,MZ745181,16 +MZ761907,MZ798055,15 +MZ761907,MZ797839,19 +MZ761907,MZ727701,59 +MZ761907,MZ727700,60 +MZ761907,MZ759709,58 +MZ761907,MZ637292,11 +MZ761907,MZ744384,65 +MZ761907,MZ712879,31 +MZ761907,MZ797735,67 +MZ761907,MZ712835,10 +MZ761907,MZ744285,70 +MZ761907,MZ797519,70 +MZ761907,MZ740979,70 +MZ761907,MZ787305,57 +MZ761907,MZ727689,66 +MZ761907,MZ591568,56 +MZ761907,MZ696569,60 +MZ762276,MZ797980,27 +MZ762276,MZ375596,33 +MZ762276,MZ745515,19 +MZ762276,MZ797832,34 +MZ762276,MZ415508,47 +MZ762276,MZ505967,48 +MZ762276,MZ797748,36 +MZ762276,MZ797703,37 +MZ762276,MZ797965,37 +MZ762276,MZ745181,40 +MZ762276,MZ798055,39 +MZ762276,MZ797839,43 +MZ762276,MZ727701,63 +MZ762276,MZ727700,64 +MZ762276,MZ759709,61 +MZ762276,MZ637292,35 +MZ762276,MZ744384,67 +MZ762276,MZ712879,19 +MZ762276,MZ797735,69 +MZ762276,MZ712835,38 +MZ762276,MZ744285,72 +MZ762276,MZ797519,72 +MZ762276,MZ740979,73 +MZ762276,MZ787305,60 +MZ762276,MZ727689,70 +MZ762276,MZ591568,57 +MZ762276,MZ696569,62 +MZ762276,MZ761907,36 +MZ727698,MZ797980,59 +MZ727698,MZ375596,61 +MZ727698,MZ745515,61 +MZ727698,MZ797832,62 +MZ727698,MZ415508,61 +MZ727698,MZ505967,62 +MZ727698,MZ797748,64 +MZ727698,MZ797703,63 +MZ727698,MZ797965,65 +MZ727698,MZ745181,64 +MZ727698,MZ798055,68 +MZ727698,MZ797839,69 +MZ727698,MZ727701,17 +MZ727698,MZ727700,17 +MZ727698,MZ759709,54 +MZ727698,MZ637292,67 +MZ727698,MZ744384,63 +MZ727698,MZ712879,63 +MZ727698,MZ797735,65 +MZ727698,MZ712835,66 +MZ727698,MZ744285,66 +MZ727698,MZ797519,65 +MZ727698,MZ740979,67 +MZ727698,MZ787305,51 +MZ727698,MZ727689,7 +MZ727698,MZ591568,51 +MZ727698,MZ696569,54 +MZ727698,MZ761907,64 +MZ727698,MZ762276,68 diff --git a/cypress/fixtures/Cypress_Test_Style.style b/cypress/fixtures/Cypress_Test_Style.style new file mode 100644 index 00000000..1d15e865 --- /dev/null +++ b/cypress/fixtures/Cypress_Test_Style.style @@ -0,0 +1,418 @@ +{ + "linkAlphas": [ + 1, + 1, + 1, + 1, + 1 + ], + "linkColors": [ + "#a6cee3", + "#1f78b4", + "#b2df8a", + "#33a02c", + "#fb9a99", + "#e31a1c", + "#fdbf6f", + "#ff7f00", + "#cab2d6", + "#6a3d9a", + "#ffff99", + "#b15928" + ], + "linkValueNames": {}, + "nodeAlphas": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "nodeColors": [ + "#3998f5", + "#f22020", + "#b732cc", + "#f47a22", + "#0ec434", + "#96341c", + "#8ad8e8", + "#EAE553", + "#235b54", + "#ffcba5", + "#772b9d", + "#29bdab", + "#ffc413", + "#d30b94", + "#201923", + "#7dfc00", + "#3750db", + "#946aa2", + "#edeff3", + "#fcff5d", + "#632819", + "#228c68", + "#277da7", + "#37294f", + "#991919", + "#e68f66", + "#c3a5b4", + "#2f2aa0", + "#c56133", + "#5d4c86" + ], + "nodeColorsTable": { + "Profession": [ + "#3998f5", + "#f22020", + "#b732cc", + "#f47a22", + "#0ec434", + "#96341c", + "#8ad8e8", + "#EAE553", + "#235b54", + "#ffcba5", + "#772b9d", + "#29bdab", + "#ffc413", + "#d30b94", + "#201923", + "#7dfc00", + "#3750db", + "#946aa2", + "#edeff3", + "#fcff5d", + "#632819", + "#228c68", + "#277da7", + "#37294f", + "#991919", + "#e68f66", + "#c3a5b4", + "#2f2aa0", + "#c56133", + "#5d4c86" + ] + }, + "nodeColorsTableHistory": { + "null": "#EAE553", + "Colorado": "#3998f5", + "Texas": "#f22020", + "Pennsylvania": "#b732cc", + "Arizona": "#f47a22", + "Florida": "#0ec434", + "Louisiana": "#96341c", + "North Carolina": "#8ad8e8", + "Connecticut": "#f07cab", + "Healthcare": "#3998f5", + "Education": "#f22020", + "Other ": "#b732cc", + "service industry": "#f47a22", + "Hospitality": "#0ec434", + "Student": "#96341c", + "Manufacturing": "#8ad8e8" + }, + "nodeColorsTableKeys": { + "Profession": [ + "Healthcare", + "Education", + "Other ", + "service industry", + "Hospitality", + "Student", + "Manufacturing", + "null" + ] + }, + "linkColorsTable": { + "Contact type": [ + "#a6cee3", + "#1f78b4", + "#b2df8a", + "#33a02c", + "#fb9a99", + "#e31a1c", + "#fdbf6f", + "#ff7f00", + "#cab2d6", + "#6a3d9a", + "#ffff99", + "#b15928" + ] + }, + "linkColorsTableKeys": { + "Contact type": [ + "sports team", + "classroom", + "party", + "family member", + "null" + ] + }, + "nodeSymbols": [ + "ellipse", + "rectangle", + "triangle", + "hexagon", + "diamond", + "barrel", + "pentagon", + "octagon", + "star", + "tag", + "vee" + ], + "nodeSymbolsTable": { + "Node type": [ + "ellipse", + "rectangle", + "triangle", + "hexagon", + "diamond", + "barrel", + "pentagon", + "octagon", + "star", + "tag", + "vee" + ] + }, + "nodeSymbolsTableKeys": { + "Node type": [ + "Person", + "Place" + ] + }, + "originalNodeSymbolValues": [ + "Person", + "Place" + ], + "nodeSymbol": {}, + "nodeValueNames": {}, + "polygonAlphas": [ + 0.5 + ], + "polygonColors": [ + "#353cac", + "#fdbe3d", + "#41ba97", + "#9e0f1e", + "#303030", + "#62a5e4", + "#a13eda", + "#f4e41c", + "#75d054", + "#f22020" + ], + "polygonValueNames": {}, + "overwrite": {}, + "widgets": { + "3DNet-link-tooltip-variable": "None", + "3DNet-link-transparency": 0, + "3DNet-link-width": 1.6, + "3DNet-node-tooltip-variable": "_id", + "3DNet-node-radius": 4, + "3DNet-node-radius-variable": "None", + "align-sw": false, + "align-none": true, + "alignView-charSetting": "hide", + "alignView-colorSchemeName": "n", + "alignView-customColorScheme": { + "A": "#ccff00", + "C": "#ffff00", + "G": "#ff9900", + "T": "#ff6600", + "ambig": "#ffffff" + }, + "alignView-labelField": "_id", + "alignView-rulerMinorInterval": 50, + "alignView-selectedSize": "s", + "alignView-showMiniMap": true, + "alignView-sortField": "index", + "alignView-spanWidth": 10, + "alignView-spanHeight": 16, + "alignView-topDisplay": "barplot", + "ambiguity-resolution-strategy": "AVERAGE", + "ambiguity-threshold": 0.015, + "background-color": "#ffffff", + "background-color-contrast": "#000000", + "bubble-x": "cluster", + "bubble-y": "None", + "bubble-charge": 0.05, + "bubble-size": 20, + "bubble-collapsed": false, + "choropleth-aggregate-as": "states", + "choropleth-aggregate-on": "None", + "choropleth-basemap-show": false, + "choropleth-color-high": "#800026", + "choropleth-color-low": "#ffffcc", + "choropleth-color-medium": "#fd8d3c", + "choropleth-satellite-show": false, + "choropleth-transparency": 0.3, + "cluster-minimum-size": 1, + "default-view": "2d_network", + "default-distance-metric": "snps", + "filtering-epsilon": -8, + "flow-showNodes": "selected", + "gantt-date-list": "", + "globe-countries-show": false, + "globe-field-lat": "None", + "globe-field-lon": "None", + "globe-field-tract": "None", + "globe-field-zipcode": "None", + "globe-field-county": "None", + "globe-field-state": "None", + "globe-field-country": "None", + "globe-link-show": true, + "globe-link-transparency": 0, + "globe-node-jitter": -2, + "globe-node-show": true, + "globe-node-transparency": 0, + "globe-stars-show": true, + "heatmap-invertX": false, + "heatmap-invertY": false, + "heatmap-color-high": "#a50026", + "heatmap-color-medium": "#ffffbf", + "heatmap-color-low": "#313695", + "heatmap-axislabels-show": false, + "histogram-axis-x": true, + "histogram-scale-log": false, + "histogram-variable": "links-distance", + "infer-directionality-false": true, + "link-color": "#a6cee3", + "link-color-table-counts": true, + "link-color-table-frequencies": false, + "link-color-variable": "Contact type", + "link-directed": false, + "link-bidirectional": false, + "link-label-variable": "None", + "link-label-decimal-length": 3, + "link-length": 50, + "link-opacity": 0, + "link-show-nn": false, + "link-sort-variable": "distance", + "link-threshold": 16, + "link-tooltip-variable": [], + "link-width": 3, + "link-width-max": 27, + "link-width-min": 3, + "link-width-variable": "None", + "link-width-reciprocal": false, + "link-origin-array-order": [], + "map-basemap-show": true, + "map-collapsing-on": false, + "map-counties-show": false, + "map-countries-show": false, + "map-field-lat": "None", + "map-field-lon": "None", + "map-field-tract": "None", + "map-field-zipcode": "None", + "map-field-county": "None", + "map-field-state": "None", + "map-field-country": "None", + "map-link-show": true, + "map-link-tooltip-variable": "None", + "map-link-transparency": 0, + "map-node-jitter": -2, + "map-node-show": true, + "map-node-tooltip-variable": "Lineage", + "map-node-transparency": 0, + "map-satellite-show": false, + "map-states-show": true, + "mst-computed": false, + "network-friction": 0.124, + "network-gravity": 0.05, + "network-link-strength": 0.124, + "node-charge": 200, + "node-border-width": 2, + "node-color": "#1f77b4", + "node-color-table-counts": true, + "node-color-table-frequencies": false, + "node-color-variable": "Profession", + "node-highlight": false, + "node-label-size": 16, + "node-label-variable": "None", + "node-label-orientation": "Right", + "node-opacity": 0, + "node-radius": 20, + "node-radius-variable": "degree", + "node-radius-min": 15, + "node-radius-max": 85, + "node-symbol": "ellipse", + "node-symbol-table-counts": true, + "node-symbol-table-frequencies": false, + "node-symbol-variable": "Node type", + "node-symbol-table-visible": "Show", + "node-timeline-variable": "None", + "node-tooltip-variable": [ + "_id" + ], + "physics-tree-branch-type": "Straight", + "physics-tree-charge": 30, + "physics-tree-friction": 0.05, + "physics-tree-gravity": 0.05, + "physics-tree-lateral-strength": 0.025, + "physics-tree-layout": "Horizontal", + "physics-tree-node-label-variable": "None", + "physics-tree-tooltip": "id", + "physics-tree-type": "tree", + "polygon-color": "#bbccee", + "polygon-color-table-name-sort": "DESC", + "polygon-color-table-counts-sort": "DESC", + "polygon-color-table-counts": true, + "polygon-color-table-frequencies": false, + "polygons-color-show": false, + "polygons-foci": "cluster", + "polygons-gather-force": 0, + "polygons-label-show": false, + "polygon-label-orientation": "top", + "polygons-label-size": 16, + "polygons-show": false, + "polygon-color-table-visible": false, + "reference-source-file": true, + "reference-source-first": false, + "reference-source-consensus": false, + "scatterplot-xVar": "index", + "scatterplot-yVar": "distance", + "scatterplot-logScale": false, + "scatterplot-showNodes": false, + "search-field": "_id", + "selected-color": "#ff8300", + "selected-color-contrast": "#000000", + "selected-node-stroke-color": "#ff8300", + "selected-node-stroke-width": "4px", + "timeline-date-field": "None", + "timeline-noncumulative": true, + "tree-animation-on": true, + "tree-branch-distances-hide": false, + "tree-branch-distance-size": 8, + "tree-branch-nodes-show": false, + "tree-horizontal-stretch": 1, + "tree-layout-vertical": false, + "tree-layout-horizontal": false, + "tree-layout-circular": true, + "tree-labels-align": false, + "tree-labels-show": false, + "tree-leaf-label-show": false, + "tree-leaf-label-size": 12, + "tree-leaf-node-radius-variable": "degree", + "tree-leaf-node-show": true, + "tree-leaf-node-size": 9, + "tree-mode-square": false, + "tree-mode-smooth": true, + "tree-mode-straight": false, + "tree-round-true": false, + "tree-ruler-show": true, + "tree-tooltip-show": true, + "tree-type": "dendrogram", + "tree-vertical-stretch": 1, + "triangulate-false": true, + "twoD-settings-visible": "Hide", + "network-gridlines-show": false, + "link-threshold-variable": "snps" + } +} \ No newline at end of file diff --git a/cypress/fixtures/LargeDataSet_Test_sequences_node.csv b/cypress/fixtures/LargeDataSet_Test_sequences_node.csv new file mode 100644 index 00000000..e3be2a78 --- /dev/null +++ b/cypress/fixtures/LargeDataSet_Test_sequences_node.csv @@ -0,0 +1,1601 @@ +id,subtype,Diag date +A-1,A,1/2/2024 +A-2,A,1/3/2024 +A-3,A,1/4/2024 +A-4,A,1/5/2024 +A-5,A,1/6/2024 +A-6,A,1/7/2024 +A-7,A,1/8/2024 +A-8,A,1/9/2024 +A-9,A,1/10/2024 +A-10,A,1/11/2024 +A-11,A,1/12/2024 +A-12,A,1/13/2024 +A-13,A,1/14/2024 +A-14,A,1/15/2024 +A-15,A,1/16/2024 +A-16,A,1/17/2024 +A-17,A,1/18/2024 +A-18,A,1/19/2024 +A-19,A,1/20/2024 +A-20,A,1/21/2024 +A-21,A,1/22/2024 +A-22,A,1/23/2024 +A-23,A,1/24/2024 +A-24,A,1/25/2024 +A-25,A,1/26/2024 +A-26,A,1/27/2024 +A-27,A,1/28/2024 +A-28,A,1/29/2024 +A-29,A,1/30/2024 +A-30,A,1/31/2024 +A-31,A,2/1/2024 +A-32,A,2/2/2024 +A-33,A,2/3/2024 +A-34,A,2/4/2024 +A-35,A,2/5/2024 +A-36,A,2/6/2024 +A-37,A,1/2/2024 +A-38,A,1/3/2024 +A-39,A,1/4/2024 +A-40,A,1/5/2024 +A-41,A,1/6/2024 +A-42,A,1/7/2024 +A-43,A,1/8/2024 +A-44,A,1/9/2024 +A-45,A,1/10/2024 +A-46,A,1/11/2024 +A-47,A,1/12/2024 +A-48,A,1/13/2024 +A-49,A,1/14/2024 +A-50,A,1/15/2024 +A-51,A,1/16/2024 +A-52,A,1/17/2024 +A-53,A,1/18/2024 +A-54,A,1/19/2024 +A-55,A,1/20/2024 +A-56,A,1/21/2024 +A-57,A,1/22/2024 +A-58,A,1/23/2024 +A-59,A,1/24/2024 +A-60,A,1/25/2024 +A-61,A,1/26/2024 +A-62,A,1/27/2024 +A-63,A,1/28/2024 +A-64,A,1/29/2024 +A-65,A,1/30/2024 +A-66,A,1/31/2024 +A-67,A,2/1/2024 +A-68,A,2/2/2024 +A-69,A,2/3/2024 +A-70,A,2/4/2024 +A-71,A,2/5/2024 +A-72,A,2/6/2024 +A-73,A,1/2/2024 +A-74,A,1/3/2024 +A-75,A,1/4/2024 +A-76,A,1/5/2024 +A-77,A,1/6/2024 +A-78,A,1/7/2024 +A-79,A,1/8/2024 +A-80,A,1/9/2024 +A-81,A,1/10/2024 +A-82,A,1/11/2024 +A-83,A,1/12/2024 +A-84,A,1/13/2024 +A-85,A,1/14/2024 +A-86,A,1/15/2024 +A-87,A,1/16/2024 +A-88,A,1/17/2024 +A-89,A,1/18/2024 +A-90,A,1/19/2024 +A-91,A,1/20/2024 +A-92,A,1/21/2024 +A-93,A,1/22/2024 +A-94,A,1/23/2024 +A-95,A,1/24/2024 +A-96,A,1/25/2024 +A-97,A,1/26/2024 +A-98,A,1/27/2024 +A-99,A,1/28/2024 +A-100,A,1/29/2024 +A-101,A,1/30/2024 +A-102,A,1/31/2024 +A-103,A,2/1/2024 +A-104,A,2/2/2024 +A-105,A,2/3/2024 +A-106,A,2/4/2024 +A-107,A,2/5/2024 +A-108,A,2/6/2024 +A-109,A,1/2/2024 +A-110,A,1/3/2024 +A-111,A,1/4/2024 +A-112,A,1/5/2024 +A-113,A,1/6/2024 +A-114,A,1/7/2024 +A-115,A,1/8/2024 +A-116,A,1/9/2024 +A-117,A,1/10/2024 +A-118,A,1/11/2024 +A-119,A,1/12/2024 +A-120,A,1/13/2024 +A-121,A,1/14/2024 +A-122,A,1/15/2024 +A-123,A,1/16/2024 +A-124,A,1/17/2024 +A-125,A,1/18/2024 +A-126,A,1/19/2024 +A-127,A,1/20/2024 +A-128,A,1/21/2024 +A-129,A,1/22/2024 +A-130,A,1/23/2024 +A-131,A,1/24/2024 +A-132,A,1/25/2024 +A-133,A,1/26/2024 +A-134,A,1/27/2024 +A-135,A,1/28/2024 +A-136,A,1/29/2024 +A-137,A,1/30/2024 +A-138,A,1/31/2024 +A-139,A,2/1/2024 +A-140,A,2/2/2024 +A-141,A,2/3/2024 +A-142,A,2/4/2024 +A-143,A,2/5/2024 +A-144,A,2/6/2024 +A-145,A,1/2/2024 +A-146,A,1/3/2024 +A-147,A,1/4/2024 +A-148,A,1/5/2024 +A-149,A,1/6/2024 +A-150,A,1/7/2024 +A-151,A,1/8/2024 +A-152,A,1/9/2024 +A-153,A,1/10/2024 +A-154,A,1/11/2024 +A-155,A,1/12/2024 +A-156,A,1/13/2024 +A-157,A,1/14/2024 +A-158,A,1/15/2024 +A-159,A,1/16/2024 +A-160,A,1/17/2024 +A-161,A,1/18/2024 +A-162,A,1/19/2024 +A-163,A,1/20/2024 +A-164,A,1/21/2024 +A-165,A,1/22/2024 +A-166,A,1/23/2024 +A-167,A,1/24/2024 +A-168,A,1/25/2024 +A-169,A,1/26/2024 +A-170,A,1/27/2024 +A-171,A,1/28/2024 +A-172,A,1/29/2024 +A-173,A,1/30/2024 +A-174,A,1/31/2024 +A-175,A,2/1/2024 +A-176,A,2/2/2024 +A-177,A,2/3/2024 +A-178,A,2/4/2024 +A-179,A,2/5/2024 +A-180,A,2/6/2024 +A-181,A,1/2/2024 +A-182,A,1/3/2024 +A-183,A,1/4/2024 +A-184,A,1/5/2024 +A-185,A,1/6/2024 +A-186,A,1/7/2024 +A-187,A,1/8/2024 +A-188,A,1/9/2024 +A-189,A,1/10/2024 +A-190,A,1/11/2024 +A-191,A,1/12/2024 +A-192,A,1/13/2024 +A-193,A,1/14/2024 +A-194,A,1/15/2024 +A-195,A,1/16/2024 +A-196,A,1/17/2024 +A-197,A,1/18/2024 +A-198,A,1/19/2024 +A-199,A,1/20/2024 +A-200,A,1/21/2024 +A-201,A,1/22/2024 +A-202,A,1/23/2024 +A-203,A,1/24/2024 +A-204,A,1/25/2024 +A-205,A,1/26/2024 +A-206,A,1/27/2024 +A-207,A,1/28/2024 +A-208,A,1/29/2024 +A-209,A,1/30/2024 +A-210,A,1/31/2024 +A-211,A,2/1/2024 +A-212,A,2/2/2024 +A-213,A,2/3/2024 +A-214,A,2/4/2024 +A-215,A,2/5/2024 +A-216,A,2/6/2024 +A-217,A,1/2/2024 +A-218,A,1/3/2024 +A-219,A,1/4/2024 +A-220,A,1/5/2024 +A-221,A,1/6/2024 +A-222,A,1/7/2024 +A-223,A,1/8/2024 +A-224,A,1/9/2024 +A-225,A,1/10/2024 +A-226,A,1/11/2024 +A-227,A,1/12/2024 +A-228,A,1/13/2024 +A-229,A,1/14/2024 +A-230,A,1/15/2024 +A-231,A,1/16/2024 +A-232,A,1/17/2024 +A-233,A,1/18/2024 +A-234,A,1/19/2024 +A-235,A,1/20/2024 +A-236,A,1/21/2024 +A-237,A,1/22/2024 +A-238,A,1/23/2024 +A-239,A,1/24/2024 +A-240,A,1/25/2024 +A-241,A,1/26/2024 +A-242,A,1/27/2024 +A-243,A,1/28/2024 +A-244,A,1/29/2024 +A-245,A,1/30/2024 +A-246,A,1/31/2024 +A-247,A,2/1/2024 +A-248,A,2/2/2024 +A-249,A,2/3/2024 +A-250,A,2/4/2024 +A-251,A,2/5/2024 +A-252,A,2/6/2024 +A-253,A,1/2/2024 +A-254,A,1/3/2024 +A-255,A,1/4/2024 +A-256,A,1/5/2024 +A-257,A,1/6/2024 +A-258,A,1/7/2024 +A-259,A,1/8/2024 +A-260,A,1/9/2024 +A-261,A,1/10/2024 +A-262,A,1/11/2024 +A-263,A,1/12/2024 +A-264,A,1/13/2024 +A-265,A,1/14/2024 +A-266,A,1/15/2024 +A-267,A,1/16/2024 +A-268,A,1/17/2024 +A-269,A,1/18/2024 +A-270,A,1/19/2024 +A-271,A,1/20/2024 +A-272,A,1/21/2024 +A-273,A,1/22/2024 +A-274,A,1/23/2024 +A-275,A,1/24/2024 +A-276,A,1/25/2024 +A-277,A,1/26/2024 +A-278,A,1/27/2024 +A-279,A,1/28/2024 +A-280,A,1/29/2024 +A-281,A,1/30/2024 +A-282,A,1/31/2024 +A-283,A,2/1/2024 +A-284,A,2/2/2024 +A-285,A,2/3/2024 +A-286,A,2/4/2024 +A-287,A,2/5/2024 +A-288,A,2/6/2024 +A-289,A,1/2/2024 +A-290,A,1/3/2024 +A-291,A,1/4/2024 +A-292,A,1/5/2024 +A-293,A,1/6/2024 +A-294,A,1/7/2024 +A-295,A,1/8/2024 +A-296,A,1/9/2024 +A-297,A,1/10/2024 +A-298,A,1/11/2024 +A-299,A,1/12/2024 +A-300,A,1/13/2024 +A-301,A,1/14/2024 +A-302,A,1/15/2024 +A-303,A,1/16/2024 +A-304,A,1/17/2024 +A-305,A,1/18/2024 +A-306,A,1/19/2024 +A-307,A,1/20/2024 +A-308,A,1/21/2024 +A-309,A,1/22/2024 +A-310,A,1/23/2024 +A-311,A,1/24/2024 +A-312,A,1/25/2024 +A-313,A,1/26/2024 +A-314,A,1/27/2024 +A-315,A,1/28/2024 +A-316,A,1/29/2024 +A-317,A,1/30/2024 +A-318,A,1/31/2024 +A-319,A,2/1/2024 +A-320,A,2/2/2024 +A-321,A,2/3/2024 +A-322,A,2/4/2024 +A-323,A,2/5/2024 +A-324,A,2/6/2024 +A-325,A,1/2/2024 +A-326,A,1/3/2024 +A-327,A,1/4/2024 +A-328,A,1/5/2024 +A-329,A,1/6/2024 +A-330,A,1/7/2024 +A-331,A,1/8/2024 +A-332,A,1/9/2024 +A-333,A,1/10/2024 +A-334,A,1/11/2024 +A-335,A,1/12/2024 +A-336,A,1/13/2024 +A-337,A,1/14/2024 +A-338,A,1/15/2024 +A-339,A,1/16/2024 +A-340,A,1/17/2024 +A-341,A,1/18/2024 +A-342,A,1/19/2024 +A-343,A,1/20/2024 +A-344,A,1/21/2024 +A-345,A,1/22/2024 +A-346,A,1/23/2024 +A-347,A,1/24/2024 +A-348,A,1/25/2024 +A-349,A,1/26/2024 +A-350,A,1/27/2024 +A-351,A,1/28/2024 +A-352,A,1/29/2024 +A-353,A,1/30/2024 +A-354,A,1/31/2024 +A-355,A,2/1/2024 +A-356,A,2/2/2024 +A-357,A,2/3/2024 +A-358,A,2/4/2024 +A-359,A,2/5/2024 +A-360,A,2/6/2024 +A-361,A,1/2/2024 +A-362,A,1/3/2024 +A-363,A,1/4/2024 +A-364,A,1/5/2024 +A-365,A,1/6/2024 +A-366,A,1/7/2024 +A-367,A,1/8/2024 +A-368,A,1/9/2024 +A-369,A,1/10/2024 +A-370,A,1/11/2024 +A-371,A,1/12/2024 +A-372,A,1/13/2024 +A-373,A,1/14/2024 +A-374,A,1/15/2024 +A-375,A,1/16/2024 +A-376,A,1/17/2024 +A-377,A,1/18/2024 +A-378,A,1/19/2024 +A-379,A,1/20/2024 +A-380,A,1/21/2024 +A-381,A,1/22/2024 +A-382,A,1/23/2024 +A-383,A,1/24/2024 +A-384,A,1/25/2024 +A-385,A,1/26/2024 +A-386,A,1/27/2024 +A-387,A,1/28/2024 +A-388,A,1/29/2024 +A-389,A,1/30/2024 +A-390,A,1/31/2024 +A-391,A,2/1/2024 +A-392,A,2/2/2024 +A-393,A,2/3/2024 +A-394,A,2/4/2024 +A-395,A,2/5/2024 +A-396,A,2/6/2024 +A-397,A,1/2/2024 +A-398,A,1/3/2024 +A-399,A,1/4/2024 +A-400,A,1/5/2024 +B-1,B,1/6/2024 +B-2,B,1/7/2024 +B-3,B,1/8/2024 +B-4,B,1/9/2024 +B-5,B,1/10/2024 +B-6,B,1/11/2024 +B-7,B,1/12/2024 +B-8,B,1/13/2024 +B-9,B,1/14/2024 +B-10,B,1/15/2024 +B-11,B,1/16/2024 +B-12,B,1/17/2024 +B-13,B,1/18/2024 +B-14,B,1/19/2024 +B-15,B,1/20/2024 +B-16,B,1/21/2024 +B-17,B,1/22/2024 +B-18,B,1/23/2024 +B-19,B,1/24/2024 +B-20,B,1/25/2024 +B-21,B,1/26/2024 +B-22,B,1/27/2024 +B-23,B,1/28/2024 +B-24,B,1/29/2024 +B-25,B,1/30/2024 +B-26,B,1/31/2024 +B-27,B,2/1/2024 +B-28,B,2/2/2024 +B-29,B,2/3/2024 +B-30,B,2/4/2024 +B-31,B,2/5/2024 +B-32,B,2/6/2024 +B-33,B,1/2/2024 +B-34,B,1/3/2024 +B-35,B,1/4/2024 +B-36,B,1/5/2024 +B-37,B,1/6/2024 +B-38,B,1/7/2024 +B-39,B,1/8/2024 +B-40,B,1/9/2024 +B-41,B,1/10/2024 +B-42,B,1/11/2024 +B-43,B,1/12/2024 +B-44,B,1/13/2024 +B-45,B,1/14/2024 +B-46,B,1/15/2024 +B-47,B,1/16/2024 +B-48,B,1/17/2024 +B-49,B,1/18/2024 +B-50,B,1/19/2024 +B-51,B,1/20/2024 +B-52,B,1/21/2024 +B-53,B,1/22/2024 +B-54,B,1/23/2024 +B-55,B,1/24/2024 +B-56,B,1/25/2024 +B-57,B,1/26/2024 +B-58,B,1/27/2024 +B-59,B,1/28/2024 +B-60,B,1/29/2024 +B-61,B,1/30/2024 +B-62,B,1/31/2024 +B-63,B,2/1/2024 +B-64,B,2/2/2024 +B-65,B,2/3/2024 +B-66,B,2/4/2024 +B-67,B,2/5/2024 +B-68,B,2/6/2024 +B-69,B,2/7/2024 +B-70,B,2/8/2024 +B-71,B,2/9/2024 +B-72,B,2/10/2024 +B-73,B,2/11/2024 +B-74,B,2/12/2024 +B-75,B,2/13/2024 +B-76,B,2/14/2024 +B-77,B,2/15/2024 +B-78,B,2/16/2024 +B-79,B,2/17/2024 +B-80,B,2/18/2024 +B-81,B,2/19/2024 +B-82,B,2/20/2024 +B-83,B,2/21/2024 +B-84,B,2/22/2024 +B-85,B,2/23/2024 +B-86,B,2/24/2024 +B-87,B,2/25/2024 +B-88,B,2/26/2024 +B-89,B,2/27/2024 +B-90,B,2/28/2024 +B-91,B,2/29/2024 +B-92,B,3/1/2024 +B-93,B,3/2/2024 +B-94,B,3/3/2024 +B-95,B,3/4/2024 +B-96,B,3/5/2024 +B-97,B,3/6/2024 +B-98,B,3/7/2024 +B-99,B,3/8/2024 +B-100,B,3/9/2024 +B-101,B,3/10/2024 +B-102,B,3/11/2024 +B-103,B,3/12/2024 +B-104,B,3/13/2024 +B-105,B,3/14/2024 +B-106,B,3/15/2024 +B-107,B,3/16/2024 +B-108,B,3/17/2024 +B-109,B,3/18/2024 +B-110,B,3/19/2024 +B-111,B,3/20/2024 +B-112,B,3/21/2024 +B-113,B,3/22/2024 +B-114,B,3/23/2024 +B-115,B,3/24/2024 +B-116,B,3/25/2024 +B-117,B,3/26/2024 +B-118,B,3/27/2024 +B-119,B,3/28/2024 +B-120,B,3/29/2024 +B-121,B,3/30/2024 +B-122,B,3/31/2024 +B-123,B,4/1/2024 +B-124,B,4/2/2024 +B-125,B,4/3/2024 +B-126,B,4/4/2024 +B-127,B,4/5/2024 +B-128,B,4/6/2024 +B-129,B,4/7/2024 +B-130,B,4/8/2024 +B-131,B,4/9/2024 +B-132,B,4/10/2024 +B-133,B,4/11/2024 +B-134,B,4/12/2024 +B-135,B,4/13/2024 +B-136,B,4/14/2024 +B-137,B,4/15/2024 +B-138,B,4/16/2024 +B-139,B,4/17/2024 +B-140,B,4/18/2024 +B-141,B,4/19/2024 +B-142,B,4/20/2024 +B-143,B,4/21/2024 +B-144,B,4/22/2024 +B-145,B,4/23/2024 +B-146,B,4/24/2024 +B-147,B,4/25/2024 +B-148,B,4/26/2024 +B-149,B,4/27/2024 +B-150,B,4/28/2024 +B-151,B,4/29/2024 +B-152,B,4/30/2024 +B-153,B,5/1/2024 +B-154,B,5/2/2024 +B-155,B,5/3/2024 +B-156,B,5/4/2024 +B-157,B,5/5/2024 +B-158,B,5/6/2024 +B-159,B,5/7/2024 +B-160,B,5/8/2024 +B-161,B,5/9/2024 +B-162,B,5/10/2024 +B-163,B,5/11/2024 +B-164,B,5/12/2024 +B-165,B,5/13/2024 +B-166,B,5/14/2024 +B-167,B,5/15/2024 +B-168,B,5/16/2024 +B-169,B,5/17/2024 +B-170,B,5/18/2024 +B-171,B,5/19/2024 +B-172,B,5/20/2024 +B-173,B,5/21/2024 +B-174,B,5/22/2024 +B-175,B,5/23/2024 +B-176,B,2/6/2024 +B-177,B,2/7/2024 +B-178,B,2/8/2024 +B-179,B,2/9/2024 +B-180,B,2/10/2024 +B-181,B,2/11/2024 +B-182,B,2/12/2024 +B-183,B,2/13/2024 +B-184,B,2/14/2024 +B-185,B,2/15/2024 +B-186,B,2/16/2024 +B-187,B,2/17/2024 +B-188,B,2/18/2024 +B-189,B,2/19/2024 +B-190,B,2/20/2024 +B-191,B,2/21/2024 +B-192,B,2/22/2024 +B-193,B,2/23/2024 +B-194,B,2/24/2024 +B-195,B,2/25/2024 +B-196,B,2/26/2024 +B-197,B,2/27/2024 +B-198,B,2/28/2024 +B-199,B,2/29/2024 +B-200,B,3/1/2024 +B-201,B,3/2/2024 +B-202,B,3/3/2024 +B-203,B,3/4/2024 +B-204,B,3/5/2024 +B-205,B,3/6/2024 +B-206,B,3/7/2024 +B-207,B,3/8/2024 +B-208,B,3/9/2024 +B-209,B,3/10/2024 +B-210,B,3/11/2024 +B-211,B,3/12/2024 +B-212,B,3/13/2024 +B-213,B,3/14/2024 +B-214,B,3/15/2024 +B-215,B,3/16/2024 +B-216,B,3/17/2024 +B-217,B,3/18/2024 +B-218,B,3/19/2024 +B-219,B,3/20/2024 +B-220,B,3/21/2024 +B-221,B,3/22/2024 +B-222,B,3/23/2024 +B-223,B,3/24/2024 +B-224,B,3/25/2024 +B-225,B,3/26/2024 +B-226,B,3/27/2024 +B-227,B,3/28/2024 +B-228,B,3/29/2024 +B-229,B,3/30/2024 +B-230,B,3/31/2024 +B-231,B,4/1/2024 +B-232,B,4/2/2024 +B-233,B,4/3/2024 +B-234,B,4/4/2024 +B-235,B,4/5/2024 +B-236,B,4/6/2024 +B-237,B,4/7/2024 +B-238,B,4/8/2024 +B-239,B,4/9/2024 +B-240,B,4/10/2024 +B-241,B,4/11/2024 +B-242,B,4/12/2024 +B-243,B,4/13/2024 +B-244,B,4/14/2024 +B-245,B,4/15/2024 +B-246,B,4/16/2024 +B-247,B,4/17/2024 +B-248,B,4/18/2024 +B-249,B,4/19/2024 +B-250,B,4/20/2024 +B-251,B,4/21/2024 +B-252,B,4/22/2024 +B-253,B,4/23/2024 +B-254,B,4/24/2024 +B-255,B,4/25/2024 +B-256,B,4/26/2024 +B-257,B,4/27/2024 +B-258,B,4/28/2024 +B-259,B,4/29/2024 +B-260,B,4/30/2024 +B-261,B,5/1/2024 +B-262,B,5/2/2024 +B-263,B,5/3/2024 +B-264,B,5/4/2024 +B-265,B,5/5/2024 +B-266,B,5/6/2024 +B-267,B,5/7/2024 +B-268,B,5/8/2024 +B-269,B,5/9/2024 +B-270,B,5/10/2024 +B-271,B,5/11/2024 +B-272,B,5/12/2024 +B-273,B,5/13/2024 +B-274,B,5/14/2024 +B-275,B,5/15/2024 +B-276,B,5/16/2024 +B-277,B,5/17/2024 +B-278,B,5/18/2024 +B-279,B,5/19/2024 +B-280,B,5/20/2024 +B-281,B,5/21/2024 +B-282,B,5/22/2024 +B-283,B,5/23/2024 +B-284,B,2/6/2024 +B-285,B,2/7/2024 +B-286,B,2/8/2024 +B-287,B,2/9/2024 +B-288,B,2/10/2024 +B-289,B,2/11/2024 +B-290,B,2/12/2024 +B-291,B,2/13/2024 +B-292,B,2/14/2024 +B-293,B,2/15/2024 +B-294,B,2/16/2024 +B-295,B,2/17/2024 +B-296,B,2/18/2024 +B-297,B,2/19/2024 +B-298,B,2/20/2024 +B-299,B,2/21/2024 +B-300,B,2/22/2024 +B-301,B,2/23/2024 +B-302,B,2/24/2024 +B-303,B,2/25/2024 +B-304,B,2/26/2024 +B-305,B,2/27/2024 +B-306,B,2/28/2024 +B-307,B,2/29/2024 +B-308,B,3/1/2024 +B-309,B,3/2/2024 +B-310,B,3/3/2024 +B-311,B,3/4/2024 +B-312,B,3/5/2024 +B-313,B,3/6/2024 +B-314,B,3/7/2024 +B-315,B,3/8/2024 +B-316,B,3/9/2024 +B-317,B,3/10/2024 +B-318,B,3/11/2024 +B-319,B,3/12/2024 +B-320,B,3/13/2024 +B-321,B,3/14/2024 +B-322,B,3/15/2024 +B-323,B,3/16/2024 +B-324,B,3/17/2024 +B-325,B,3/18/2024 +B-326,B,3/19/2024 +B-327,B,3/20/2024 +B-328,B,3/21/2024 +B-329,B,3/22/2024 +B-330,B,3/23/2024 +B-331,B,3/24/2024 +B-332,B,3/25/2024 +B-333,B,3/26/2024 +B-334,B,3/27/2024 +B-335,B,3/28/2024 +B-336,B,3/29/2024 +B-337,B,3/30/2024 +B-338,B,3/31/2024 +B-339,B,4/1/2024 +B-340,B,4/2/2024 +B-341,B,4/3/2024 +B-342,B,4/4/2024 +B-343,B,4/5/2024 +B-344,B,4/6/2024 +B-345,B,4/7/2024 +B-346,B,4/8/2024 +B-347,B,4/9/2024 +B-348,B,4/10/2024 +B-349,B,4/11/2024 +B-350,B,4/12/2024 +B-351,B,4/13/2024 +B-352,B,4/14/2024 +B-353,B,4/15/2024 +B-354,B,4/16/2024 +B-355,B,4/17/2024 +B-356,B,4/18/2024 +B-357,B,4/19/2024 +B-358,B,4/20/2024 +B-359,B,4/21/2024 +B-360,B,4/22/2024 +B-361,B,4/23/2024 +B-362,B,4/24/2024 +B-363,B,4/25/2024 +B-364,B,4/26/2024 +B-365,B,4/27/2024 +B-366,B,4/28/2024 +B-367,B,4/29/2024 +B-368,B,4/30/2024 +B-369,B,5/1/2024 +B-370,B,5/2/2024 +B-371,B,5/3/2024 +B-372,B,5/4/2024 +B-373,B,5/5/2024 +B-374,B,5/6/2024 +B-375,B,5/7/2024 +B-376,B,5/8/2024 +B-377,B,5/9/2024 +B-378,B,5/10/2024 +B-379,B,5/11/2024 +B-380,B,5/12/2024 +B-381,B,5/13/2024 +B-382,B,5/14/2024 +B-383,B,5/15/2024 +B-384,B,5/16/2024 +B-385,B,5/17/2024 +B-386,B,5/18/2024 +B-387,B,5/19/2024 +B-388,B,5/20/2024 +B-389,B,5/21/2024 +B-390,B,5/22/2024 +B-391,B,5/23/2024 +B-392,B,2/6/2024 +B-393,B,2/7/2024 +B-394,B,2/8/2024 +B-395,B,2/9/2024 +B-396,B,2/10/2024 +B-397,B,2/11/2024 +B-398,B,2/12/2024 +B-399,B,2/13/2024 +B-400,B,2/14/2024 +CRF01AE-1,CRF01AE,2/15/2024 +CRF01AE-2,CRF01AE,2/16/2024 +CRF01AE-3,CRF01AE,2/17/2024 +CRF01AE-4,CRF01AE,2/18/2024 +CRF01AE-5,CRF01AE,2/19/2024 +CRF01AE-6,CRF01AE,2/20/2024 +CRF01AE-7,CRF01AE,2/21/2024 +CRF01AE-8,CRF01AE,2/22/2024 +CRF01AE-9,CRF01AE,2/23/2024 +CRF01AE-10,CRF01AE,2/24/2024 +CRF01AE-11,CRF01AE,2/25/2024 +CRF01AE-12,CRF01AE,2/26/2024 +CRF01AE-13,CRF01AE,2/27/2024 +CRF01AE-14,CRF01AE,2/28/2024 +CRF01AE-15,CRF01AE,2/29/2024 +CRF01AE-16,CRF01AE,3/1/2024 +CRF01AE-17,CRF01AE,3/2/2024 +CRF01AE-18,CRF01AE,3/3/2024 +CRF01AE-19,CRF01AE,3/4/2024 +CRF01AE-20,CRF01AE,3/5/2024 +CRF01AE-21,CRF01AE,3/6/2024 +CRF01AE-22,CRF01AE,3/7/2024 +CRF01AE-23,CRF01AE,3/8/2024 +CRF01AE-24,CRF01AE,3/9/2024 +CRF01AE-25,CRF01AE,3/10/2024 +CRF01AE-26,CRF01AE,3/11/2024 +CRF01AE-27,CRF01AE,3/12/2024 +CRF01AE-28,CRF01AE,3/13/2024 +CRF01AE-29,CRF01AE,3/14/2024 +CRF01AE-30,CRF01AE,3/15/2024 +CRF01AE-31,CRF01AE,3/16/2024 +CRF01AE-32,CRF01AE,3/17/2024 +CRF01AE-33,CRF01AE,3/18/2024 +CRF01AE-34,CRF01AE,3/19/2024 +CRF01AE-35,CRF01AE,3/20/2024 +CRF01AE-36,CRF01AE,3/21/2024 +CRF01AE-37,CRF01AE,3/22/2024 +CRF01AE-38,CRF01AE,3/23/2024 +CRF01AE-39,CRF01AE,3/24/2024 +CRF01AE-40,CRF01AE,3/25/2024 +CRF01AE-41,CRF01AE,3/26/2024 +CRF01AE-42,CRF01AE,3/27/2024 +CRF01AE-43,CRF01AE,3/28/2024 +CRF01AE-44,CRF01AE,3/29/2024 +CRF01AE-45,CRF01AE,3/30/2024 +CRF01AE-46,CRF01AE,3/31/2024 +CRF01AE-47,CRF01AE,4/1/2024 +CRF01AE-48,CRF01AE,4/2/2024 +CRF01AE-49,CRF01AE,4/3/2024 +CRF01AE-50,CRF01AE,4/4/2024 +CRF01AE-51,CRF01AE,4/5/2024 +CRF01AE-52,CRF01AE,4/6/2024 +CRF01AE-53,CRF01AE,4/7/2024 +CRF01AE-54,CRF01AE,4/8/2024 +CRF01AE-55,CRF01AE,4/9/2024 +CRF01AE-56,CRF01AE,4/10/2024 +CRF01AE-57,CRF01AE,4/11/2024 +CRF01AE-58,CRF01AE,4/12/2024 +CRF01AE-59,CRF01AE,4/13/2024 +CRF01AE-60,CRF01AE,4/14/2024 +CRF01AE-61,CRF01AE,4/15/2024 +CRF01AE-62,CRF01AE,4/16/2024 +CRF01AE-63,CRF01AE,4/17/2024 +CRF01AE-64,CRF01AE,4/18/2024 +CRF01AE-65,CRF01AE,4/19/2024 +CRF01AE-66,CRF01AE,4/20/2024 +CRF01AE-67,CRF01AE,4/21/2024 +CRF01AE-68,CRF01AE,4/22/2024 +CRF01AE-69,CRF01AE,4/23/2024 +CRF01AE-70,CRF01AE,4/24/2024 +CRF01AE-71,CRF01AE,4/25/2024 +CRF01AE-72,CRF01AE,4/26/2024 +CRF01AE-73,CRF01AE,4/27/2024 +CRF01AE-74,CRF01AE,4/28/2024 +CRF01AE-75,CRF01AE,4/29/2024 +CRF01AE-76,CRF01AE,4/30/2024 +CRF01AE-77,CRF01AE,5/1/2024 +CRF01AE-78,CRF01AE,5/2/2024 +CRF01AE-79,CRF01AE,5/3/2024 +CRF01AE-80,CRF01AE,5/4/2024 +CRF01AE-81,CRF01AE,5/5/2024 +CRF01AE-82,CRF01AE,5/6/2024 +CRF01AE-83,CRF01AE,5/7/2024 +CRF01AE-84,CRF01AE,5/8/2024 +CRF01AE-85,CRF01AE,5/9/2024 +CRF01AE-86,CRF01AE,5/10/2024 +CRF01AE-87,CRF01AE,5/11/2024 +CRF01AE-88,CRF01AE,5/12/2024 +CRF01AE-89,CRF01AE,5/13/2024 +CRF01AE-90,CRF01AE,5/14/2024 +CRF01AE-91,CRF01AE,5/15/2024 +CRF01AE-92,CRF01AE,5/16/2024 +CRF01AE-93,CRF01AE,5/17/2024 +CRF01AE-94,CRF01AE,5/18/2024 +CRF01AE-95,CRF01AE,5/19/2024 +CRF01AE-96,CRF01AE,5/20/2024 +CRF01AE-97,CRF01AE,5/21/2024 +CRF01AE-98,CRF01AE,5/22/2024 +CRF01AE-99,CRF01AE,5/23/2024 +CRF01AE-100,CRF01AE,2/6/2024 +CRF01AE-101,CRF01AE,2/7/2024 +CRF01AE-102,CRF01AE,2/8/2024 +CRF01AE-103,CRF01AE,2/9/2024 +CRF01AE-104,CRF01AE,2/10/2024 +CRF01AE-105,CRF01AE,2/11/2024 +CRF01AE-106,CRF01AE,2/12/2024 +CRF01AE-107,CRF01AE,2/13/2024 +CRF01AE-108,CRF01AE,2/14/2024 +CRF01AE-109,CRF01AE,2/15/2024 +CRF01AE-110,CRF01AE,2/16/2024 +CRF01AE-111,CRF01AE,2/17/2024 +CRF01AE-112,CRF01AE,2/18/2024 +CRF01AE-113,CRF01AE,2/19/2024 +CRF01AE-114,CRF01AE,2/20/2024 +CRF01AE-115,CRF01AE,2/21/2024 +CRF01AE-116,CRF01AE,2/22/2024 +CRF01AE-117,CRF01AE,2/23/2024 +CRF01AE-118,CRF01AE,2/24/2024 +CRF01AE-119,CRF01AE,2/25/2024 +CRF01AE-120,CRF01AE,2/26/2024 +CRF01AE-121,CRF01AE,2/27/2024 +CRF01AE-122,CRF01AE,2/28/2024 +CRF01AE-123,CRF01AE,2/29/2024 +CRF01AE-124,CRF01AE,3/1/2024 +CRF01AE-125,CRF01AE,3/2/2024 +CRF01AE-126,CRF01AE,3/3/2024 +CRF01AE-127,CRF01AE,3/4/2024 +CRF01AE-128,CRF01AE,3/5/2024 +CRF01AE-129,CRF01AE,3/6/2024 +CRF01AE-130,CRF01AE,3/7/2024 +CRF01AE-131,CRF01AE,3/8/2024 +CRF01AE-132,CRF01AE,3/9/2024 +CRF01AE-133,CRF01AE,3/10/2024 +CRF01AE-134,CRF01AE,3/11/2024 +CRF01AE-135,CRF01AE,3/12/2024 +CRF01AE-136,CRF01AE,3/13/2024 +CRF01AE-137,CRF01AE,3/14/2024 +CRF01AE-138,CRF01AE,3/15/2024 +CRF01AE-139,CRF01AE,3/16/2024 +CRF01AE-140,CRF01AE,3/17/2024 +CRF01AE-141,CRF01AE,3/18/2024 +CRF01AE-142,CRF01AE,3/19/2024 +CRF01AE-143,CRF01AE,3/20/2024 +CRF01AE-144,CRF01AE,3/21/2024 +CRF01AE-145,CRF01AE,3/22/2024 +CRF01AE-146,CRF01AE,3/23/2024 +CRF01AE-147,CRF01AE,3/24/2024 +CRF01AE-148,CRF01AE,3/25/2024 +CRF01AE-149,CRF01AE,3/26/2024 +CRF01AE-150,CRF01AE,3/27/2024 +CRF01AE-151,CRF01AE,3/28/2024 +CRF01AE-152,CRF01AE,3/29/2024 +CRF01AE-153,CRF01AE,3/30/2024 +CRF01AE-154,CRF01AE,3/31/2024 +CRF01AE-155,CRF01AE,4/1/2024 +CRF01AE-156,CRF01AE,4/2/2024 +CRF01AE-157,CRF01AE,4/3/2024 +CRF01AE-158,CRF01AE,4/4/2024 +CRF01AE-159,CRF01AE,4/5/2024 +CRF01AE-160,CRF01AE,4/6/2024 +CRF01AE-161,CRF01AE,4/7/2024 +CRF01AE-162,CRF01AE,4/8/2024 +CRF01AE-163,CRF01AE,4/9/2024 +CRF01AE-164,CRF01AE,4/10/2024 +CRF01AE-165,CRF01AE,4/11/2024 +CRF01AE-166,CRF01AE,4/12/2024 +CRF01AE-167,CRF01AE,4/13/2024 +CRF01AE-168,CRF01AE,4/14/2024 +CRF01AE-169,CRF01AE,4/15/2024 +CRF01AE-170,CRF01AE,4/16/2024 +CRF01AE-171,CRF01AE,4/17/2024 +CRF01AE-172,CRF01AE,4/18/2024 +CRF01AE-173,CRF01AE,4/19/2024 +CRF01AE-174,CRF01AE,4/20/2024 +CRF01AE-175,CRF01AE,4/21/2024 +CRF01AE-176,CRF01AE,4/22/2024 +CRF01AE-177,CRF01AE,4/23/2024 +CRF01AE-178,CRF01AE,4/24/2024 +CRF01AE-179,CRF01AE,4/25/2024 +CRF01AE-180,CRF01AE,4/26/2024 +CRF01AE-181,CRF01AE,4/27/2024 +CRF01AE-182,CRF01AE,4/28/2024 +CRF01AE-183,CRF01AE,4/29/2024 +CRF01AE-184,CRF01AE,4/30/2024 +CRF01AE-185,CRF01AE,5/1/2024 +CRF01AE-186,CRF01AE,5/2/2024 +CRF01AE-187,CRF01AE,5/3/2024 +CRF01AE-188,CRF01AE,5/4/2024 +CRF01AE-189,CRF01AE,5/5/2024 +CRF01AE-190,CRF01AE,5/6/2024 +CRF01AE-191,CRF01AE,5/7/2024 +CRF01AE-192,CRF01AE,5/8/2024 +CRF01AE-193,CRF01AE,5/9/2024 +CRF01AE-194,CRF01AE,5/10/2024 +CRF01AE-195,CRF01AE,5/11/2024 +CRF01AE-196,CRF01AE,5/12/2024 +CRF01AE-197,CRF01AE,5/13/2024 +CRF01AE-198,CRF01AE,5/14/2024 +CRF01AE-199,CRF01AE,5/15/2024 +CRF01AE-200,CRF01AE,5/16/2024 +CRF01AE-201,CRF01AE,5/17/2024 +CRF01AE-202,CRF01AE,5/18/2024 +CRF01AE-203,CRF01AE,5/19/2024 +CRF01AE-204,CRF01AE,5/20/2024 +CRF01AE-205,CRF01AE,5/21/2024 +CRF01AE-206,CRF01AE,5/22/2024 +CRF01AE-207,CRF01AE,5/23/2024 +CRF01AE-208,CRF01AE,2/6/2024 +CRF01AE-209,CRF01AE,2/7/2024 +CRF01AE-210,CRF01AE,2/8/2024 +CRF01AE-211,CRF01AE,2/9/2024 +CRF01AE-212,CRF01AE,2/10/2024 +CRF01AE-213,CRF01AE,2/11/2024 +CRF01AE-214,CRF01AE,2/12/2024 +CRF01AE-215,CRF01AE,2/13/2024 +CRF01AE-216,CRF01AE,2/14/2024 +CRF01AE-217,CRF01AE,2/15/2024 +CRF01AE-218,CRF01AE,2/16/2024 +CRF01AE-219,CRF01AE,2/17/2024 +CRF01AE-220,CRF01AE,2/18/2024 +CRF01AE-221,CRF01AE,2/19/2024 +CRF01AE-222,CRF01AE,2/20/2024 +CRF01AE-223,CRF01AE,2/21/2024 +CRF01AE-224,CRF01AE,2/22/2024 +CRF01AE-225,CRF01AE,2/23/2024 +CRF01AE-226,CRF01AE,2/24/2024 +CRF01AE-227,CRF01AE,2/25/2024 +CRF01AE-228,CRF01AE,2/26/2024 +CRF01AE-229,CRF01AE,2/27/2024 +CRF01AE-230,CRF01AE,2/28/2024 +CRF01AE-231,CRF01AE,2/29/2024 +CRF01AE-232,CRF01AE,3/1/2024 +CRF01AE-233,CRF01AE,3/2/2024 +CRF01AE-234,CRF01AE,3/3/2024 +CRF01AE-235,CRF01AE,3/4/2024 +CRF01AE-236,CRF01AE,3/5/2024 +CRF01AE-237,CRF01AE,3/6/2024 +CRF01AE-238,CRF01AE,3/7/2024 +CRF01AE-239,CRF01AE,3/8/2024 +CRF01AE-240,CRF01AE,3/9/2024 +CRF01AE-241,CRF01AE,3/10/2024 +CRF01AE-242,CRF01AE,3/11/2024 +CRF01AE-243,CRF01AE,3/12/2024 +CRF01AE-244,CRF01AE,3/13/2024 +CRF01AE-245,CRF01AE,3/14/2024 +CRF01AE-246,CRF01AE,3/15/2024 +CRF01AE-247,CRF01AE,3/16/2024 +CRF01AE-248,CRF01AE,3/17/2024 +CRF01AE-249,CRF01AE,3/18/2024 +CRF01AE-250,CRF01AE,3/19/2024 +CRF01AE-251,CRF01AE,3/20/2024 +CRF01AE-252,CRF01AE,3/21/2024 +CRF01AE-253,CRF01AE,3/22/2024 +CRF01AE-254,CRF01AE,3/23/2024 +CRF01AE-255,CRF01AE,3/24/2024 +CRF01AE-256,CRF01AE,3/25/2024 +CRF01AE-257,CRF01AE,3/26/2024 +CRF01AE-258,CRF01AE,3/27/2024 +CRF01AE-259,CRF01AE,3/28/2024 +CRF01AE-260,CRF01AE,3/29/2024 +CRF01AE-261,CRF01AE,3/30/2024 +CRF01AE-262,CRF01AE,3/31/2024 +CRF01AE-263,CRF01AE,4/1/2024 +CRF01AE-264,CRF01AE,4/2/2024 +CRF01AE-265,CRF01AE,4/3/2024 +CRF01AE-266,CRF01AE,4/4/2024 +CRF01AE-267,CRF01AE,4/5/2024 +CRF01AE-268,CRF01AE,4/6/2024 +CRF01AE-269,CRF01AE,4/7/2024 +CRF01AE-270,CRF01AE,4/8/2024 +CRF01AE-271,CRF01AE,4/9/2024 +CRF01AE-272,CRF01AE,4/10/2024 +CRF01AE-273,CRF01AE,4/11/2024 +CRF01AE-274,CRF01AE,4/12/2024 +CRF01AE-275,CRF01AE,4/13/2024 +CRF01AE-276,CRF01AE,4/14/2024 +CRF01AE-277,CRF01AE,4/15/2024 +CRF01AE-278,CRF01AE,4/16/2024 +CRF01AE-279,CRF01AE,4/17/2024 +CRF01AE-280,CRF01AE,4/18/2024 +CRF01AE-281,CRF01AE,4/19/2024 +CRF01AE-282,CRF01AE,4/20/2024 +CRF01AE-283,CRF01AE,4/21/2024 +CRF01AE-284,CRF01AE,4/22/2024 +CRF01AE-285,CRF01AE,4/23/2024 +CRF01AE-286,CRF01AE,4/24/2024 +CRF01AE-287,CRF01AE,4/25/2024 +CRF01AE-288,CRF01AE,4/26/2024 +CRF01AE-289,CRF01AE,4/27/2024 +CRF01AE-290,CRF01AE,4/28/2024 +CRF01AE-291,CRF01AE,4/29/2024 +CRF01AE-292,CRF01AE,4/30/2024 +CRF01AE-293,CRF01AE,5/1/2024 +CRF01AE-294,CRF01AE,5/2/2024 +CRF01AE-295,CRF01AE,5/3/2024 +CRF01AE-296,CRF01AE,5/4/2024 +CRF01AE-297,CRF01AE,5/5/2024 +CRF01AE-298,CRF01AE,5/6/2024 +CRF01AE-299,CRF01AE,5/7/2024 +CRF01AE-300,CRF01AE,5/8/2024 +CRF01AE-301,CRF01AE,5/9/2024 +CRF01AE-302,CRF01AE,5/10/2024 +CRF01AE-303,CRF01AE,5/11/2024 +CRF01AE-304,CRF01AE,5/12/2024 +CRF01AE-305,CRF01AE,5/13/2024 +CRF01AE-306,CRF01AE,5/14/2024 +CRF01AE-307,CRF01AE,5/15/2024 +CRF01AE-308,CRF01AE,5/16/2024 +CRF01AE-309,CRF01AE,5/17/2024 +CRF01AE-310,CRF01AE,5/18/2024 +CRF01AE-311,CRF01AE,5/19/2024 +CRF01AE-312,CRF01AE,5/20/2024 +CRF01AE-313,CRF01AE,5/21/2024 +CRF01AE-314,CRF01AE,5/22/2024 +CRF01AE-315,CRF01AE,5/23/2024 +CRF01AE-316,CRF01AE,2/6/2024 +CRF01AE-317,CRF01AE,2/7/2024 +CRF01AE-318,CRF01AE,2/8/2024 +CRF01AE-319,CRF01AE,2/9/2024 +CRF01AE-320,CRF01AE,2/10/2024 +CRF01AE-321,CRF01AE,2/11/2024 +CRF01AE-322,CRF01AE,2/12/2024 +CRF01AE-323,CRF01AE,2/13/2024 +CRF01AE-324,CRF01AE,2/14/2024 +CRF01AE-325,CRF01AE,2/15/2024 +CRF01AE-326,CRF01AE,2/16/2024 +CRF01AE-327,CRF01AE,2/17/2024 +CRF01AE-328,CRF01AE,2/18/2024 +CRF01AE-329,CRF01AE,2/19/2024 +CRF01AE-330,CRF01AE,2/20/2024 +CRF01AE-331,CRF01AE,2/21/2024 +CRF01AE-332,CRF01AE,2/22/2024 +CRF01AE-333,CRF01AE,2/23/2024 +CRF01AE-334,CRF01AE,2/24/2024 +CRF01AE-335,CRF01AE,2/25/2024 +CRF01AE-336,CRF01AE,2/26/2024 +CRF01AE-337,CRF01AE,2/27/2024 +CRF01AE-338,CRF01AE,2/28/2024 +CRF01AE-339,CRF01AE,2/29/2024 +CRF01AE-340,CRF01AE,3/1/2024 +CRF01AE-341,CRF01AE,3/2/2024 +CRF01AE-342,CRF01AE,3/3/2024 +CRF01AE-343,CRF01AE,3/4/2024 +CRF01AE-344,CRF01AE,3/5/2024 +CRF01AE-345,CRF01AE,3/6/2024 +CRF01AE-346,CRF01AE,3/7/2024 +CRF01AE-347,CRF01AE,3/8/2024 +CRF01AE-348,CRF01AE,3/9/2024 +CRF01AE-349,CRF01AE,3/10/2024 +CRF01AE-350,CRF01AE,3/11/2024 +CRF01AE-351,CRF01AE,3/12/2024 +CRF01AE-352,CRF01AE,3/13/2024 +CRF01AE-353,CRF01AE,3/14/2024 +CRF01AE-354,CRF01AE,3/15/2024 +CRF01AE-355,CRF01AE,3/16/2024 +CRF01AE-356,CRF01AE,3/17/2024 +CRF01AE-357,CRF01AE,3/18/2024 +CRF01AE-358,CRF01AE,3/19/2024 +CRF01AE-359,CRF01AE,3/20/2024 +CRF01AE-360,CRF01AE,3/21/2024 +CRF01AE-361,CRF01AE,3/22/2024 +CRF01AE-362,CRF01AE,3/23/2024 +CRF01AE-363,CRF01AE,3/24/2024 +CRF01AE-364,CRF01AE,3/25/2024 +CRF01AE-365,CRF01AE,3/26/2024 +CRF01AE-366,CRF01AE,3/27/2024 +CRF01AE-367,CRF01AE,3/28/2024 +CRF01AE-368,CRF01AE,3/29/2024 +CRF01AE-369,CRF01AE,3/30/2024 +CRF01AE-370,CRF01AE,3/31/2024 +CRF01AE-371,CRF01AE,4/1/2024 +CRF01AE-372,CRF01AE,4/2/2024 +CRF01AE-373,CRF01AE,4/3/2024 +CRF01AE-374,CRF01AE,4/4/2024 +CRF01AE-375,CRF01AE,4/5/2024 +CRF01AE-376,CRF01AE,4/6/2024 +CRF01AE-377,CRF01AE,4/7/2024 +CRF01AE-378,CRF01AE,4/8/2024 +CRF01AE-379,CRF01AE,4/9/2024 +CRF01AE-380,CRF01AE,4/10/2024 +CRF01AE-381,CRF01AE,4/11/2024 +CRF01AE-382,CRF01AE,4/12/2024 +CRF01AE-383,CRF01AE,4/13/2024 +CRF01AE-384,CRF01AE,4/14/2024 +CRF01AE-385,CRF01AE,4/15/2024 +CRF01AE-386,CRF01AE,4/16/2024 +CRF01AE-387,CRF01AE,4/17/2024 +CRF01AE-388,CRF01AE,4/18/2024 +CRF01AE-389,CRF01AE,4/19/2024 +CRF01AE-390,CRF01AE,4/20/2024 +CRF01AE-391,CRF01AE,4/21/2024 +CRF01AE-392,CRF01AE,4/22/2024 +CRF01AE-393,CRF01AE,4/23/2024 +CRF01AE-394,CRF01AE,4/24/2024 +CRF01AE-395,CRF01AE,4/25/2024 +CRF01AE-396,CRF01AE,4/26/2024 +CRF01AE-397,CRF01AE,4/27/2024 +CRF01AE-398,CRF01AE,4/28/2024 +CRF01AE-399,CRF01AE,4/29/2024 +CRF01AE-400,CRF01AE,4/30/2024 +C-1,C,5/1/2024 +C-2,C,5/2/2024 +C-3,C,5/3/2024 +C-4,C,5/4/2024 +C-5,C,5/5/2024 +C-6,C,5/6/2024 +C-7,C,5/7/2024 +C-8,C,5/8/2024 +C-9,C,5/9/2024 +C-10,C,5/10/2024 +C-11,C,5/11/2024 +C-12,C,5/12/2024 +C-13,C,5/13/2024 +C-14,C,5/14/2024 +C-15,C,5/15/2024 +C-16,C,5/16/2024 +C-17,C,5/17/2024 +C-18,C,5/18/2024 +C-19,C,5/19/2024 +C-20,C,5/20/2024 +C-21,C,5/21/2024 +C-22,C,5/22/2024 +C-23,C,5/23/2024 +C-24,C,2/6/2024 +C-25,C,2/7/2024 +C-26,C,2/8/2024 +C-27,C,2/9/2024 +C-28,C,2/10/2024 +C-29,C,2/11/2024 +C-30,C,2/12/2024 +C-31,C,2/13/2024 +C-32,C,2/14/2024 +C-33,C,2/15/2024 +C-34,C,2/16/2024 +C-35,C,2/17/2024 +C-36,C,2/18/2024 +C-37,C,2/19/2024 +C-38,C,2/20/2024 +C-39,C,2/21/2024 +C-40,C,2/22/2024 +C-41,C,2/23/2024 +C-42,C,2/24/2024 +C-43,C,2/25/2024 +C-44,C,2/26/2024 +C-45,C,2/27/2024 +C-46,C,2/28/2024 +C-47,C,2/29/2024 +C-48,C,3/1/2024 +C-49,C,3/2/2024 +C-50,C,3/3/2024 +C-51,C,3/4/2024 +C-52,C,3/5/2024 +C-53,C,3/6/2024 +C-54,C,3/7/2024 +C-55,C,3/8/2024 +C-56,C,3/9/2024 +C-57,C,3/10/2024 +C-58,C,3/11/2024 +C-59,C,3/12/2024 +C-60,C,3/13/2024 +C-61,C,3/14/2024 +C-62,C,3/15/2024 +C-63,C,3/16/2024 +C-64,C,3/17/2024 +C-65,C,3/18/2024 +C-66,C,3/19/2024 +C-67,C,3/20/2024 +C-68,C,3/21/2024 +C-69,C,3/22/2024 +C-70,C,3/23/2024 +C-71,C,3/24/2024 +C-72,C,3/25/2024 +C-73,C,3/26/2024 +C-74,C,3/27/2024 +C-75,C,3/28/2024 +C-76,C,3/29/2024 +C-77,C,3/30/2024 +C-78,C,3/31/2024 +C-79,C,4/1/2024 +C-80,C,4/2/2024 +C-81,C,4/3/2024 +C-82,C,4/4/2024 +C-83,C,4/5/2024 +C-84,C,4/6/2024 +C-85,C,4/7/2024 +C-86,C,4/8/2024 +C-87,C,4/9/2024 +C-88,C,4/10/2024 +C-89,C,4/11/2024 +C-90,C,4/12/2024 +C-91,C,4/13/2024 +C-92,C,4/14/2024 +C-93,C,4/15/2024 +C-94,C,4/16/2024 +C-95,C,4/17/2024 +C-96,C,4/18/2024 +C-97,C,4/19/2024 +C-98,C,4/20/2024 +C-99,C,4/21/2024 +C-100,C,4/22/2024 +C-101,C,4/23/2024 +C-102,C,4/24/2024 +C-103,C,4/25/2024 +C-104,C,4/26/2024 +C-105,C,4/27/2024 +C-106,C,4/28/2024 +C-107,C,4/29/2024 +C-108,C,4/30/2024 +C-109,C,5/1/2024 +C-110,C,5/2/2024 +C-111,C,5/3/2024 +C-112,C,5/4/2024 +C-113,C,5/5/2024 +C-114,C,5/6/2024 +C-115,C,5/7/2024 +C-116,C,5/8/2024 +C-117,C,5/9/2024 +C-118,C,5/10/2024 +C-119,C,5/11/2024 +C-120,C,5/12/2024 +C-121,C,5/13/2024 +C-122,C,5/14/2024 +C-123,C,5/15/2024 +C-124,C,5/16/2024 +C-125,C,5/17/2024 +C-126,C,5/18/2024 +C-127,C,5/19/2024 +C-128,C,5/20/2024 +C-129,C,5/21/2024 +C-130,C,5/22/2024 +C-131,C,5/23/2024 +C-132,C,2/6/2024 +C-133,C,2/7/2024 +C-134,C,2/8/2024 +C-135,C,2/9/2024 +C-136,C,2/10/2024 +C-137,C,2/11/2024 +C-138,C,2/12/2024 +C-139,C,2/13/2024 +C-140,C,2/14/2024 +C-141,C,2/15/2024 +C-142,C,2/16/2024 +C-143,C,2/17/2024 +C-144,C,2/18/2024 +C-145,C,2/19/2024 +C-146,C,2/20/2024 +C-147,C,2/21/2024 +C-148,C,2/22/2024 +C-149,C,2/23/2024 +C-150,C,2/24/2024 +C-151,C,2/25/2024 +C-152,C,2/26/2024 +C-153,C,2/27/2024 +C-154,C,2/28/2024 +C-155,C,2/29/2024 +C-156,C,3/1/2024 +C-157,C,3/2/2024 +C-158,C,3/3/2024 +C-159,C,3/4/2024 +C-160,C,3/5/2024 +C-161,C,3/6/2024 +C-162,C,3/7/2024 +C-163,C,3/8/2024 +C-164,C,3/9/2024 +C-165,C,3/10/2024 +C-166,C,3/11/2024 +C-167,C,3/12/2024 +C-168,C,3/13/2024 +C-169,C,3/14/2024 +C-170,C,3/15/2024 +C-171,C,3/16/2024 +C-172,C,3/17/2024 +C-173,C,3/18/2024 +C-174,C,3/19/2024 +C-175,C,3/20/2024 +C-176,C,3/21/2024 +C-177,C,3/22/2024 +C-178,C,3/23/2024 +C-179,C,3/24/2024 +C-180,C,3/25/2024 +C-181,C,3/26/2024 +C-182,C,3/27/2024 +C-183,C,3/28/2024 +C-184,C,3/29/2024 +C-185,C,3/30/2024 +C-186,C,3/31/2024 +C-187,C,4/1/2024 +C-188,C,4/2/2024 +C-189,C,4/3/2024 +C-190,C,4/4/2024 +C-191,C,4/5/2024 +C-192,C,4/6/2024 +C-193,C,4/7/2024 +C-194,C,4/8/2024 +C-195,C,4/9/2024 +C-196,C,4/10/2024 +C-197,C,4/11/2024 +C-198,C,4/12/2024 +C-199,C,4/13/2024 +C-200,C,4/14/2024 +C-201,C,4/15/2024 +C-202,C,4/16/2024 +C-203,C,4/17/2024 +C-204,C,4/18/2024 +C-205,C,4/19/2024 +C-206,C,4/20/2024 +C-207,C,4/21/2024 +C-208,C,4/22/2024 +C-209,C,4/23/2024 +C-210,C,4/24/2024 +C-211,C,4/25/2024 +C-212,C,4/26/2024 +C-213,C,4/27/2024 +C-214,C,4/28/2024 +C-215,C,4/29/2024 +C-216,C,4/30/2024 +C-217,C,5/1/2024 +C-218,C,5/2/2024 +C-219,C,5/3/2024 +C-220,C,5/4/2024 +C-221,C,5/5/2024 +C-222,C,5/6/2024 +C-223,C,5/7/2024 +C-224,C,5/8/2024 +C-225,C,5/9/2024 +C-226,C,5/10/2024 +C-227,C,5/11/2024 +C-228,C,5/12/2024 +C-229,C,5/13/2024 +C-230,C,5/14/2024 +C-231,C,5/15/2024 +C-232,C,5/16/2024 +C-233,C,5/17/2024 +C-234,C,5/18/2024 +C-235,C,5/19/2024 +C-236,C,5/20/2024 +C-237,C,5/21/2024 +C-238,C,5/22/2024 +C-239,C,5/23/2024 +C-240,C, +C-241,C,2/6/2024 +C-242,C,2/7/2024 +C-243,C,2/8/2024 +C-244,C,2/9/2024 +C-245,C,2/10/2024 +C-246,C,2/11/2024 +C-247,C,2/12/2024 +C-248,C,2/13/2024 +C-249,C,2/14/2024 +C-250,C,2/15/2024 +C-251,C,2/16/2024 +C-252,C,2/17/2024 +C-253,C,2/18/2024 +C-254,C,2/19/2024 +C-255,C,2/20/2024 +C-256,C,2/21/2024 +C-257,C,2/22/2024 +C-258,C,2/23/2024 +C-259,C,2/24/2024 +C-260,C,2/25/2024 +C-261,C,2/26/2024 +C-262,C,2/27/2024 +C-263,C,2/28/2024 +C-264,C,2/29/2024 +C-265,C,3/1/2024 +C-266,C,3/2/2024 +C-267,C,3/3/2024 +C-268,C,3/4/2024 +C-269,C,3/5/2024 +C-270,C,3/6/2024 +C-271,C,3/7/2024 +C-272,C,3/8/2024 +C-273,C,3/9/2024 +C-274,C,3/10/2024 +C-275,C,3/11/2024 +C-276,C,3/12/2024 +C-277,C,3/13/2024 +C-278,C,3/14/2024 +C-279,C,3/15/2024 +C-280,C,3/16/2024 +C-281,C,3/17/2024 +C-282,C,3/18/2024 +C-283,C,3/19/2024 +C-284,C,3/20/2024 +C-285,C,3/21/2024 +C-286,C,3/22/2024 +C-287,C,3/23/2024 +C-288,C,3/24/2024 +C-289,C,3/25/2024 +C-290,C,3/26/2024 +C-291,C,3/27/2024 +C-292,C,3/28/2024 +C-293,C,3/29/2024 +C-294,C,3/30/2024 +C-295,C,3/31/2024 +C-296,C,4/1/2024 +C-297,C,4/2/2024 +C-298,C,4/3/2024 +C-299,C,4/4/2024 +C-300,C,4/5/2024 +C-301,C,4/6/2024 +C-302,C,4/7/2024 +C-303,C,4/8/2024 +C-304,C,4/9/2024 +C-305,C,4/10/2024 +C-306,C,4/11/2024 +C-307,C,4/12/2024 +C-308,C,4/13/2024 +C-309,C,4/14/2024 +C-310,C,4/15/2024 +C-311,C,4/16/2024 +C-312,C,4/17/2024 +C-313,C,4/18/2024 +C-314,C,4/19/2024 +C-315,C,4/20/2024 +C-316,C,4/21/2024 +C-317,C,4/22/2024 +C-318,C,4/23/2024 +C-319,C,4/24/2024 +C-320,C,4/25/2024 +C-321,C,4/26/2024 +C-322,C,4/27/2024 +C-323,C,4/28/2024 +C-324,C,4/29/2024 +C-325,C,4/30/2024 +C-326,C,5/1/2024 +C-327,C,5/2/2024 +C-328,C,5/3/2024 +C-329,C,5/4/2024 +C-330,C,5/5/2024 +C-331,C,5/6/2024 +C-332,C,5/7/2024 +C-333,C,5/8/2024 +C-334,C,5/9/2024 +C-335,C,5/10/2024 +C-336,C,5/11/2024 +C-337,C,5/12/2024 +C-338,C,5/13/2024 +C-339,C,5/14/2024 +C-340,C,5/15/2024 +C-341,C,5/16/2024 +C-342,C,5/17/2024 +C-343,C,5/18/2024 +C-344,C,5/19/2024 +C-345,C,5/20/2024 +C-346,C,5/21/2024 +C-347,C,5/22/2024 +C-348,C,5/23/2024 +C-349,C, +C-350,C,2/6/2024 +C-351,C,2/7/2024 +C-352,C,2/8/2024 +C-353,C,2/9/2024 +C-354,C,2/10/2024 +C-355,C,2/11/2024 +C-356,C,2/12/2024 +C-357,C,2/13/2024 +C-358,C,2/14/2024 +C-359,C,2/15/2024 +C-360,C,2/16/2024 +C-361,C,2/17/2024 +C-362,C,2/18/2024 +C-363,C,2/19/2024 +C-364,C,2/20/2024 +C-365,C,2/21/2024 +C-366,C,2/22/2024 +C-367,C,2/23/2024 +C-368,C,2/24/2024 +C-369,C,2/25/2024 +C-370,C,2/26/2024 +C-371,C,2/27/2024 +C-372,C,2/28/2024 +C-373,C,2/29/2024 +C-374,C,3/1/2024 +C-375,C,3/2/2024 +C-376,C,3/3/2024 +C-377,C,3/4/2024 +C-378,C,3/5/2024 +C-379,C,3/6/2024 +C-380,C,3/7/2024 +C-381,C,3/8/2024 +C-382,C,3/9/2024 +C-383,C,3/10/2024 +C-384,C,3/11/2024 +C-385,C,3/12/2024 +C-386,C,3/13/2024 +C-387,C,3/14/2024 +C-388,C,3/15/2024 +C-389,C,3/16/2024 +C-390,C,3/17/2024 +C-391,C,3/18/2024 +C-392,C,3/19/2024 +C-393,C,3/20/2024 +C-394,C,3/21/2024 +C-395,C,3/22/2024 +C-396,C,3/23/2024 +C-397,C,3/24/2024 +C-398,C,3/25/2024 +C-399,C,3/26/2024 +C-400,C,3/27/2024 diff --git a/cypress/fixtures/Large_Dataset_forTesting_epiLinks.csv b/cypress/fixtures/Large_Dataset_forTesting_epiLinks.csv new file mode 100644 index 00000000..1581aca5 --- /dev/null +++ b/cypress/fixtures/Large_Dataset_forTesting_epiLinks.csv @@ -0,0 +1,60 @@ +ID1,ID2 +A-81,A-82 +A-81,A-83 +A-81,A-84 +A-81,A-85 +A-81,A-86 +A-81,A-88 +A-81,A-89 +A-81,A-91 +A-81,A-92 +A-81,A-93 +A-81,A-94 +A-81,A-95 +A-81,A-96 +A-81,A-97 +A-157,A-158 +A-81,A-100 +A-81,A-101 +B-246,B-247 +A-1,A-2 +A-157,A-161 +B-246,B-250 +A-1,A-3 +A-81,A-104 +B-246,B-251 +A-1,A-4 +A-81,A-105 +A-1,A-5 +A-81,A-106 +A-1,A-6 +A-81,A-107 +A-157,A-166 +A-1,A-7 +A-81,A-108 +B-246,B-255 +A-1,A-8 +A-81,A-109 +A-1,A-9 +A-81,A-110 +B-246,B-257 +A-1,A-10 +A-81,A-111 +B-246,B-258 +A-1,A-11 +A-81,A-112 +A-1,A-12 +A-81,A-113 +A-1,A-13 +A-81,A-114 +A-157,A-174 +B-246,B-261 +A-81,A-115 +B-195,B-198 +A-1,A-14 +A-81,A-116 +A-157,A-175 +B-294,B-306 +A-1,A-15 +B-246,B-262 +A-81,A-117 diff --git a/cypress/fixtures/SARSCoV2_Simulated_Sequences_NJ_tree_snp.nwk b/cypress/fixtures/SARSCoV2_Simulated_Sequences_NJ_tree_snp.nwk new file mode 100644 index 00000000..2760b349 --- /dev/null +++ b/cypress/fixtures/SARSCoV2_Simulated_Sequences_NJ_tree_snp.nwk @@ -0,0 +1 @@ +(((((((((MZ375596:0.00000000,MZ797832:0.00003363)0.4100:0.00000083,MZ797965:0.00013360)0.6600:0.00003374,MZ761907:0.00013685)0.5200:0.00000410,MZ712835:0.00019850)0.7800:0.00005686,(MZ637292:0.00006631,MZ797748:0.00010189)0.8900:0.00010308)0.2000:0.00000480,MZ798055:0.00033180)0.4000:0.00001626,(MZ745181:0.00029394,(MZ797703:0.00020236,MZ797839:0.00040304)0.5400:0.00000873)0.4800:0.00001034)1.0000:0.00033306,(MZ797980:0.00027249,(MZ762276:0.00041993,(MZ712879:0.00008959,MZ745515:0.00007867)0.9300:0.00014201)1.0000:0.00020010)0.7800:0.00006158)1.0000:0.00027277,(MZ415508:0.00041414,MZ505967:0.00046010)1.0000:0.00023396,((((MZ744285:0.00033669,MZ744384:0.00016785)0.9800:0.00010077,MZ797735:0.00033700)1.0000:0.00004809,MZ797519:0.00045680)1.0000:0.00074829,((((MZ727689:0.00013541,MZ727698:0.00003628)1.0000:0.00027338,MZ727700:0.00020188)0.8000:0.00001106,MZ727701:0.00019052)1.0000:0.00066033,((MZ591568:0.00028846,MZ696569:0.00042893)1.0000:0.00037190,(MZ759709:0.00039806,(MZ740979:0.00078536,MZ787305:0.00032973)0.7300:0.00003907)1.0000:0.00033071)0.7100:0.00007068)0.5300:0.00002222)1.0000:0.00032077); diff --git a/cypress/fixtures/SARSCoV2_Simulated_Sequences_snp.fas b/cypress/fixtures/SARSCoV2_Simulated_Sequences_snp.fas new file mode 100644 index 00000000..a0ffd8fb --- /dev/null +++ b/cypress/fixtures/SARSCoV2_Simulated_Sequences_snp.fas @@ -0,0 +1,14940 @@ +>MZ744285 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaatatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacctaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agacaacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttattagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattac +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcattccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaacactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgctaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaatcctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattga +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgttgtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttcttttttttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaatcttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctataagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttcttaatcacccattcagtgcatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacttggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ744384 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaatatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattac +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcattccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +ggacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +tcttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgctaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattga +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaat +tgttcgtggatgaggctggttcttaatcacccattcagtgcatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcacc +ctgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcat +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797519 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattattttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccatctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattac +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggctttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcgggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgatgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataggcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaggctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattga +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcacttttttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caataatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaattttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaatttttctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacacacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtgcatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtggacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797735 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtctgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaacagctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactattattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgataactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttattttacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattac +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgtaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttattaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacctggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaacagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcatcttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacctcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcttattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaatttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgcta------tctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttt------accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattga +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccataaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatccttgcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacacacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaactgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaacccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tatatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtacttaacatcaaccatatgtagttgatgacccgtgtcctattt +acttctattctaaatggtatattagagtaggagctataaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttcttaatcacccattcagtgcatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctctaaatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaaacgaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtttggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ591568 +------------------aactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactct +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggtttgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattttaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagtcatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaattggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttatttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttagggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttataagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgctaaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttttgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcatggtctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaa---------ctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaatattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacacaaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattactttaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcttgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcttgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +ttatctaaacgaacaaactaaaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatct------------------------ +------------------------------------------------------------ +------------------------------------------------------------ +------------------------- +>MZ696569 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactct +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaagnnnnnnnggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatnnnntggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtnnnnnn +nnnnnnnnnnnnnnattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcnnnnnnnnnnnnnnnnnnnnnt +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagccttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgnnnnnnnnnnnnnnncacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctnnaaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagtnntctgggtaggtacatgtcagcatt +aaatcacactaaaaattggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagannnnnnnnnnnnnnnnnnnnnttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaanaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatgnnnnnnctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgttggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttannnnnnnnnnnnnnnnnnnagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttnntagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggnnnnnnnnnnnnnnnnnnnnnnnnnntaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttagggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggaaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactattttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtactttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgacagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaattgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttgnnnnnnncgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnntcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattacccccttcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgctaaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtggtctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaa---------ctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaatattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacttcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattactttaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcttgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgtggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +ttatctaaacgaacaaactaaaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctacggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +ttttggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ375596 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +tttgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ637292 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattgtacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgttgcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagtgtggagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaattacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgac +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttaattt +taatctaaacgaacaaactaaaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccc-------- +------------------------- +>MZ712835 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacnnctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaagtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgccc +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaatttcttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagtaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggntgtttatt---accacaaaaacaacaa +aagttggatggaaagtgnnnnnngagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccaggtcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaana +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgannacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttannnt +taatctaaacgaacaaactnaaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggagtacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccc-------- +------------------------- +>MZ712879 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagattgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaga +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgattactaccacacaactgatcttagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacnctttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcatc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagttct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaat +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaataagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtntacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtttagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaactagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggntgtttatt---accacaaaaacaacaa +aagttggatggaaagtgnnnnnngagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggttttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctataga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaana +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgannacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttannnt +taatctaaacgaacaaactnaaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttgttggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccc-------- +------------------------- +>MZ745181 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttattggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttattcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaatatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctatctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatttgtagttgatgacccgtgtcccattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +taccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccaatcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ745515 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagattgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgattactaccacacaactgatcttagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacgctttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagttct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaat +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaataagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtttacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggttttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctataga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaattttttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttgttggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ761907 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaagnnnnnnnggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatnnnntggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtnnnnnn +nnnnnnnnnnnnnnattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaaggtgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcnnnnnnnnnnnnnnnnnnnnnt +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgnnnnnnnnnnnnnnncacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctnnaaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagtnntctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagannnnnnnnnnnnnnnnnnnnnttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaanactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatgnnnnnnctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttannnnnnnnnnnnnnnnnnnagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttnntagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggnnnnnnnnnnnnnnnnnnnnnnnnnntaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtatttccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatnngaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttgnnnnnnncgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctannnnnnnnnaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtgatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatctctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ762276 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaagnnnnnnnggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatnnnntggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtnnnnnn +nnnnnnnnnnnnnnattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcnnnnnnnnnnnnnnnnnnnnnt +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgnnnnnnnnnnnnnnncacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctnnaaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcttagtnntctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagannnnnnnnnnnnnnnnnnnnnttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacgctttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaanaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatgnnnnnnctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggcccctatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttannnnnnnnnnnnnnnnnnnagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttnntagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggnnnnnnnnnnnnnnnnnnnnnnnnnntaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagttct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaat +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatnngaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtttacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcatacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttgnnnnnnncgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaactagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctannnnnnnnnaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccgtttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggttttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgatacctatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacacttgtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcnnnnngctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +atcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgaaggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctactc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcatgcctaaactcatgcagaccacacaaggcatatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggacactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797703 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgttgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttttatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattatcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaacagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaattgtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcataagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797748 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgttacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaattataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttttt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattgtacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaattacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgac +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797832 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +tttgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggactcgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797839 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagattgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatatctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatattttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacatatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgtcctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtttgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattatgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcatttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattacccccttcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaattcaattgagtacagacactggtgttgaacatgttacattcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcataaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797965 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgttcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatggtgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +tttgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatcagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttatatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggcacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacattcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ797980 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcactaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggtgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcttagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgcttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtacttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagrgctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cttaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattttgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccgttactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacattcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ798055 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaagttcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggtctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgttaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaagtctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagctttgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaactagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctatatcttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgtaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgattttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccatt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtggt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtactaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaagtctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcagttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaactacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgttaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttagaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtg------gagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggctggtagcaaaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctaccgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacattaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagatagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaatttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgtttta---- +--atctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaaggccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggctgtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattggggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ740979 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataattaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcaactcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaatatcataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagatggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tatctgtgtggaaactaaagctatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtactnnnattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctgtttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagggaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcctacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaatctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttacttacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgatcct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattacgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcnnnnnnnnaccattcttatgt +tgtaaatgctgttannnnnnnntcatatcaacatcacataaattagtcttgtctgttnnn +nnnnntgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacacgtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttctagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcacctttagaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactacacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaggctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaactacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgttttttttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtggttcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggcnnnnnnnncaccttgtaatggtgttgaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccatgttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttactacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaataacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgatactgatacaagcctcactccttttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgatgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacgnngtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcataactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctattaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactctaggcagcagtaggggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatatctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggttccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgnnnnnnnnn +nnnnnntgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ759709 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtatacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcctacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgtattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacacgtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcgaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgttttttttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtggttcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttctgattttgttcgcgctactgca +acgataccgatacaagcctcactccttttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tctaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +agcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgattttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcataactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactctaggcagcagtaaacgaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatatctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +tacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttctgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ787305 +------------------aactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacatcttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tttaaagttgcgtagtgatgtgctattacctcctacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaattcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttg---------aagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaaggtgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcgcgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttattggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacacgtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattgagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttggaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgttttttttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtggttcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcctcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgtagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccttttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcataactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctattaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactctaggcagcagtaggggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatatctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaacctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgagtccacgcggagtacg +atcgagtgtacattgaacaatgctagggagagctg------------------------- +------------------------- +>MZ727689 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcatacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccagcagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctggttttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgactagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctttagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaataaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaatagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacttttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcttcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagtttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttttctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tc-tctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagttcagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaacagggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtac------------------------------------------------- +------------------------- +>MZ727698 +--atctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctnnnnnnnnnnnnnnnnttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcatacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaannnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataacnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagyacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctttagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagawgtatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaatagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacttttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcttcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +agnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnnatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn +nnnnnnnnnnnnnnnnnnnttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttttctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagttcagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaacagggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcg-gtgtac------------------------------------------------- +------------------------- +>MZ727700 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccggtctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccagcagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaatttaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggatttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccccgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcttat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccaggtcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ727701 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgtgttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccagcagtggttgttaatgcagccaatgtttaccttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccattcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaattggcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacattagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggactattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagtttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgttaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagataacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaatctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccactgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcgagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattctactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaatcagaatatttcaattcagtgtgt +agacttatgaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtttagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacatcggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagtttaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +aaggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ttcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttgggtgttacttctaaccacaaaaacaacaa +aagttggatggaaagtgagtccagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccaaatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttacctgtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttaaaggttttaattgttactt +tcctttacaatcatatggtttccaacccacttatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcatcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaaa +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acaagaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactccttcagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcatagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacatacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagtt----atccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatatttgtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagtttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcaaaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgttctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttttaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaactataatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtaggggaatttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggctgatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccacgcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ415508 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcatcaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtagtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaggacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaggtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttatcttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +agctggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaatgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggattattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacctatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agaatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgtgacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataat +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactattgt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttattaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttataccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaataaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgtgatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +agggaagcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccattgagaagtctaacataataagaggctggatttttggtactactttaga +ctcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatgaaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttcaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acatgaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacacactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttttttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaatttttctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctagcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaagacttttaaagtttccatttggaatcttgat +tacatcataaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcatcacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaatcacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtctgataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc +>MZ505967 +agatctgttctctaaacgaactttaaaatctgtgtggctgtcactcggctgcatgcttag +tgcactcacgcagtataattaataactaattactgtcgttgacaggacacgagtaactcg +tctatcttctgcaggctgcttacggtttcgtccgttttgcagccgatcatcagcacatct +aggttttgtccgggtgtgaccgaaaggtaagatggagagccttgtccctggtttcaacga +gaaaacacacgtccaactcagtttgcctgttttacaggttcgcgacgtgctcgtacgtgg +ctttggagactccgtggaggaggtcttatcagaggcacgtcaacatcttaaagatggcac +ttgtggcttagtagaagttgaaaaaggcgttttgcctcaacttgaacagccctatgtgtt +catcaaacgttcggatgctcgaactgcacctcatggtcatgttatggttgagctggtagc +agaactcgaaggcattcagtacggtcgtagtggtgagacacttggtgtccttgtccctca +tgtgggcgaaataccagtggcttaccgcaaggttcttcttcgtaagaacggtaataaagg +agctggtggccatagttacggcgccgatctaaagtcatttgacttaggcgacgagcttgg +cactgatccttatgaagattttcaagaaaactggaacactaaacatagcagtggtgttac +ccgtgaactcatgcgtgagcttaacggaggggcatacactcgctatgtcgataacaactt +ctgtggccctgatggctaccctcttgagtgcattaaagaccttctagcacgtgctggtaa +agcttcatgcactttgtccgaacaactggactttattgacactaagaggggtgtatactg +ctgccgtgaacatgagcatgaaattgcttggtacacggaacgttctgaaaagagctatga +attgcagacaccttttgaaattaaattggcaaagaaatttgacaccttcaatggggaatg +tccaaattttgtatttcccttaaattccataatcaagactattcaaccaagggttgaaaa +gaaaaagcttgatggctttatgggtagaattcgatctgtctatccagttgcgtcaccaaa +tgaatgcaaccaaatgtgcctttcaactctcatgaagtgtgatcattgtggtgaaacttc +atggcagacgggcgattttgttaaagccacttgcgaattttgtggcactgagaatttgac +taaagaaggtgccactacttgtggttacttaccccaaaatgctgttgttaaaatttattg +tccagcatgtcacaattcagaagtaagacctgagcatagtcttgccgaataccataatga +atctggcttgaaaaccattcttcgtaagggtggtcgcactattgcctttggaggctgtgt +gttctcttatgttggttgccataacaagtgtgcctattgggttccacgtgctagcgctaa +cataggttgtaaccatacaggtgttgttggagaaggttccgaaggtcttaatgacaacct +tcttgaaatactccaaaaagagaaagtcaacatcaatattgttggtgactttaaacttaa +tgaagagatcgccattattttggcatctttttctgcttccacaagtgcttttgtggaaac +tgtgaaaggtttggattataaagcattcaaacaaattgttgaatcctgtggtaattttaa +agttacaaaaggaaaagctaaaaaaagtgcctggaatattggtgaacagaaatcaatact +gagtcctctttatgcatttgcatcagaggctgctcgtgttgtacgatcaattttctcccg +cactcttgaaactgctcaaaattctgtgcgtgttttacagaaggccgctataacaatact +agatggaatttcacagtattcactgagactcattgatgctatgatgttcacatctgattt +ggctactaacaatctagttgtaatggcctacattacaggtggtgttgttcagttgacttc +gcagtggctaactaacatctttggcactgtttatgaaaaactcaaacccgtccttgattg +gcttgaagagaagtttaaggaaggtgtagagtttcttagagacggttgggaaattgttaa +atttatctcaacctgtgcttgtgaaattgtcggtggacaaattgtcacctgtgcaaagga +aattaaggagagtgttcagacattctttaagcttgtaaataaatttttggctttgtgtgc +tgactctatcattattggtggagctaaacttaaagccttgaatttaggtgaaacatttgt +cacgcactcaaagggattgtacagaaagtgtgttaaatccagagaagaaactggcctact +catgcctctaaaagccccaaaagaaattatcttcttagagggagaaacacttcccacaga +agtgttaacagaggaagttgtcttgaaaactggtgatttacaaccattagaacaacctac +tagtgaagctgttgaagctccattggttggtacaccagtttgtattaacgggcttatgtt +gctcgaaatcaaagacacagaaaagtactgtgcccttgcacctaatatgatggtaacaaa +caataccttcacactcaaaggcggtgcaccaacaaaggttacttttggtgatgacactgt +gatagaagtgcaaggttacaagagtgtgaatatcacttttgaacttgatgaaaggattga +taaagtacttaatgagaagtgctctgcctatacagttgaactcggtacagaagtaaatga +gttcgcctgtgttgtggcagatgctgtcataaaaactttgcaaccagtatctgaattact +tacaccactgggcattgatttagatgagtggagtatggctacatactacttatttgatga +gtctggtgagtttaaattggcttcacatatgtattgttctttttaccctccagatgagga +tgaagaagaaggtgattgtgaagaagaagagtttgagccatcaactcaatatgagtatgg +tactgaagatgattaccaaggtaaacctttggaatttggtgccacttctgctgctcttca +acctgaagaagagcaagaagaagattggttagatgatgatagtcaacaaactgttggtca +acaagacggcagtgaggacaatcagacaactactattcaaacaattgttgaggttcaacc +tcaattagagatggaacttacaccagttgttcagactattgaagtgaatagttttagtgg +ttatttaaaacttactgacaatgtatacattaaaaatgcagacattgtggaagaagctaa +aaaggtaaaaccaacagtggttgttaatgcagccaatgtttatcttaaacatggaggagg +tgttgcaggagccttaaataaggctactaacaatgccatgcaagttgaatctgatgatta +catagctactaatggaccacttaaagtgggtggtagttgtgttttaagcggacacaatct +tgctaaacactgtcttcatgttgtcggcccaaatgttaacaaaggtgaagacattcaact +tcttaagagtgcttatgaaaattttaatcagcacgaagttctacttgcaccattattatc +aactggtatttttggtgctgaccctatacattctttaagagtttgtgtagatactgttcg +cacaaatgtctacttagctgtctttgataaaaatctctatgacaaacttgtttcaagctt +tttggaaatgaagagtgaaaagcaagttgaacaaaagatcgctgagattcctaaagagga +agttaagccatttataactgaaagtaaaccttcagttgaacagagaaaacaagatgataa +gaaaatcaaagcttgtgttgaagaagttacaacaactctggaagaaactaagttcctcac +agaaaacttgttactttatattgacattaatggcaatcttcatccagattctgccactct +tgttagtgacattgacatcactttcttaaagaaagatgctccatatatagtgggtgatgt +tgttcaagagggtgttttaactgctgtggttatacctactaaaaaggctggtggcactac +tgaaatgctagcgaaagctttgagaaaagtgccaacagacaattatataaccacttaccc +gggtcagggtttaaatggttacactgtagaggaggcaaagacagtgcttaaaaagtgtaa +aagtgccttttacattctaccatctattatctctaatgagaagcaagaaattcttggaac +tgtttcttggaatttgcgagaaatgcttgcacatgcagaagaaacacgcaaattaatgcc +tgtctgtgtggaaactaaagccatagtttcaactatacagcgtaaatataagggtattaa +aatacaagagggtgtggttgattatggtgctagattttacttttacaccagtaaaacaac +tgtagcgtcacttatcaacacacttaacgatctaaatgaaactcttgttacaatgccact +tggctatgtaacacatggcttaaatttggaagaagctgctcggtatatgagatctctcaa +agtgccagctacagtttctgtttcttcacctgatgctgttacagcgtataatggttatct +tacttcttcttctaaaacacctgaagaacattttattgaaaccatctcacttgctggttc +ctataaagattggtcctattctggacaatctacacaactaggtatagaatttcttaagag +aggtgataaaagtgtatattacactagtaatcctaccacattccacctagatggtgaagt +tatcacctttgacaatcttaagacacttctttctttgagagaagtgaggattattaaggt +gtttacaacagtagacaacattaacctccacacgcaagttgtggacatgtcaatgacata +tggacaacagtttggtccaacttatttggatggagctgatgttactaaaataaaacctca +taattcacatgaaggtaaaacattttatgttttacctaatgatgacactctacgtgttga +ggcttttgagtactaccacacaactgatcctagttttctgggtaggtacatgtcagcatt +aaatcacactaaaaagtggaaatacccacaagttaatggtttaacttctattaaatgggc +agataacaactgttatcttgccactgcattgttaacactccaacaaatagagttgaagtt +taatccacctgctctacaagatgcttattacagagcaagggctggtgaagctgctaactt +ttgtgcacttatcttagcctactgtaataagacagtaggtgagttaggtgatgttagaga +aacaatgagttacttgtttcaacatgccaatttagattcttgcaaaagagtcttgaacgt +ggtgtgtaaaacttgtggacaacagcagacaacccttaagggtgtagaagctgttatgta +catgggcacactttcttatgaacaatttaagaaaggtgttcagataccttgtacgtgtgg +taaacaagctacaaaatatctagtacaacaggagtcaccttttgttatgatgtcagcacc +acctgctcagtatgaacttaagcatggtacatttacttgtgctagtgagtacactggtaa +ttaccagtgtggtcactataaacatataacttctaaagaaactttgtattgcatagacgg +tgctttacttacaaagtcctcagaatacaaaggtcctattacggatgttttctacaaaga +aaacagttacacaacaaccataaaaccagttacttataaattggatggtgttgtttgtac +agaaattgaccctaagttggacaattattataagaaagacaattcttatttcacagagca +accaattgatcttgtaccaaaccaaccatatccaaacgcaagcttcgataattttaagtt +tgtatgtgataatatcaaatttgctgatgatttaaaccagttaactggttataagaaacc +tgcttcaagagagcttaaagttacatttttccctgacttaaatggtgatgtggtggctat +tgattataaacactacacaccctcttttaagaaaggagctaaattgttacataaacctat +tgtttggcatgttaacaatgcaactaataaagccacgtataaaccaaatacctggtgtat +acgttgtctttggagcacaaaaccagttgaaacatcaaattcgtttgatgtactgaagtc +agaggacgcgcagggaatggataatcttgcctgcgaagatctaaaaccagtctctgaaga +agtagtggaaaatcctaccatacagaaagacgttcttgagtgtaatgtgaaaactaccga +agttgtaggagacattatacttaaaccagcaaataatagtttaaaaattacagaagaggt +tggccacacagatctaatggctgcttatgtagacaattctagtcttactattaagaaacc +taatgaattatctagagtattaggtttgaaaacccttgctactcatggtttagctgctgt +taatagtgtcccttgggatactatagctaattatgctaagccttttcttaacaaagttgt +tagtacaactactaacatagttacacggtgtttaaaccgtgtttgtactaattatatgcc +ttatttctttactttattgctacaattgtgtacttttactagaagtacaaattctagaat +taaagcatctatgccgactactatagcaaagaatactgttaagagtgtcggtaaattttg +tctagaggcttcatttaattatttgaagtcacctaatttttctaaactgataaatattat +aatttggtttttactattaagtgtttgcctaggttctttaatctactcaaccgctgcttt +aggtgttttaatgtctaatttaggcatgccttcttactgtactggttacagagaaggcta +tttgaactctactaatgtcactattgcaacctactgtactggttctataccttgtagtgt +ttgtcttagtggtttagattctttagacacttatccttctttagaaactatacaaattac +catttcatcttttaaatgggatttaactgcttttggcttagttgcagagtggtttttggc +atatattcttttcactaggtttttctatgtacttggattggctgcaatcatgcaattgtt +tttcagctattttgcagtacattttattagtaattcttggcttatgtggttaataattaa +tcttgtacaaatggccccgatttcagctatggttagaatgtacatcttctttgcatcatt +ttattatgtatggaaaagttatgtgcatgttgtagacggttgtaattcatcaacttgtat +gatgtgttacaaacgtaatagagcaacaagagtcgaatgtacaactattgttaatggtgt +tagaaggtccttttatgtctatgctaatggaggtaaaggcttttgcaaactacacaattg +gaattgtgttaattgtgatacattctgtgctggtagtacatttattagtgatgaagttgc +gagagacttgtcactacagtttaaaagaccaataaatcctactgaccagtcttcttacat +cgttgatagtgttacagtgaagaatggttccatccatctttactttgataaagctggtca +aaagacttatgaaagacattctctctctcattttgttaacttagacaacctgagagctaa +taacactaaaggttcattgcctattaatgttatagtttttgatggtaaatcaaaatgtga +agcatcatctgcaaaatcagcgtctgtttactacagtcagcttatgtgtcaacctatact +gttactagatcaggcattagtgtctgatgttggtgatagtgcggaagttgcagttaaaat +gtttgatgcttacgttaatacgttttcatcaacttttaacgtaccaatggaaaaactcaa +aacactagttgcaactgcagaagctgaacttgcaaagaatgtgtccttagacaatgtctt +atctacttttatttcagcagctcggcaagggtttgttgattcagatgtagaaactaaaga +tgttgttgaatgtcttaaattgtcacatcaatctgacatagaagttactggcgatagttg +taataactatatgctcacctataacaaagttgaaaacatgacaccccgtgaccttggtgc +ttgtattgactgtagtgcgcgtcatattaatgcgcaggtagcaaaaagtcacaacattgc +tttgatatggaacgttaaagatttcatgtcattgtctgaacaactacgaaaacaaatacg +tagtgctgctaaaaagaataacttaccttttaagttgacatgtgcaactactagacaagt +tgttaatgttgtaacaacaaagatagcacttaagggtggtaaaattgttaataattggtt +gaagcagttaattaaagttacacttgtgttcctttttgttgctgctattttctatttaat +aacacctgttcatgtcatgtctaaacatactgacttttcaagtgaaatcataggatacaa +ggctattgatggtggtgtcactcgtgacatagcatctacagatacttgttttgctaacaa +acatgctgattttgacacatggtttagccagcgtggtggtagttatactaatgacaaagc +ttgcccattgattgctgcagtcataacaagagaagtgggttttgtcgtgcctggtttgcc +tggcacgatattacgcacaactaatggtgactttttgcatttcttacctagagtttttag +tgcagttggtaacatctgttacacaccatcaaaacttatagagtacactgactttgcaac +atcagcttgtgttttggctgctgaatgtacaatttttaaagatgcttctggtaagccagt +accatattgttatgataccaatgtactagaaggttctgttgcttatgaaagtttacgccc +tgacacacgttatgtgctcatggatggctctattattcaatttcctaacacctaccttga +aggttctgttagagtggtaacaacttttgattctgagtactgtaggcacggcacttgtga +aagatcagaagctggtgtttgtgtatctactagtggtagatgggtacttaacaatgatta +ttacagatctttaccaggagttttctgtggtgtagatgctgtaaatttacttactaatat +gtttacaccactaattcaacctattggtgctttggacatatcagcatctatagtagctgg +tggtattgtagctatcgtagtaacatgccttgcctactattttatgaggtttagaagagc +ttttggtgaatacagtcatgtagttgcctttaatactttactattccttatgtcattcac +tgtactctgtttaacaccagtttactcattcttacctggtgtttattctgttatttactt +gtacttgacattttatcttactaatgatgtttcttttttagcacatattcagtggatggt +tatgttcacacctttagtacctttctggataacaattgcttatatcatttgtatttccac +aaagcatttctattggttctttagtaattacctaaagagacgtgtagtctttaatggtgt +ttcctttagtacttttgaagaagctgcgctgtgcacctttttgttaaataaagaaatgta +tctaaagttgcgtagtgatgtgctattacctcttacgcaatataatagatacttagctct +ttataataagtacaagtattttagtggagcaatggatacaactagctacagagaagctgc +ttgttgtcatctcgcaaaggctctcaatgacttcagtaactcaggttctgatgttcttta +ccaaccaccacaaacctctatcacctcagctgttttgcagagtggttttagaaaaatggc +attcccatctggtaaagttgagggttgtatggtacaagtaacttgtggtacaactacact +taacggtctttggcttgatgacgtagtttactgtccaagacatgtgatctgcacctctga +agacatgcttaaccctaattatgaagatttactcattcgtaagtctaatcataatttctt +ggtacaggctggtaatgttcaactcagggttattggacattctatgcaaaattgtgtact +taagcttaaggttgatacagccaatcctaagacacctaagtataagtttgttcgcattca +accaggacagactttttcagtgttagcttgttacaatggttcaccatctggtgtttacca +atgtgctatgaggcccaatttcactattaagggttcattccttaatggttcatgtggtag +tgttggttttaacatagattatgactgtgtctctttttgttacatgcaccatatggaatt +accaactggagttcatgctggcacagacttagaaggtaacttttatggaccttttgttga +caggcaaacagcacaagcagctggtacggacacaactattacagttaatgttttagcttg +gttgtacgctgctgttataaatggagacaggtggtttctcaatcgatttaccacaactct +taatgactttaaccttgtggctatgaagtacaattatgaacctctaacacaagaccatgt +tgacatactaggacctctttctgctcaaactggaattgccgttttagatatgtgtgcttc +attaaaagaattactgcaaaatggtatgaatggacgtaccatattgggtagtgctttatt +agaagatgaatttacaccttttgatgttgttagacaatgctcaggtgttactttccaaag +tgcagtgaaaagaacaatcaagggtacacaccactggttgttactcacaattttgacttc +acttttagttttagtccagagtactcaatggtctttgttcttttttttgtatgaaaatgc +ctttttaccttttgctatgggtattattgctatgtctgcttttgcaatgatgtttgtcaa +acataagcatgcatttctctgtttgtttttgttaccttctcttgccgctgtagcttattt +taatatggtctatatgcctgctagttgggtgatgcgtattatgacatggttggatatggt +tgatactagtttgtctggttttaagctaaaagactgtgttatgtatgcatcagctgtagt +gttactaatccttatgacagcaagaactgtgtatgatgatggtgctaggagagtgtggac +acttatgaatgtcttgacactcgtttataaagtttattatggtaatgctttagatcaagc +catttccatgtgggctcttataatctctgttacttctaactactcaggtgtagttacaac +tgtcatgtttttggccagaggtattgtttttatgtgtgttgagtattgccctattttctt +cataactggtaatacacttcagtgtataatgctagtttattgtttcttaggctatttttg +tacttgttactttggcctcttttgtttactcaaccgctactttagactgactcttggtgt +ttatgattacttagtttctacacaggagtttagatatatgaattcacagggactactccc +acccaagaatagcatagatgccttcaaactcaacattaaattgttgggtgttggtggcaa +accttgtatcaaagtagccactgtacagtctaaaatgtcagatgtaaagtgcacatcagt +agtcttactctcagttttgcaacaactcagagtagaatcatcatctaaattgtgggctca +atgtgtccagttacacaatgacattctcttagctaaagatactactgaagcctttgaaaa +aatggtttcactactttctgttttgctttccatgcagggtgctgtagacataaacaagct +ttgtgaagaaatgctggacaacagggcaaccttacaagctatagcctcagagtttagttc +ccttccatcatatgcagcttttgctactgctcaagaagcttatgagcaggctgttgctaa +tggtgattctgaagttgttcttaaaaagttgaagaagtctttgaatgtggctaaatctga +atttgaccgtgatgcagccatgcaacgtaagttggaaaagatggctgatcaagctatgac +ccaaatgtataaacaggctagatctgaggacaagagggcaaaagttactagtgctatgca +gacaatgcttttcactatgcttagaaagttggataatgatgcactcaacaacattatcaa +caatgcaagagatggttgtgttcccttgaacataatacctcttacaacagcagccaaact +aatggttgtcataccagactataacacatataaaaatacgtgtgatggtacaacatttac +ttatgcatcagcattgtgggaaatccaacaggttgtagatgcagatagtaaaattgttca +acttagtgaaattagtatggacaattcacctaatttagcatggcctcttattgtaacagc +tttaagggccaattctgctgtcaaattacagaataatgagcttagtcctgttgcactacg +acagatgtcttgtgctgccggtactacacaaactgcttgcactgatgacaatgcgttagc +ttactacaacacaacaaagggaggtaggtttgtacttgcactgttatccgatttacagga +tttgaaatgggctagattccctaagagtgatggaactggtactatctatacagaactgga +accaccttgtaggtttgttacagacacacctaaaggtcctaaagtgaagtatttatactt +tattaaaggattaaacaacctaaatagaggtatggtacttggtagtttagctgccacagt +acgtctacaagctggtaatgcaacagaagtgcctgccaattcaactgtattatctttctg +tgcttttgctgtagatgctgctaaagcttacaaagattatctagctagtgggggacaacc +aatcactaattgtgttaagatgttgtgtacacacactggtactggtcaggcaataacagt +tacaccggaagccaatatggatcaagaatcctttggtggtgcatcgtgttgtctgtactg +ccgttgccacatagatcatccaaatcctaaaggattttgtgacttaaaaggtaagtatgt +acaaatacctacaacttgtgctaatgaccctgtgggttttacacttaaaaacacagtctg +taccgtctgcggtatgtggaaaggttatggctgtagttgtgatcaactccgcgaacccat +gcttcagtcagctgatgcacaatcgtttttaaacgggtttgcggtgtaagtgcagcccgt +cttacaccgtgcggcacaggcactagtactgatgtcgtatacagggcttttgacatctac +aatgataaagtagctggttttgctaaattcctaaaaactaattgttgtcgcttccaagaa +aaggacgaagatgacaatttaattgattcttactttgtagttaagagacacactttctct +aactaccaacatgaagaaacaatttataatttacttaaggattgtccagctgttgctaaa +catgacttctttaagtttagaatagacggtgacatggtaccacatatatcacgtcaacgt +cttactaaatacacaatggcagacctcgtctatgctttaaggcattttgatgaaggtaat +tgttacacattaaaagaaatacttgtcacatacaattgttgtgatgatgattatttcaat +aaaaaggactggtatgattttgtagaaaacccagatatattacgcgtatacgccaactta +ggtgaacgtgtacgccaagctttgttaaaaacagtacaattctgtgatgccatgcgaaat +gctggtattgttggtgtactgacattagataatcaagatctcaatggtaactggtatgat +ttcggtgatttcatacaaaccacgccaggtagtggagttcctgttgtagattcttattat +tcattgttaatgcctatattaaccttgaccagggctttaactgcagagtcacatgttgac +actgacttaacaaagccttacattaagtgggatttgttaaaatatgacttcacggaagag +aggttaaaactctttgaccgttattttaaatattgggatcagacataccacccaaattgt +gttaactgtttggatgacagatgcattctgcattgtgcaaactttaatgttttattctct +acagtgttcccacttacaagttttggaccactagtgagaaaaatatttgttgatggtgtt +ccatttgtagtttcaactggataccacttcagagagctaggtgttgtacataatcaggat +gtaaacttacatagctctagacttagttttaaggaattacttgtgtatgctgctgaccct +gctatgcacgctgcttctggtaatctattactagataaacgcactacgtgcttttcagta +gctgcacttactaacaatgttgcttttcaaactgtcaaacccggtaattttaacaaagac +ttctatgactttgctgtgtctaagggtttctttaaggaaggaagttctgttgaattaaaa +cacttcttctttgctcaggatggtaatgctgctatcagcgattatgactactatcgttat +aatctaccaacaatgtgtgatatcagacaactactatttgtagttgaagttgttgataag +tactttgattgttacgatggtggctgtattaatgctaaccaagtcatcgtcaacaaccta +gacaaatcagctggttttccatttaataaatggggtaaggctagactttattatgattca +atgagttatgaggatcaagatgcacttttcgcatatacaaaacgtaatgtcatccctact +ataactcaaatgaatcttaagtatgccattagtgcaaagaatagagctcgcaccgtagct +ggtgtctctatctgtagtactatgaccaatagacagtttcatcaaaaattattgaaatca +atagccgccactagaggagctactgtagtaattggaacaagcaaattctatggtggttgg +cacaacatgttaaaaactgtttatagtgatgtagaaaaccctcaccttatgggttgggat +tatcctaaatgtgatagagccatgcctaacatgcttagaattatggcctcacttgttctt +gctcgcaaacatacaacgtgttgtagcttgtcacaccgtttctatagattagctaatgag +tgtgctcaagtattgagtgaaatggtcatgtgtggcggttcactatatgttaaaccaggt +ggaacctcatcaggagatgccacaactgcttatgctaatagtgtttttaacatttgtcaa +gctgtcacggccaatgttaatgcacttttatctactgatggtaacaaaattgccgataag +tatgtccgcaatttacaacacagactttatgagtgtctctatagaaatagagatgttgac +acagactttgtgaatgagttttacgcatatttgcgtaaacatttctcaatgatgatactc +tctgacgatgctgttgtgtgtttcaatagcacttatgcatctcaaggtctagtggctagc +ataaagaactttaagtcagttctttattatcaaaacaatgtttttatgtctgaagcaaaa +tgttggactgagactgaccttactaaaggacctcatgaattttgctctcaacatacaatg +ctagttaaacagggtgatgattatgtgtaccttccttacccagatccatcaagaatccta +ggggccggctgttttgtagatgatatcgtaaaaacagatggtacacttatgattgaacgg +ttcgtgtctttagctatagatgcttacccacttactaaacatcctaatcaggagtatgct +gatgtctttcatttgtacttacaatacataagaaagctacatgatgagttaacaggacac +atgttagacatgtattctgttatgcttactaatgataacacttcaaggtattgggaacct +gagttttatgaggctatgtacacaccgcatacagtcttacaggctgttggggcttgtgtt +ctttgcaattcacagacttcattaagatgtggtgcttgcatacgtagaccattcttatgt +tgtaaatgctgttacgaccatgtcatatcaacatcacataaattagtcttgtctgttaat +ccgtatgtttgcaatgctccaggttgtgatgtcacagatgtgactcaactttacttagga +ggtatgagctattattgtaaatcacataaaccacccattagttttccattgtgtgctaat +ggacaagtttttggtttatataaaaatacatgtgttggtagcgataatgttactgacttt +aatgcaattgcaacatgtgactggacaaatgctggtgattacattttagctaacacctgt +actgaaagactcaagctttttgcagcagaaacgctcaaagctactgaggagacatttaaa +ctgtcttatggtattgctactgtacgtgaagtgctgtctgacagagaattacatctttca +tgggaagttggtaaacctagaccaccacttaaccgaaattatgtctttactggttatcgt +gtaactaaaaacagtaaagtacaaataggagagtacacctttgaaaaaggtgactatggt +gatgctgttgtttaccgaggtacaacaacttacaaattaaatgttggtgattattttgtg +ctgacatcacatacagtaatgccattaagtgcacctacactagtgccacaagagcactat +gttagaattactggcttatacccaacactcaatatctcagatgagttttctagcaatgtt +gcaaattatcaaaaggttggtatgcaaaagtattctacactccagggaccacctggtact +ggtaagagtcattttgctattggcctagctctctactacccttctgctcgcatagtgtat +acagcttgctctcatgccgctgttgatgcactatgtgagaaggcattaaaatatttgcct +atagataaatgtagtagaattatacctgcacgtgctcgtgtagagtgttttgataaattc +aaagtgaattcaacattagaacagtatgtcttttgtactgtaaatgcattgcctgagacg +acagcagatatagttgtctttgatgaaatttcaatggccacaaattatgatttgagtgtt +gtcaatgccagattacgtgctaagcactatgtgtacattggcgaccctgctcaattacct +gcaccacgcacattgctaactaagggcacactagaaccagaatatttcaattcagtgtgt +agacttattaaaactataggtccagacatgttcctcggaacttgtcggcgttgtcctgct +gaaattgttgacactgtgagtgctttggtttatgataataagcttaaagcacataaagac +aaatcagctcaatgctttaaaatgttttataagggtgttatcacgcatgatgtttcatct +gcaattaacaggccacaaataggcgtggtaagagaattccttacacgtaaccctgcttgg +agaaaagctgtctttatttcaccttataattcacagaatgctgtagcctcaaagattttg +ggactaccaactcaaactgttgattcatcacagggctcagaatatgactatgtcatattc +actcaaaccactgaaacagctcactcttgtaatgtaaacagatttaatgttgctattacc +agagcaaaagtaggcatactttgcataatgtctgatagagacctttatgacaagttgcaa +tttacaagtcttgaaattccacgtaggaatgtggcaactttacaagctgaaaatgtaaca +ggactctttaaagattgtagtaaggtaatcactgggttacatcctacacaggcacctaca +cacctcagtgttgacactaaattcaaaactgaaggtttatgtgttgacatacctggcata +cctaaggacatgacctatagaagactcatctctatgatgggttttaaaatgaattatcaa +gttaatggttaccctaacatgtttatcacccgcgaagaagctataagacatgtacgtgca +tggattggcttcgatgtcgaggggtgtcatgctactagagaagctgttggtaccaattta +cctttacagctaggtttttctacaggtgttaacctagttgctgtacctacaggttatgtt +gatacacctaataatacagatttttccagagttagtgctaaaccaccgcctggagatcaa +tttaaacacctcataccacttatgtacaaaggacttccttggaatgtagtgcgtataaag +attgtacaaatgttaagtgacacacttaaaaatctctctgacagagtcgtatttgtctta +tgggcacatggctttgagttgacatctatgaagtattttgtgaaaataggacctgagcgc +acctgttgtctatgtgatagacgtgccacatgcttttccactgcttcagacacttatgcc +tgttggcatcattctattggatttgattacgtctataatccgtttatgattgatgttcaa +caatggggttttacaggtaacctacaaagcaaccatgatctgtattgtcaagtccatggt +aatgcacatgtagctagttgtgatgcaatcatgactaggtgtctagctgtccacgagtgc +tttgttaagcgtgttgactggactattgaatatcctataattggtgatgaactgaagatt +aatgcggcttgtagaaaggttcaacacatggttgttaaagctgcattattagcagacaaa +ttcccagttcttcacgacattggtaaccctaaagctattaagtgtgtacctcaagctgat +gtagaatggaagttctatgatgcacagccttgtagtgacaaagcttataaaatagaagaa +ttattctattcttatgccacacattctgacaaattcacagatggtgtatgcctattttgg +aattgcaatgtcgatagatatcctgctaattccattgtttgtagatttgacactagagtg +ctatctaaccttaacttgcctggttgtgatggtggcagtttgtatgtaaacaaacatgca +ttccacacaccagcttttgataaaagtgcttttgttaatttaaaacaattaccatttttc +tattactctgacagtccatgtgagtctcatggaaaacaagtagtgtcagatatagattat +gtaccactaaagtctgctacgtgtataacacgttgcaatttaggtggtgctgtctgtaga +catcatgctaatgagtacagattgtatctcgatgcttataacatgatgatctcagctggc +tttagcttgtgggtttacaaacaatttgatacttataacctctggaacacttttacaaga +cttcagagtttagaaaatgtggcttttaatgttgtaaataagggacactttgatggacaa +cagggtgaagtaccagtttctatcattaataacactgtttacacaaaagttgatggtgtt +gatgtagaattgtttgaaaataaaacaacattacctgttaatgtagcatttgagctttgg +gctaagcgcaacattaaaccagtaccagaggtgaaaatactcaataatttgggtgtggac +attgctgctaatactgttatctgggactacaaaagagatgctccagcacatatatctact +attggtgtttgttctatgactgacatagccaagaaaccaactgaaacgatttgtgcacca +ctcactgtcttttttgatggtagagttgatggtcaagtagacttatttagaaatgcccgt +aatggtgttcttattacagaaggtagtgttaaaggtttacaaccatctgtaggtcccaaa +caagctagtcttaatggagtcacattaattggagaagccgtaaaaacacagttcaattat +tataagaaagttgatggtgttgtccaacaattacctgaaacttactttactcagagtaga +aatttacaagaatttaaacccaggagtcaaatggaaattgatttcttagaattagctatg +gatgaattcattgaacggtataaattagaaggctatgccttcgaacatatcgtttatgga +gattttagtcatagtcagttaggtggtttacatctactgattggactagctaaacgtttt +agggaatcaccttttgaattagaagattttattcctatggacagtacagttaaaaactat +ttcataacagatgcgcaaacaggttcatctaagtgtgtgtgttctgttattgatttatta +cttgatgattttgttgaaataataaaatcccaagatttatctgtagtttctaaggttgtc +aaagtgactattgactatacagaaatttcatttatgctttggtgtaaagatggccatgta +gaaacattttacccaaaattacaatctagtcaagcgtggcaaccgggtgttgctatgcct +aatctttacaaaatgcaaagaatgctattagaaaagtgtgaccttcaaaattatggtgat +agtgcaacattacctaaaggcataatgatgaatgtcgcaaaatatactcaactgtgtcaa +tatttaaacacattaacattagctgtaccctataatatgagagttatacattttggtgct +ggttctgataaaggagttgcaccaggtacagctgttttaagacagtggttgcctacgggt +acgctgcttgtcgattcagatcttaatgactttgtctctgatgcagattcaactttgatt +ggtgattgtgcaactgtacatacagctaataaatgggatctcattattagtgatatgtac +gaccctaagactaaaaatgttacaaaagaaaatgactctaaagagggttttttcacttac +atttgtgggtttatacaacaaaagctagctcttggaggttccgtggctataaagataaca +gaacattcttggaatgctgatctttataagctcatgggacacttcgcatggtggacagcc +tttgttactaatgtgaatgcgtcatcatctgaagcatttttaattggatgtaattatctt +ggcaaaccacgcgaacaaatagatggttatgtcatgcatgcaaattacatattttggagg +aatacaaatccaattcagttgtcttcctattctttatttgacatgagtaaatttcccctt +aaattaaggggtactgctgttatgtctttaaaagaaggtcaaatcaatgatatgatttta +tctcttcttagtaaaggtagacttataattagagaaaacaacagagttgttatttctagt +gatgttcttgttaacaactaaacgaacaatgtttgtttttcttgttttattgccactagt +ctctagtcagtgtgttaatcttacaaccagaactcaattaccccctgcatacactaattc +tttcacacgtggtgtttattaccctgacaaagttttcagatcctcagttttacattcaac +tcaggacttgttcttacctttcttttccaatgttacttggttccatgctatacatgtctc +tgggaccaatggtactaagaggtttgataaccctgtcctaccatttaatgatggtgttta +ttttgcttccactgagaagtctaacataataagaggctggatttttggtactactttaga +ctcgaagacccagtccctacttattgttaataacgctactaatgttgttattaaagtctg +tgaatttcaattttgtaatgatccatttttggatgtttatt---accacaaaaacaacaa +aagttggatggaaagtgagttcagagtttattctagtgcgaataattgcacttttgaata +tgtctctcagccttttcttatggaccttgaaggaaaacagggtaatttcaaaaatcttag +ggaatttgtgtttaagaatattgatggttattttaaaatatattctaagcacacgcctat +taatttagtgcgtgatctccctcagggtttttcggctttagaaccattggtagatttgcc +aataggtattaacatcactaggtttcaaactttacttgctttacatagaagttatttgac +tcctggtgattcttcttcaggttggacagctggtgctgcagcttattatgtgggttatct +tcaacctaggacttttctattaaaatataatgaaaatggaaccattacagatgctgtaga +ctgtgcacttgaccctctctcagaaacaaagtgtacgttgaaatccttcactgtagaaaa +aggaatctatcaaacttctaactttagagtccaaccaacagaatctattgttagatttcc +taatattacaaacttgtgcccttttggtgaagtttttaacgccaccagatttgcatctgt +ttatgcttggaacaggaagagaatcagcaactgtgttgctgattattctgtcctatataa +ttccgcatcattttccacttttaagtgttatggagtgtctcctactaaattaaatgatct +ctgctttactaatgtctatgcagattcatttgtaattagaggtgatgaagtcagacaaat +cgctccagggcaaactggaaagattgctgattataattataaattaccagatgattttac +aggctgcgttatagcttggaattctaacaatcttgattctaaggttggtggtaattataa +ttaccggtatagattgtttaggaagtctaatctcaaaccttttgagagagatatttcaac +tgaaatctatcaggccggtagcacaccttgtaatggtgttcaaggttttaattgttactt +tcctttacaatcatatggtttccaacccactaatggtgttggttaccaaccatacagagt +agtagtactttcttttgaacttctacatgcaccagcaactgtttgtggacctaaaaagtc +tactaatttggttaaaaacaaatgtgtcaatttcaacttcaatggtttaacaggcacagg +tgttcttactgagtctaacaaaaagtttctgcctttccaacaatttggcagagacattgc +tgacactactgatgctgtccgtgatccacagacacttgagattcttgacattacaccatg +ttcttttggtggtgtcagtgttataacaccaggaacaaatacttctaaccaggttgctgt +tctttatcagggtgttaactgcacagaagtccctgttgctattcatgcagatcaacttac +tcctacttggcgtgtttattctacaggttctaatgtttttcaaacacgtgcaggctgttt +aataggggctgaacatgtcaacaactcatatgagtgtgacatacccattggtgcaggtat +atgcgctagttatcagactcagactaattctcgtcggcgggcacgtagtgtagctagtca +atccatcattgcctacactatgtcacttggtgcagaaaattcagttgcttactctaataa +ctctattgccatacccacaaattttactattagtgttaccacagaaattctaccagtgtc +tatgaccaagacatcagtagattgtacaatgtacatttgtggtgattcaactgaatgcag +caatcttttgttgcaatatggcagtttttgtacacaattaaaccgtgctttaactggaat +agctgttgaacaagacaaaaacacccaagaagtttttgcacaagtcaaacaaatttacaa +aacaccaccaattaaagattttggtggttttaatttttcacaaatattaccagatccatc +aaaaccaagcaagaggtcatttattgaagatctacttttcaacaaagtgacacttgcaga +tgctggcttcatcaaacaatatggtgattgccttggtgatattgctgctagagacctcat +ttgtgcacaaaagtttaacggccttactgttttgccacctttgctcacagatgaaatgat +tgctcaatacacttctgcactgttagcgggtacaatcacttctggttggacctttggtgc +aggtgctgcattacaaataccatttgctatgcaaatggcttataggtttaatggtattgg +agttacacagaatgttctctatgagaaccaaaaattgattgccaaccaatttaatagtgc +tattggcaaaattcaagactcactttcttccacagcaagtgcacttggaaaacttcaaga +tgtggtcaaccaaaatgcacaagctttaaacacgcttgttaaacaacttagctccaattt +tggtgcaatttcaagtgttttaaatgatatcctttcacgtcttgacaaagttgaggctga +agtgcaaattgataggttgatcacaggcagacttcaaagtttgcagacatatgtgactca +acaattaattagagctgcagaaatcagagcttctgctaatcttgctgctactaaaatgtc +agagtgtgtacttggacaatcaaaaagagttgatttttgtggaaagggctatcatcttat +gtccttccctcagtcagcacctcatggtgtagtcttcttgcatgtgacttatgtccctgc +acatgaaaagaacttcacaactgctcctgccatttgtcatgatggaaaagcacactttcc +tcgtgaaggtgtctttgtttcaaatggcacagactggtttgtaacacaaaggaattttta +tgaaccacaaatcattactacagacaacacatttgtgtctggtaactgtgatgttgtaat +aggaattgtcaacaacacagtttatgatcctttgcaacctgaattagactcattcaagga +ggagttagataaatattttaagaatcatacatcaccagatgttgatttaggtgacatctc +tggcattaatgcttcagttgtaaacattcaaaaagaaattgaccgcctcaatgaggttgc +caagaatttaaatgaatctctcatcgatctccaagaacttggaaagtatgagcagtatat +aaaatggccatggtacatttggctaggttttatagctggcttgattgccatagtaatggt +gacaattatgctttgctgtatgaccagttgctgtagttgtctcaagggctgttgttcttg +tggatcctgctgcaaatttgatgaagacgactctgagccagtgctcaaaggagtcaaatt +acattacacataaacgaacttatggatttgtttatgagaatcttcacaattggaactgta +actttgaagcaaggtgaaatcaaggatgctactcctttagattttgttcgcgctactgca +acgataccgatacaagcctcactccctttcggatggcttattgttggcgttgcacttctt +gctgtttttcagagcgcttccaaaatcataaccctcaaaaagagatggcaactagcactc +tccaagggtgttcactttgtttgcaacttgctgttgttgtttgtaacagtttactcacac +cttttgctcgttgctgctggccttgaagccccttttctctatctttatgctttagtctac +ttcttgcagagtataaactttgtaagaataataatgaggctttggctttgctggaaatgc +cgttccaaaaacccattactttatgatgccaactattttctttgctggcatactaattgt +tacgactattgtataccttacaatagtgtaacttcttcaattgtcattacttcaggtgat +ggcacaacaagtcctatttctgaacatgactaccagattggtggttatactgaaaaatgg +gaatctggagtaaaagactgtgttgtattacacagttacttcacttcagactattaccag +ctgtactcaactcaattgagtacagacactggtgttgaacatgttaccttcttcatctac +aataaaattgttgatgagcctgaagaacatgtccaaattcacacaatcgacggttcatcc +ggagttgttaatccagtaatggaaccaatttatgatgaaccgacgacgactactagcgtg +cctttgtaagcacaagctgatgagtacgaacttatgtactcattcgtttcggaagagaca +ggtacgttaatagttaatagcgtacttctttttcttgctttcgtggtattcttgctagtt +acactagccatccttactgcgcttcgattgtgtgcgtactgctgcaatattgttaacgtg +agtcttgtaaaaccttctttttacgtttactctcgtgttaaaaatctgaattcttctaga +gttcctgatcttctggtctaaacgaactaaatattatattagtttttctgtttggaactt +taattttagccatggcagattccaacggtactattaccgttgaagagcttaaaaagctcc +ttgaacaatggaacctagtaataggtttcctattccttacatggatttgtcttctacaat +ttgcctatgccaacaggaataggtttttgtatataattaagttaattttcctctggctgt +tatggccagtaactttagcttgttttgtgcttgctgctgtttacagaataaattggatca +ccggtggaattgctatcgcaatggcttgtcttgtaggcttgatgtggctcagctacttca +ttgcttctttcagactgtttgcgcgtacgcgttccatgtggtcattcaatccagaaacta +acattcttctcaacgtgccactccatggcactattctgaccagaccgcttctagaaagtg +aactcgtaatcggagctgtgatccttcgtggacatcttcgtattgctggacaccatctag +gacgctgtgacatcaaggacctgcctaaagaaatcactgttgctacatcacgaacgcttt +cttattacaaattgggagcttcgcagcgtgtagcaggtgactcaggttttgctgcataca +gtcgctacaggattggcaactataaattaaacacagaccattccagtagcagtgacaata +ttgctttgcttgtacagtaagtgacaacagatgtttcatctcgttgactttcaggttact +atagcagagatattactaattattatgaggacttttaaagtttccatttggaatcttgat +tacatcacaaacctcataattaaaaatttatctaagtcactaactgagaataaatattct +caattagatgaagagcaaccaatggagattgattaaacgaacatgaaaattattcttttc +ttggcactgataacactcgctacttgtgagctttatcactaccaagagtgtgttagaggt +acaacagtacttttaaaagaaccttgctcttctggaacatacgagggcaattcaccattt +catcctctagctgataacaaatttgcactgacttgctttagcactcaatttgcttttgct +tgtcctgacggcgtaaaacacgtctatcagttacgtgccagatcagcttcacctaaactg +ttcatcagacaagaggaagttcaagaactttactctccaatttttcttattgttgcggca +atagtgtttataacactttgcttcacactcaaaagaaagacagaatgattgaactttcat +taattgacttctatttgtgctttttagcctttctgctattccttgttttaattatgctta +ttatcttttggttctcacttgaactgcaagatcataatgaaacttgtcacgcctaaacga +acatgaaatttcttgttttcttaggaatcaccacaactgtagctgcatttcaccaagaat +gtagtttacagtcatgtactcaacatcaaccatatgtagttgatgacccgtgtcctattc +acttctattctaaatggtatattagagtaggagctagaaaatcagcacctttaattgaat +tgtgcgtggatgaggctggttctaaattacccattcagtacatcgatatcggtaattata +cagtttcctgtttaccttttacaattaattgccaggaacctaaattgggtagtcttgtag +tgcgttgttcgttctatgaagactttttagagtatcatgacgttcgtgttgttttagatt +tcatctaaacgaacaaact-aaatgtcttataatggaccccaaaatcagcgaaatgcacc +ccgcattacgtttggtggaccctcagattcaactggcagtaaccagaatggagaacgcag +tggggcgcgatcaaaacaacgtcggccccaaggtttacccaataatactgcgtcttggtt +caccgctctcactcaacatggcaaggaagaccttaaattccctcgaggacaaggcgttcc +aattaacaccaatagcagtccagatgaccaaattggctactaccgaagagctaccagacg +aattcgtggtggtgacggtaaaatgaaagatctcagtccaagatggtatttctactacct +aggaactgggccagaagctggacttccctatggtgctaacaaagacggcatcatatgggt +tgcaactgagggagccttgaatacaccaaaagatcacattggcacccgcaatcctgctaa +caatgctgcaatcgtgctacaacttcctcaaggaacaacattgccaaaaggcttctacgc +agaagggagcagaggcggcagtcaagcctcttctcgttcctcatcacgtagtcgcaacag +ttcaagaaattcaactccaggcagcagtatgggaacttctcctgctagaatggctggcaa +tggcggtgatgctgctcttgctttgctgctgcttgacagattgaaccagcttgagagcaa +aatgtctggtaaaggccaacaacaacaaggccaaactgtcactaagaaatctgctgctga +ggcttctaagaagcctcggcaaaaacgtactgccactaaagcatacaatgtaacacaagc +tttcggcagacgtggtccagaacaaacccaaggaaattttggggaccaggaactaatcag +acaaggaactgattacaaacattggccgcaaattgcacaatttgcccccagcgcttcagc +gttcttcggaatgtcgcgcattggcatggaagtcacaccttcgggaacgtggttgaccta +cacaggtgccatcaaattggatgacaaagatccaaatttcaaagatcaagtcattttgct +gaataagcatattgacgcatacaaaacattcccaccaacagagcctaaaaaggacaaaaa +gaagaaggcttatgaaactcaagccttaccgcagagacagaagaaacagcaaactgtgac +tcttcttcctgctgcagatttggatgatttctccaaacaattgcaacaatccatgagcag +tgctgactcaactcaggcctaaactcatgcagaccacacaaggcagatgggctatataaa +cgttttcgcttttccgtttacgatatatagtctactcttgtgcagaatgaattctcgtaa +ctacatagcacaagtagatgtagttaactttaatctcacatagcaatctttaatcagtgt +gtaacattagggaggacttgaaagagccaccacattttcaccgaggccactcggagtacg +atcgagtgtacagtgaacaatgctagggagagctgcctatatggaagagccctaatgtgt +aaaattaattttagtagtgctatcc diff --git a/cypress/fixtures/TestStyleEdgelist_snp.csv b/cypress/fixtures/TestStyleEdgelist_snp.csv new file mode 100644 index 00000000..012abcad --- /dev/null +++ b/cypress/fixtures/TestStyleEdgelist_snp.csv @@ -0,0 +1,13 @@ +source,target,Contact type,,Exposure,Case status confirmed? +797703,MZ797980,sports team,,high,Y +797703,MZ745515,sports team,,med,N +797703,MZ415508,classroom,,low,N +375596,MZ797980,classroom,,low,Y +375597,MZ375596,classroom,,high,N +505967,MZ415508,sports team,,low,N +797965,MZ375596,family member,,low,Y +797735,MZ744384,family member,,low,Y +797519,MZ797735,classroom,,low,Y +G1,MZ797735,,,low,N +G3,MZ797703,,,low,N +G3,MZ797965,,,low,N diff --git a/cypress/fixtures/TestStyleNodelist_snp.csv b/cypress/fixtures/TestStyleNodelist_snp.csv new file mode 100644 index 00000000..97ccf79a --- /dev/null +++ b/cypress/fixtures/TestStyleNodelist_snp.csv @@ -0,0 +1,16 @@ +ID,Virus_Name,Lineage,WHO_class,Collection_Date,State,Zip_code,Node_Class,Profession,Viral loads,Sex at birth,Node type,Virus source +375596,hCoV-19/USA/CO-CDC-MMB08712754/2021,B.1.617.2,Delta,7/8/2021,Colorado,80301,VOC,service industry,,Female,Person,Human +415508,hCoV-19/USA/PA-CDC-STM-000072865/2021,B.1.617.1,,7/10/2021,Pennsylvania,19019,VOI,Other ,,Female,Person,Human +505967,SARS-CoV-2/human/USA/AZ-4001/2021,B.1.617.1,,7/12/2021,Arizona,85123,VOI,Other ,,Female,Person,Human +797519,hCoV-19/USA/FL-CDC-QDX27272258/2021,B.1.1.7,Alpha,7/25/2021,Florida,32789,VOC,Hospitality,,Female,Person,Human +797703,hCoV-19/USA/TX-CDC-QDX27272171/2021,B.1.617.2,Delta,7/24/2021,Texas,75039,VOC,Healthcare,,Male,Person,Human +797735,hCoV-19/USA/FL-CDC-QDX27272212/2021,B.1.1.7,Alpha,7/25/2021,Florida,32801,VOC,Student,,Female,Person,Human +797748,hCoV-19/USA/TX-CDC-QDX27272178/2021,B.1.617.2,Delta,7/24/2021,Texas,75039,VOC,Healthcare,,Male,Person,Human +797832,hCoV-19/USA/TX-CDC-QDX27272181/2021,B.1.617.2,Delta,7/24/2021,Texas,75032,VOC,Healthcare,,Female,Person,Human +797839,hCoV-19/USA/FL-CDC-QDX27272273/2021,B.1.617.2,Delta,7/25/2021,Florida,32807,VOC,Healthcare,,Female,Person,Human +797965,hCoV-19/USA/TX-CDC-QDX27272175/2021,B.1.617.2,Delta,7/24/2021,Texas,75039,VOC,Healthcare,,Male,Person,Human +797980,hCoV-19/USA/TX-CDC-QDX27272170/2021,B.1.617.2,Delta,7/24/2021,Texas,75039,VOC,Education,,Male,Person,Human +798055,hCoV-19/USA/TX-CDC-QDX27272166/2021,B.1.617.2,Delta,7/24/2021,Texas,75039,VOC,Education,,Male,Person,Human +G1,,,,,,,,,,,Facility, +G2,,,,,,,,,,,Facility, +G3,,,,,,,,,,,Facility, diff --git a/cypress/fixtures/example.json b/cypress/fixtures/example.json new file mode 100644 index 00000000..02e42543 --- /dev/null +++ b/cypress/fixtures/example.json @@ -0,0 +1,5 @@ +{ + "name": "Using fixtures to represent data", + "email": "hello@cypress.io", + "body": "Fixtures are a great way to mock data for responses to routes" +} diff --git a/cypress/support/commands.ts b/cypress/support/commands.ts new file mode 100644 index 00000000..98f12545 --- /dev/null +++ b/cypress/support/commands.ts @@ -0,0 +1,226 @@ +// cypress/support/commands.ts +/// + +declare global { + namespace Cypress { + interface Chainable { + /** + * Attaches a file from the fixtures folder to a file input element. + * @param target_selector The selector for the element. + * @param fixture_path The path to the file within the fixtures folder. + * @param mime_type The MIME type of the file. + */ + attach_file( + target_selector: string, + fixture_path: string, + mime_type?: string + ): Chainable; + + /** + * Attaches multiple files from the fixtures folder to a file input element. + * @param target_selector The selector for the element (ie. '#fileDropRef') + * @param fixture_paths An array of the paths to the file within the fixtures folder + * @param mime_type An array of the MIME type of the file. + */ + attach_files( + target_selector: string, + fixture_paths: string[], + mime_type?: string[] + ); + + /** + * Wrapper around {@link attach_files} function that also sets/checks the datatype and fields + * @param opts array of objects each containing file name and datatype and optional field values + */ + loadFiles(opts :{ + name: string, + datatype: 'link'|'node'|'matrix'|'fasta'|'newick'|'MT/other', + field1 ?: string, + field2?: string, + field3?: string + }[]) + + /** + * Closes a PrimeNG settings pane by its dialog title. + * @param dialogTitle The title of the dialog to close. + */ + closeSettingsPane(dialogTitle: string): Chainable; + + // opens Global settings Menu + openGlobalSettings(): Chainable; + closeGlobalSettings(): Chainable; + + /** + * Opens global settings and sets the Timeline By dropdown to the given label. + * Defaults to 'Date of Symptions Resolved'. + */ + enableTimelineMode(variableLabel?: string): Chainable; + } + } + } + + const getMimeTypeFromFilename = (name: string): string => { + const ext = (name.split('.').pop() || '').toLowerCase(); + + if (ext === 'csv') return 'text/csv'; + if (ext === 'json' || ext === 'microbetrace' || ext === 'style') return 'application/json'; + + if (ext === 'fasta' || ext === 'fas' || ext === 'fa' || ext === 'nwk' || ext === 'newick') { + return 'text/plain'; + } + + if (ext === 'xlsx') return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'; + if (ext === 'xls') return 'application/vnd.ms-excel'; + + return 'application/octet-stream'; + }; + + Cypress.Commands.add('attach_files', (target_selector, fixture_paths, mime_type) => { + const mimeTypes = (mime_type && mime_type.length) + ? mime_type + : fixture_paths.map(getMimeTypeFromFilename); + + const data = new DataTransfer(); + + // Important: chain fixtures so the DataTransfer is fully populated before dispatching change + cy.wrap(fixture_paths, { log: false }).each((fixture_path, idx) => { + const mt = mimeTypes[idx] || 'application/octet-stream'; + + cy.fixture(fixture_path, 'base64').then((base64) => { + const binary = Cypress.Blob.base64StringToBlob(base64, mt); + const file = new File([binary], fixture_path, { type: mt }); + data.items.add(file); + }); + }).then(() => { + cy.get(target_selector).then(($input) => { + const el = $input.get(0) as HTMLInputElement; + el.files = data.files; + el.dispatchEvent(new Event('change', { bubbles: true })); + }); + }); + }); + + // Similar to attach_files(), but allow multiple files to be attached/loaded at once + Cypress.Commands.add('attach_files', (target_selector, fixture_paths, mime_type = ['text/csv']) => { + const data = new DataTransfer(); + fixture_paths.forEach((fixture_path, i) => { + cy.fixture(fixture_path, 'base64').then((base64) => { + const binary = Cypress.Blob.base64StringToBlob(base64, mime_type[i]); + const file = new File([binary], fixture_path, { type: mime_type[i] }); + data.items.add(file); + }) + }) + cy.get(target_selector).then(($input) => { + const el = $input.get(0) as HTMLInputElement; + el.files = data.files; + el.dispatchEvent(new Event('change', { bubbles: true })); + }); + }); + + // haven't tested newick, might need some more work when loading json, microbetrace, or auspice datatype + Cypress.Commands.add('loadFiles', (opts: { + name: string, + datatype: 'link'|'node'|'matrix'|'fasta'|'newick'|'MT/other', + field1?: string, + field2?: string, + field3?: string + }[]) => { + const fileNames = opts.map(f => f.name); + const mimeTypes = fileNames.map(getMimeTypeFromFilename); + + // Upload (waits until all fixtures are actually attached) + cy.attach_files('#fileDropRef', fileNames, mimeTypes); + + // Overlay goes away when file processing is done + cy.get('#overlay', { timeout: 20000 }).should('not.be.visible'); + + // Launch enabled is a stronger signal than "row is visible" + cy.get('#launch', { timeout: 20000 }).should('not.be.disabled'); + + // For each row: assert it exists (NOT visible), then set datatype/fields with force + opts.forEach((file) => { + cy.contains('#file-table .file-table-row', file.name, { timeout: 20000 }) + .should('exist') + .then(($fileRow) => { + const $row = cy.wrap($fileRow); + + // datatype toggle + const activeType = $fileRow.find('label.active input').attr('data-type'); + if (activeType !== file.datatype) { + $row.find(`input[data-type="${file.datatype}"]`).click({ force: true }); + } + + // field mapping + if (file.datatype === 'link' || file.datatype === 'node') { + const setField = (expectedValue: string, fieldNumber: number) => { + const selectId = `file-${file.name}-field-${fieldNumber}`; + + cy.wrap($fileRow) + .find(`select[id="${selectId}"]`) + .should('exist') + .then(($sel) => { + const current = String($sel.val()); + if (current !== expectedValue) { + cy.wrap($sel).select(expectedValue, { force: true }); + } + }); + + cy.get(`select[id="${selectId}"]`).should('have.value', expectedValue); + }; + + if (file.field1) setField(file.field1, 1); + if (file.field2) setField(file.field2, 2); + if (file.datatype === 'link' && file.field3) setField(file.field3, 3); + } + }); + }); + + cy.get('#launch', { timeout: 20000 }).should('not.be.disabled'); + }); + + Cypress.Commands.add('closeSettingsPane', (dialogTitle: string) => { + cy.contains('.p-dialog-title', dialogTitle) + .parents('.p-dialog') + .find('button.p-dialog-close-button') + .click(); + // Optionally, assert the dialog is closed + cy.contains('.p-dialog-title', dialogTitle).should('not.exist'); + }); + + Cypress.Commands.add('openGlobalSettings', () => { + cy.contains('button', 'Settings').click(); + // Optionally, assert the dialog is closed + cy.contains('.p-dialog-title', 'Global Settings').should('exist'); + }); + + Cypress.Commands.add('closeGlobalSettings', () => { + //cy.contains('button', 'Settings').click(); + // Optionally, assert the dialog is closed + cy.contains('.p-dialog-title', 'Global Settings').parents('.p-dialog').find('button.p-dialog-close-button').click(); + + cy.contains('.p-dialog-title', 'Global Settings').should('not.exist'); + }); + + Cypress.Commands.add('enableTimelineMode', (variableLabel = 'Date of symptom onset') => { + cy.openGlobalSettings(); + + cy.contains('#global-settings-modal .nav-link', 'Timeline').click(); + cy.get('#timeline-config').should('be.visible'); + + cy.get('#node-timeline-variable').click(); + cy.get('p-dropdownitem').contains('li', variableLabel).click(); + cy.get('#node-timeline-variable .p-select-label').should('contain', variableLabel); + }); + + Cypress.Commands.add('waitForNetworkToRender', (timeout = 20000) => { + cy.log('Waiting for network to render...'); + // Wait for the stats panel to be visible, as it indicates data processing is complete + cy.get('#numberOfNodes', { timeout }).should('be.visible').and('not.contain', '0'); + cy.get('#numberOfVisibleLinks', { timeout }).should('be.visible'); + }); + + Cypress.Commands.add('get_common_service', () => { + return cy.window().its('commonService'); + }); + + export {}; \ No newline at end of file diff --git a/cypress/support/e2e.ts b/cypress/support/e2e.ts new file mode 100644 index 00000000..e4e246ec --- /dev/null +++ b/cypress/support/e2e.ts @@ -0,0 +1,17 @@ +// *********************************************************** +// This example support/e2e.ts is processed and +// loaded automatically before your test files. +// +// This is a great place to put global configuration and +// behavior that modifies Cypress. +// +// You can change the location of this file or turn off +// automatically serving support files with the +// 'supportFile' configuration option. +// +// You can read more here: +// https://on.cypress.io/configuration +// *********************************************************** + +// Import commands.js using ES2015 syntax: +import './commands' \ No newline at end of file diff --git a/cypress/support/journey-helpers.ts b/cypress/support/journey-helpers.ts new file mode 100644 index 00000000..487ba1b2 --- /dev/null +++ b/cypress/support/journey-helpers.ts @@ -0,0 +1,525 @@ +// cypress/support/journey-helpers.ts +/// + +import type { Core } from 'cytoscape'; +import type { DatasetProfile, DistanceMetric, DefaultView } from '../e2e/journeys/datasets/profile'; +import type { FileLoadSpec } from '../e2e/journeys/datasets/profile'; +import type { JourneyExpectations } from '../e2e/journeys/datasets/types'; + +type WinWithMT = Window & { + commonService: any; + cytoscapeInstance?: Core; +}; + +export function acceptEulaIfPresent(): void { + cy.get('body', { log: false }).then(($body) => { + const hasEula = + $body.find('.p-dialog-title:contains("License Agreement")').length > 0; + + if (!hasEula) return; + + cy.contains('.p-dialog-title', 'License Agreement') + .parents('.p-dialog') + .within(() => { + cy.contains('button', 'Accept').click({ force: true }); + }); + + cy.contains('.p-dialog-title', 'License Agreement').should('not.exist'); + }); +} + +export function visitAppAndAcceptEula(): void { + cy.visit('/'); + cy.get('#fileDropRef', { timeout: 15000 }).should('exist'); + acceptEulaIfPresent(); +} + +export function loadFilesUI(opts: FileLoadSpec[]): void { + const fileNames = opts.map(f => f.name); + const mimeTypes = fileNames.map(getMimeTypeFromFilename); + + cy.attach_files('#fileDropRef', fileNames, mimeTypes); + cy.get('#overlay').should('not.be.visible', { timeout: 10000 }); + cy.get('#launch').should('not.be.disabled'); + + opts.forEach((file) => { + cy.contains('#file-table .file-table-row', file.name) + .should('be.visible') + .then(($fileRow) => { + const $row = cy.wrap($fileRow); + + const activeType = $fileRow.find('label.active input').attr('data-type'); + if (activeType !== file.datatype) { + $row.find(`input[data-type="${file.datatype}"]`).click({ force: true }); + } + + if (file.datatype === 'link' || file.datatype === 'node') { + const checkField = (expectedValue: string, fieldNumber: number) => { + const selectId = `file-${file.name}-field-${fieldNumber}`; + cy.wrap($fileRow).find(`select[id="${selectId}"]`).then($sel => { + const current = String($sel.val()); + if (current !== expectedValue) cy.wrap($sel).select(expectedValue); + }); + cy.get(`select[id="${selectId}"]`).should('have.value', expectedValue); + }; + + if (file.field1 !== undefined) checkField(file.field1, 1); + if (file.field2 !== undefined) checkField(file.field2, 2); + if (file.datatype === 'link' && file.field3 !== undefined) checkField(file.field3, 3); + } + }); + }); + + cy.get('#launch').should('not.be.disabled'); + } + + + export function applyPreLaunchSessionSettings(profile: DatasetProfile): void { + cy.window().then((win: unknown) => { + const w = win as WinWithMT; + const cs = w.commonService; + + cs.session.style.widgets['default-distance-metric'] = profile.preLaunch.metric; + cs.session.style.widgets['link-threshold'] = profile.preLaunch.threshold; + + if (profile.preLaunch.defaultView) { + cs.session.style.widgets['default-view'] = profile.preLaunch.defaultView; + } + + // keep GlobalSettingsModel consistent (some code reads from here too) + cs.GlobalSettingsModel.SelectedDistanceMetricVariable = profile.preLaunch.metric; + cs.GlobalSettingsModel.SelectedLinkThresholdVariable = profile.preLaunch.threshold; + }); + } + + + export function applyTwoDGroupingFromProfile(profile: DatasetProfile): void { + const g = profile.expectations.grouping; + if (!g) return; + + openTwoDSettingsDialog(); + + cy.get('@twoDSettings').contains('.nav-link', 'Grouping').click({ force: true }); + + // Controls + expandAccordionTabByHeader('@twoDSettings', 'Controls'); + + cy.get('@twoDSettings') + .find('#polygons-controls') + .should('exist') + .within(() => { + cy.get('#polygons-show-toggle') + .contains('button, .p-button, .ui-button', 'Show') + .click({ force: true }); + }); + + cy.window() + .its('commonService.session.style.widgets.polygons-show') + .should('equal', g.showGroups); + + if (g.showGroups) { + assertGroupsRendered(1); + } + + // Group By (only visible when showGroups=true) + if (g.showGroups) { + const wantSubtype = g.groupBy === 'Subtype'; + + // If you need to switch to subtype + if (wantSubtype) { + cy.get('@twoDSettings').find('#polygons-foci').should('be.visible').click({ force: true }); + cy.contains('li[role="option"]', 'Subtype').click({ force: true }); + cy.window().its('commonService.session.style.widgets.polygons-foci').should('equal', 'subtype'); + } else { + // default is cluster + cy.window().its('commonService.session.style.widgets.polygons-foci').should('equal', 'cluster'); + } + } + + // Labels + if (g.showGroups) { + cy.get('@twoDSettings').contains('p-accordionTab', 'Labels').click({ force: true }); + + cy.get('@twoDSettings') + .find('#polygons-label-visibility') + .contains(g.showGroupLabels ? 'Show' : 'Hide') + .click({ force: true }); + + cy.window().its('commonService.session.style.widgets.polygons-label-show') + .should('equal', g.showGroupLabels); + } + + // Colors + if (g.showGroups) { + cy.get('@twoDSettings').contains('p-accordionTab', 'Colors').click({ force: true }); + + cy.get('@twoDSettings') + .find('#colorPolygons') // Color Groups show/hide + .contains(g.showGroupColors ? 'Show' : 'Hide') + .click({ force: true }); + + cy.window().its('commonService.session.style.widgets.polygons-color-show') + .should('equal', g.showGroupColors); + + // If we are showing group colors, also ensure the table is visible (needed to test changing colors) + if (g.showGroupColors) { + cy.get('@twoDSettings') + .find('#polygon-color-table-row') + .should('be.visible') + .within(() => { + cy.get('#polygon-color-table-toggle').contains('Show').click({ force: true }); + }); + + cy.window().its('commonService.session.style.widgets.polygon-color-table-visible') + .should('equal', true); + + // Optional: change some group colors if specified + if (g.changeGroupColors?.groups?.length) { + // table lives in the separate polygon color dialog + cy.get('#polygon-color-table-wrapper', { timeout: 15000 }).should('be.visible'); + + g.changeGroupColors.groups.forEach((groupKey, idx) => { + const newColor = idx % 2 === 0 ? '#ff0000' : '#00ff00'; + + cy.get('#polygon-color-table') + .find(`td[data-value="${groupKey}"]`) + .should('exist') + .parents('tr') + .within(() => { + cy.get('input[type="color"]').then(($input) => { + const el = $input.get(0) as HTMLInputElement; + el.value = newColor; + el.dispatchEvent(new Event('change', { bubbles: true })); + }); + }); + }); + + // quick sanity: parent nodes exist when groups are shown + cy.window().then((win: unknown) => { + const w = win as WinWithMT; + const cyInstance = w.cytoscapeInstance as Core; + expect(cyInstance.nodes('.parent').length).to.be.greaterThan(0); + }); + } + } + } + + cy.get('@twoDSettings') + .find('button.p-dialog-close-button') + .click({ force: true }); + + cy.contains('.p-dialog-title', '2D Network Settings').should('not.exist'); + } + + function expandAccordionTabByHeader(containerAlias: string, headerText: string): void { + const timeout = 15000; + + const HEADER_CLICK_SEL = [ + '.p-accordion-header', + '.p-accordion-header-link', + '.p-accordion-header-action', + '.ui-accordion-header', + '.ui-accordion-header a' + ].join(', '); + + const TAB_SEL = '.p-accordion-tab, .ui-accordion-tab'; + const CONTENT_SEL = [ + '.p-accordion-content', + '.ui-accordion-content', + '.p-toggleable-content', + '.ui-toggleable-content' + ].join(', '); + + // Find the header by text, then walk up to something clickable + cy.get(containerAlias, { timeout }) + .should('exist') + .contains(headerText, { timeout }) + .then(($t) => { + const $clickTarget = $t.closest(HEADER_CLICK_SEL).length ? $t.closest(HEADER_CLICK_SEL) : $t; + cy.wrap($clickTarget).as('accHeader'); + }); + + cy.get('@accHeader').then(($h) => { + const $header = $h; + + const ariaExpanded = $header.attr('aria-expanded'); + const isExpanded = + $header.hasClass('p-highlight') || + $header.hasClass('ui-state-active') || + ariaExpanded === 'true'; + + if (!isExpanded) { + cy.wrap($header).scrollIntoView().click({ force: true }); + } + + // PrimeNG usually wires header -> content via aria-controls + const controlsId = $header.attr('aria-controls'); + if (controlsId) { + cy.get(`#${controlsId}`, { timeout }).should('be.visible'); + return; + } + + // Fallback: locate the tab wrapper and assert any content block is visible + const $tab = $header.closest(TAB_SEL); + if ($tab.length) { + cy.wrap($tab).find(CONTENT_SEL).first().should('be.visible'); + return; + } + + // Last resort: within container, ensure some content exists after the click + cy.get(containerAlias).find(CONTENT_SEL).should('exist'); + }); + } + + + function assertGroupsRendered(minParents = 1): void { + cy.window() + .its('cytoscapeInstance') + .should((cyInst: any) => { + expect(cyInst, 'cytoscapeInstance').to.exist; + const parents = cyInst.nodes('.parent').length; + expect(parents, 'parent groups rendered').to.be.greaterThan(minParents - 1); + }); + } + + + export function assertGroupingMembershipFromProfile(profile: DatasetProfile): void { + const expected = profile.expectations.grouping?.expectedGroups; + if (!expected) return; + + const resolveParent = (cyInstance: Core, groupKey: string) => { + const direct = cyInstance.getElementById(String(groupKey)); + if (direct && !direct.empty()) return direct; + + const prefixed = cyInstance.getElementById(`group-${String(groupKey)}`); + if (prefixed && !prefixed.empty()) return prefixed; + + return direct; // empty (for error messaging) + }; + + cy.window().then((win: unknown) => { + const w = win as WinWithMT; + const cyInstance = w.cytoscapeInstance as Core; + + expect(cyInstance, 'cytoscapeInstance').to.exist; + + const expectedGroupKeys = Object.keys(expected); + + // Parent count should match number of expected groups (regardless of id format) + const parentCount = cyInstance.nodes('.parent').length; + expect(parentCount, 'parent group count').to.equal(expectedGroupKeys.length); + + expectedGroupKeys.forEach((groupKey) => { + const parent = resolveParent(cyInstance, groupKey); + + expect(parent.empty(), `parent group exists: ${groupKey}`).to.equal(false); + + // Exact child membership + const childIds = parent.children().map((n) => n.id()); + const childSet = new Set(childIds); + + const expectedChildren = expected[groupKey].map(String); + const expectedSet = new Set(expectedChildren); + + expectedChildren.forEach((id) => { + expect(childSet.has(id), `group ${groupKey} contains ${id}`).to.equal(true); + }); + + childIds.forEach((id) => { + expect(expectedSet.has(id), `group ${groupKey} unexpected child ${id}`).to.equal(true); + }); + }); + + // Also assert every visible non-parent node belongs to one of the expected groups + const expectedAllNodeIds = new Set(expectedGroupKeys.flatMap((k) => expected[k].map(String))); + + const visibleChildNodes = cyInstance + .nodes(':visible') + .filter((n) => n.children().length === 0); + + visibleChildNodes.forEach((n) => { + const id = n.id(); + expect(expectedAllNodeIds.has(id), `visible node accounted for: ${id}`).to.equal(true); + + const parent = n.parent(); + expect(parent.empty(), `node has parent: ${id}`).to.equal(false); + + const pid = parent.id(); + const ok = expectedGroupKeys.some((k) => pid === String(k) || pid === `group-${String(k)}`); + expect(ok, `node ${id} parent id recognized`).to.equal(true); + }); + }); + } + +export function applyPreLaunchFileSettings(profile: DatasetProfile): void { + // matches your existing file tests: click settings gear that opens #file-settings-pane + cy.get('a[title="Settings"]', { timeout: 15000 }).first().click({ force: true }); + + cy.get('#file-settings-pane', { timeout: 15000 }) + .should('be.visible') + .as('fileSettings'); + + cy.get('@fileSettings') + .find('#default-distance-metric') + .should('be.visible') + .select(profile.preLaunch.metric); + + cy.get('@fileSettings') + .find('#default-distance-threshold') + .should('be.visible') + .clear() + .type(String(profile.preLaunch.threshold)) + .blur(); + + if (profile.preLaunch.defaultView) { + cy.get('@fileSettings') + .find('#default-view') + .should('be.visible') + .select(profile.preLaunch.defaultView); + } + + cy.get('@fileSettings') + .find('button.p-dialog-close-button') + .click({ force: true }); + + cy.get('#file-settings-pane').should('not.be.visible'); + + cy.window().its('commonService.session.style.widgets.default-distance-metric') + .should('equal', profile.preLaunch.metric); + + cy.window().its('commonService.session.style.widgets.link-threshold') + .should('equal', profile.preLaunch.threshold); +} + +export function launchAndWaitForProcessing(timeout = 60000): void { + cy.get('#launch', { timeout: 15000 }).should('not.be.disabled'); + cy.get('#launch').click({ force: true }); + cy.get('#loading-information', { timeout }).should('not.exist'); +} + +export function goTo2DNetworkView(): void { + cy.contains('button', 'View', { timeout: 15000 }).click({ force: true }); + cy.contains('button[mat-menu-item]', '2D Network', { timeout: 15000 }).click({ force: true }); + + cy.get('#cy', { timeout: 30000 }).should('be.visible'); + cy.window({ timeout: 30000 }).should('have.property', 'cytoscapeInstance'); +} + +export function assertAfterLaunchCounts(profile: DatasetProfile): void { + const expected = profile.expectations.afterLaunch; + if (!expected) return; + + const readInt = (selector: string) => + cy.get(selector, { timeout: 20000 }) + .invoke('text') + .then((t) => parseInt(String(t).replace(/,/g, ''), 10)); + + if (expected.nodes !== undefined) { + readInt('#numberOfNodes').should('equal', expected.nodes); + } + if (expected.visibleLinks !== undefined) { + readInt('#numberOfVisibleLinks').should('equal', expected.visibleLinks); + } + if (expected.clusters !== undefined) { + readInt('#numberOfDisjointComponents').should('equal', expected.clusters); + } + if (expected.singletons !== undefined) { + readInt('#numberOfSingletonNodes').should('equal', expected.singletons); + } +} + +export function openTwoDSettingsDialog(): void { + cy.get('TwoDComponent #tool-btn-container a[title="Settings"]', { timeout: 15000 }) + .should('exist') + .click({ force: true }); + + cy.contains('.p-dialog-title', '2D Network Settings', { timeout: 10000 }) + .should('be.visible') + .parents('.p-dialog') + .as('twoDSettings'); +} + +export function enableGroupingShow(groupBy: 'cluster' | 'subtype' = 'cluster'): void { + openTwoDSettingsDialog(); + + cy.get('@twoDSettings').contains('.nav-link', 'Grouping').click({ force: true }); + cy.get('@twoDSettings').find('#polygons-controls', { timeout: 15000 }).should('exist'); + + + // Expand Controls correctly (PrimeNG) + expandAccordionTabByHeader('@twoDSettings', 'Controls'); + + // Show groups (inside Controls) + cy.get('@twoDSettings') + .find('#polygons-controls') + .should('exist') + .within(() => { + cy.get('#polygons-show-toggle') + .contains('button, .p-button, .ui-button', 'Show') + .click({ force: true }); + }); + + cy.window() + .its('commonService.session.style.widgets.polygons-show') + .should('equal', true); + + // Wait until Cytoscape actually has parent nodes (groups) + assertGroupsRendered(1); + + // Set group-by if needed (only visible after show=true) + if (groupBy !== 'cluster') { + cy.get('@twoDSettings') + .find('#polygons-foci') + .should('be.visible') + .click({ force: true }); + + cy.contains('li[role="option"]', 'Subtype').click({ force: true }); + + cy.window() + .its('commonService.session.style.widgets.polygons-foci') + .should('equal', 'subtype'); + } else { + cy.window() + .its('commonService.session.style.widgets.polygons-foci') + .should('equal', 'cluster'); + } + + cy.get('@twoDSettings') + .find('button.p-dialog-close-button') + .click({ force: true }); + + cy.contains('.p-dialog-title', '2D Network Settings').should('not.exist'); +} + + +export function assertGroupedByCluster(): void { + cy.window().then((win: unknown) => { + const w = win as WinWithMT; + const cyInstance = w.cytoscapeInstance as Core; + + expect(cyInstance, 'cytoscapeInstance').to.exist; + + const visibleNodes = (w.commonService.session.data.nodes || []) + .filter((n: any) => n.visible !== false); + + const visibleClusters = new Set(visibleNodes.map((n: any) => String(n.cluster))); + + const parentCount = cyInstance.nodes('.parent').length; + expect(parentCount, 'parent node count').to.equal(visibleClusters.size); + + visibleNodes.forEach((n: any) => { + const nodeId = String(n._id || n.id); + const clusterId = String(n.cluster); + + const cyNode = cyInstance.getElementById(nodeId); + expect(cyNode.empty(), `cy node exists: ${nodeId}`).to.equal(false); + + const parent = cyNode.parent(); + expect(parent.empty(), `node ${nodeId} has parent`).to.equal(false); + + const pid = parent.id(); + expect([clusterId, `group-${clusterId}`], `node ${nodeId} parent id`) + .to.include(pid); + }); + }); +} diff --git a/docs/AGENTS.MD b/docs/AGENTS.MD new file mode 100644 index 00000000..f94bd930 --- /dev/null +++ b/docs/AGENTS.MD @@ -0,0 +1,301 @@ +# AGENTS.md + +This repo uses Cypress for E2E tests. UI is Angular + PrimeNG. Only the 2D Network and Bubble view use Cytoscape. Other views use different rendering stacks (example: Phylogenetic Tree is D3 + SVG, Map is Leaflet [canvas]). + +## Cypress locations + +* Tests live in `cypress/e2e/` +* Shared commands live in `cypress/support/commands.ts` +* Fixtures live in `cypress/fixtures/` + +## What to test where + +* View-level tests + + * Keep per-view tests in `cypress/e2e/-plugin.cy.ts` (example: `phylogenetic-plugin.cy.ts`, `map-plugin.cy.ts`, `twod-plugin.cy.ts`). + * These should validate: view opens, view settings affect view output, export works (when supported). +* Cross-view user journeys + + * Put high-value end-to-end flows in `cypress/e2e/journeys/*`. + * Example journey: app load -> upload files -> launch -> open a view -> change settings -> verify UI and internal state. + +## Shared UI patterns (applies to all views) + +* First load overlay + + * Either click `Continue with Sample Dataset`, or upload files via `#fileDropRef`. + * Always wait for overlay to disappear: `cy.get('#overlay').should('not.be.visible', { timeout: 10000 })` +* View navigation (top toolbar) + + * Open a view via: + + * `cy.contains('button', 'View').click()` + * `cy.contains('button[mat-menu-item]', '').click()` +* Global Settings (top toolbar) + + * Open with the shared command: `cy.openGlobalSettings()` + * Close with: `cy.closeGlobalSettings()` + * Assert dialog title: `.p-dialog-title` contains `Global Settings` +* View Settings and Export (per-view tool button containers) + + * Each view has its own tool container and its own dialogs (examples: `#tool-btn-container-phylo`, `#tool-btn-container-map`, `TwoDComponent #tool-btn-container`) + * Use `cy.closeSettingsPane('')` to close PrimeNG dialogs by title. + +## PrimeNG dialog rules (applies to all views) + +* PrimeNG uses `appendTo="body"`, so hidden duplicates can exist. +* Always scope actions under the active dialog container: + + * Find dialog by title, then alias its `.p-dialog` root. + +```ts +cy.contains('.p-dialog-title', 'Phylogenetic Tree Settings') + .parents('.p-dialog') + .as('dialogContainer'); + +cy.get('@dialogContainer') + .contains('p-accordionTab', 'Layout') + .click(); +``` + +* Use `{ force: true }` when overlays intercept clicks. + +## Fixtures and file uploads + +* Use `cy.attach_file(selector, fixtureName, mimeType?)` +* Fixtures must be in `cypress/fixtures/` +* Upload patterns + + * Initial upload: `#fileDropRef` + * Additional upload buttons often point to other inputs (example: `#data-files1`) +* After launching or processing files, wait for completion: + + * If loading modal is active: `cy.get('#loading-information', { timeout: 10000 }).should('not.exist')` + * Then wait for the target view readiness (see view-specific sections below) + +## License Agreement modal + +* A "License Agreement" dialog may appear on first load. +* Do not rely on ids. +* If present, close it by clicking the `Accept` button by text. + +## Failure triage: test issue vs app issue + +When a test fails, do not immediately weaken the test. First identify which layer broke. + +* Prove readiness first + + * If the view container is not visible or the app is still processing, treat it as setup/timing until proven otherwise. +* Prove the action happened in the intended layer + + * If you changed UI, assert the backing state changed (usually `window.commonService.session.style.widgets.*` or a view state variable under `window.commonService.visuals.*`). +* Prove the render sync happened + + * If state updated but the DOM did not, likely an app bug (missing update call, missed event wiring, missing change detection). + * If DOM changed but state did not, likely an app bug (UI not persisting to widgets/model). +* Prefer a minimal reproduction + + * Reduce to: open view -> do one action -> assert one thing. +* For suspected app bugs, document divergence explicitly + + * Example: widget changed but SVG did not update, or Cytoscape moved but `session.data.nodes[*].x/y` stayed stale. + +Tip: keep diagnostic logs inside the spec while debugging, but remove noisy logging before committing. + +## View readiness checks (per view) + +* 2D Network + + * Use `cy.waitForNetworkToRender()` and `cy.window().should('have.property', 'cytoscapeInstance')` +* Phylogenetic Tree + + * Wait for `#phylocanvas` and `#phylocanvas svg` to exist and be visible. +* Map + + * Wait for `.mapStyle` to be visible. + * Avoid relying on online tiles for correctness assertions (see Map caveats). + +## 2D Network (Cytoscape) rules + +Only the 2D Network view uses Cytoscape. These rules do not apply to other views. + +The 2D Network has 3 state layers that must stay consistent: + +* App state (widgets + model) + + * `window.commonService.session.style.widgets` + * `window.commonService.session.data.*` + * `window.commonService.session.network.*` +* Cytoscape element state (data + computed style) + + * `node.data(...)`, `edge.data(...)` + * `node.style(...)`, `edge.style(...)` +* Cytoscape geometry state (positions + rendered canvas) + + * `node.position()` + +Most failing tests update only one layer and assert on another. + +### Always access Cytoscape through the exposed singleton + +* Use `cy.window().its('cytoscapeInstance')` +* Do not create a new Cytoscape instance in tests. + +Helper: + +```ts +import { Core } from 'cytoscape'; + +const getCy = () => + cy.window({ log: false }).its('cytoscapeInstance') as Cypress.Chainable; +``` + +### Prefer the TwoD test harness for interactions + +The app exposes a Cypress harness for TwoD: + +* `window.Cypress.test.*` + +For interactions that must run inside Angular zone (dragging, some toggles), prefer calling helpers instead of pointer simulation. + +### Use .data(...) vs .style(...) correctly + +* Use `node.data('label')` to validate stored metadata. +* Use `node.style('width')`, `node.style('font-size')`, `edge.style('line-opacity')` to validate computed rendering. + +Common failure mode: + +* Asserting `node.data('width')` when width is computed via stylesheet. + + * Correct: `parseFloat(node.style('width'))` + +### Target stable node ids + +Avoid `cyInstance.nodes()[0]`. It can be a parent node, hidden, or layout-mutated. + +Use known ids and sanity checks: + +```ts +getCy().then(cyInstance => { + const nodeId = 'MZ740979'; + const node = cyInstance.getElementById(nodeId); + + expect(node.empty(), `node ${nodeId} should exist`).to.be.false; + expect(node.children().length, 'should not be compound parent').to.equal(0); + expect(node.hasClass('parent'), 'should not have parent class').to.be.false; + expect(node.hasClass('hidden'), 'should not be hidden').to.be.false; +}); +``` + +### Dragging caveats + +Do not set position directly and expect app model sync. + +This only updates Cytoscape geometry: + +* `node.position({ x, y })` + +Correct approach: + +* `win.Cypress.test.dragNodeDelta(nodeId, dx, dy)` + +A correct drag test validates both: + +* geometry moved (Cytoscape) +* model updated (`commonService.session.data.nodes[*].x/y`) + +```ts +cy.window().then(win => { + const after = win.Cypress.test.dragNodeDelta('MZ740979', 100, 50); + expect(after, 'drag helper returned a position').to.not.be.null; + + const backing = + win.commonService.session.data.nodes.find((n: any) => n._id === 'MZ740979'); + expect(backing.x).to.be.closeTo(after.x, 1); + expect(backing.y).to.be.closeTo(after.y, 1); +}); +``` + +### Selection caveats + +Two selection pathways exist: + +* Cytoscape-only selection (visual state only) + + * `node.select()` + * Assert with `cyInstance.elements(':selected')` + +* App-model-driven selection (preferred when testing sync) + + * Set `commonService.session.data.nodes[*].selected` + * Trigger: `cy.document().trigger('node-selected')` + * Assert via Cytoscape selection. + +```ts +cy.window().then(win => { + win.commonService.session.data.nodes.forEach((n: any) => (n.selected = false)); + const n = win.commonService.session.data.nodes.find((x: any) => x._id === 'MZ375596'); + n.selected = true; +}); + +cy.document().trigger('node-selected'); + +getCy().then(cyInstance => { + expect(cyInstance.elements(':selected').length).to.equal(1); +}); +``` + +### Layout and rerender caveats + +2D can re-layout via: + +* `_rerender` +* `_partialUpdate` +* `gatherGroups` +* `fit()` + +So position-sensitive tests should: + +* assert deltas (not absolute coordinates), or +* use pinned mode, or +* use the drag helper and assert immediately after. + +### Tooltips + +2D tooltips are currently unstable and should not be required targets for new tests. +Do not generate new tooltip tests unless verified end-to-end. + +### TwoD anti-patterns + +* Using `cyInstance.nodes()[0]` without sanity checks +* Expecting geometry change from model-only mutation without triggering `node-selected` +* Expecting model change from `node.position(...)` without going through the sync path +* Asserting visual properties from `.data(...)` instead of `.style(...)` +* Clicking/dragging canvas while dialogs are open and expecting pointer events to work + +## Phylogenetic Tree view (D3 + SVG) notes + +* The rendered tree lives under `#phylocanvas svg`. +* Many assertions should be DOM-based: + + * leaf node circles: `#phylocanvas svg g.tidytree-node-leaf circle` + * leaf labels: `#phylocanvas svg g.tidytree-node-leaf text` +* Settings patterns + + * Open settings via `#tool-btn-container-phylo a[title="Settings"]` + * Use dialog title `Phylogenetic Tree Settings` to scope actions. +* Export patterns + + * Open export via `#tool-btn-container-phylo a[title="Export Screen"]` + * Assert downloaded files in `cypress/downloads/*` when the export writes files. + +## Map view (Leaflet) notes + +* The view container is `.mapStyle`. +* Map rendering depends on Leaflet layers and sometimes online tiles. +* Prefer offline or internal-state assertions for stability + + * Example: assert values under `window.commonService.session.style.widgets.*` or `window.commonService.visuals.gisMap.*` after toggles. +* Avoid enabling Basemap or Satellite in tests unless you control network stability + + * Those layers download tiles from the internet and can be flaky in CI or sandboxed environments. diff --git a/package-lock.json b/package-lock.json index f8a62ab5..ab7b7577 100644 --- a/package-lock.json +++ b/package-lock.json @@ -90,6 +90,7 @@ "alignment-viewer": "^0.3.2", "bioseq": "^0.1.4", "clipboard": "^2.0.4", + "cypress": "^14.5.2", "d3-force-attract": "^0.1.1", "d3-sankey": "^0.12.3", "d3-symbol-extra": "^0.1.0", @@ -4502,6 +4503,127 @@ "node": ">=0.1.90" } }, + "node_modules/@cypress/request": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@cypress/request/-/request-3.0.8.tgz", + "integrity": "sha512-h0NFgh1mJmm1nr4jCwkGHwKneVYKghUyWe6TMNrk0B9zsjAJxpg8C4/+BAcmLgCPa1vj1V8rNUaILl+zYRUWBQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~4.0.0", + "http-signature": "~1.4.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "performance-now": "^2.1.0", + "qs": "6.14.0", + "safe-buffer": "^5.1.2", + "tough-cookie": "^5.0.0", + "tunnel-agent": "^0.6.0", + "uuid": "^8.3.2" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/@cypress/request/node_modules/http-signature": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.4.0.tgz", + "integrity": "sha512-G5akfn7eKbpDN+8nPS/cb57YeA1jLTVxjpCj7tmm3QKPdyDy7T+qSC40e9ptydSWvkwjSXw1VbkpyEm39ukeAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "assert-plus": "^1.0.0", + "jsprim": "^2.0.2", + "sshpk": "^1.18.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/@cypress/request/node_modules/jsprim": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-2.0.2.tgz", + "integrity": "sha512-gqXddjPqQ6G40VdnI6T6yObEC+pDNvyP95wdQhkWkg7crHH3km5qP1FsOXEkzEQwnz6gz5qGTn1c2Y52wP3OyQ==", + "dev": true, + "engines": [ + "node >=0.6.0" + ], + "license": "MIT", + "dependencies": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.4.0", + "verror": "1.10.0" + } + }, + "node_modules/@cypress/request/node_modules/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/@cypress/request/node_modules/tough-cookie": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz", + "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "tldts": "^6.1.32" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/@cypress/request/node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "dev": true, + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/@cypress/xvfb": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/@cypress/xvfb/-/xvfb-1.2.4.tgz", + "integrity": "sha512-skbBzPggOVYCbnGgV+0dmBdW/s77ZkAOXIC1knS8NagwDjBrNC1LuXtQJeiN6l+m7lzmHtaoUw/ctJKdqkG57Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^3.1.0", + "lodash.once": "^4.1.1" + } + }, + "node_modules/@cypress/xvfb/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, "node_modules/@discoveryjs/json-ext": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.6.1.tgz", @@ -7889,6 +8011,13 @@ "@types/send": "*" } }, + "node_modules/@types/sinonjs__fake-timers": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-8.1.1.tgz", + "integrity": "sha512-0kSuKjAS0TrGLJ0M/+8MaFkGsQhZpB6pxOmvS3K8FYI72K//YmdfoW9X2qPsAKh1mkwxGD5zib9s1FIFed6E8g==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/sizzle": { "version": "2.3.9", "resolved": "https://registry.npmjs.org/@types/sizzle/-/sizzle-2.3.9.tgz", @@ -7932,6 +8061,17 @@ "@types/node": "*" } }, + "node_modules/@types/yauzl": { + "version": "2.10.3", + "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz", + "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@types/node": "*" + } + }, "node_modules/@typescript-eslint/eslint-plugin": { "version": "5.62.0", "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz", @@ -8773,6 +8913,27 @@ "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==", "license": "ISC" }, + "node_modules/arch": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/arch/-/arch-2.2.0.tgz", + "integrity": "sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, "node_modules/are-we-there-yet": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.7.tgz", @@ -8991,6 +9152,16 @@ "node": ">=0.10.0" } }, + "node_modules/astral-regex": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz", + "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/async": { "version": "2.6.4", "resolved": "https://registry.npmjs.org/async/-/async-2.6.4.tgz", @@ -9389,6 +9560,13 @@ "readable-stream": "^3.4.0" } }, + "node_modules/blob-util": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/blob-util/-/blob-util-2.0.2.tgz", + "integrity": "sha512-T7JQa+zsXXEa6/8ZhHcQEW1UFfVM49Ts65uBkFL6fz2QmrElqmbajIDJvuA0tEhRe5eIjpV9ZF+0RfZR9voJFQ==", + "dev": true, + "license": "Apache-2.0" + }, "node_modules/blocking-proxy": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/blocking-proxy/-/blocking-proxy-1.0.1.tgz", @@ -9405,6 +9583,13 @@ "node": ">=6.9.x" } }, + "node_modules/bluebird": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==", + "dev": true, + "license": "MIT" + }, "node_modules/body-parser": { "version": "1.20.3", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", @@ -9647,6 +9832,16 @@ "ieee754": "^1.1.13" } }, + "node_modules/buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + } + }, "node_modules/buffer-from": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", @@ -9785,6 +9980,16 @@ "node": ">=0.10.0" } }, + "node_modules/cachedir": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/cachedir/-/cachedir-2.4.0.tgz", + "integrity": "sha512-9EtFOZR8g22CL7BWjJ9BUx1+A/djkofnyW3aOXZORNW2kxoUpx2h+uN2cOqwPmFhnpVmxg+KW2OjOSgChTEvsQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/call-bind": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz", @@ -9953,6 +10158,16 @@ "color-name": "^1.0.0" } }, + "node_modules/check-more-types": { + "version": "2.24.0", + "resolved": "https://registry.npmjs.org/check-more-types/-/check-more-types-2.24.0.tgz", + "integrity": "sha512-Pj779qHxV2tuapviy1bSZNEL1maXr13bPYpsvSDB68HlYcYuhlDrmGd63i0JHMCLKzc7rUSNIrpdJlhVlNwrxA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, "node_modules/chokidar": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", @@ -10010,6 +10225,22 @@ "node": ">=6.0" } }, + "node_modules/ci-info": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.0.tgz", + "integrity": "sha512-l+2bNRMiQgcfILUi33labAZYIWlH1kWDp+ecNo5iisRKrbm0xcRyCww71/YU0Fkw0mAFpz9bJayXPjey6vkmaQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/clamp": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/clamp/-/clamp-1.0.1.tgz", @@ -10070,6 +10301,54 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/cli-table3": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.1.tgz", + "integrity": "sha512-w0q/enDHhPLq44ovMGdQeeDLvwxwavsJX7oQGYt/LrBlYsyaxyDnp6z3QzFut/6kLLKnlcUVJLrpB7KBfgG/RA==", + "dev": true, + "license": "MIT", + "dependencies": { + "string-width": "^4.2.0" + }, + "engines": { + "node": "10.* || >= 12.*" + }, + "optionalDependencies": { + "colors": "1.4.0" + } + }, + "node_modules/cli-table3/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/cli-table3/node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cli-table3/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/cli-truncate": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz", @@ -10402,6 +10681,16 @@ "dev": true, "license": "ISC" }, + "node_modules/common-tags": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz", + "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4.0.0" + } + }, "node_modules/commondir": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", @@ -10964,53 +11253,406 @@ "domutils": "^3.0.1", "nth-check": "^2.0.1" }, - "funding": { - "url": "https://github.com/sponsors/fb55" + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-system-font-keywords": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/css-system-font-keywords/-/css-system-font-keywords-1.0.0.tgz", + "integrity": "sha512-1umTtVd/fXS25ftfjB71eASCrYhilmEsvDEI6wG/QplnmlfmVM5HkZ/ZX46DT5K3eblFPgLUHt5BRCb0YXkSFA==", + "license": "MIT" + }, + "node_modules/css-what": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", + "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/csscolorparser": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/csscolorparser/-/csscolorparser-1.0.3.tgz", + "integrity": "sha512-umPSgYwZkdFoUrH5hIq5kf0wPSXiro51nPw0j2K/c83KflkPSTBGMz6NJvMB+07VlL0y7VPo6QJcDjcgKTTm3w==", + "license": "MIT" + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/custom-event": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz", + "integrity": "sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cypress": { + "version": "14.5.2", + "resolved": "https://registry.npmjs.org/cypress/-/cypress-14.5.2.tgz", + "integrity": "sha512-O4E4CEBqDHLDrJD/dfStHPcM+8qFgVVZ89Li7xDU0yL/JxO/V0PEcfF2I8aGa7uA2MGNLkNUAnghPM83UcHOJw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "@cypress/request": "^3.0.8", + "@cypress/xvfb": "^1.2.4", + "@types/sinonjs__fake-timers": "8.1.1", + "@types/sizzle": "^2.3.2", + "arch": "^2.2.0", + "blob-util": "^2.0.2", + "bluebird": "^3.7.2", + "buffer": "^5.7.1", + "cachedir": "^2.3.0", + "chalk": "^4.1.0", + "check-more-types": "^2.24.0", + "ci-info": "^4.1.0", + "cli-cursor": "^3.1.0", + "cli-table3": "0.6.1", + "commander": "^6.2.1", + "common-tags": "^1.8.0", + "dayjs": "^1.10.4", + "debug": "^4.3.4", + "enquirer": "^2.3.6", + "eventemitter2": "6.4.7", + "execa": "4.1.0", + "executable": "^4.1.1", + "extract-zip": "2.0.1", + "figures": "^3.2.0", + "fs-extra": "^9.1.0", + "getos": "^3.2.1", + "hasha": "5.2.2", + "is-installed-globally": "~0.4.0", + "lazy-ass": "^1.6.0", + "listr2": "^3.8.3", + "lodash": "^4.17.21", + "log-symbols": "^4.0.0", + "minimist": "^1.2.8", + "ospath": "^1.2.2", + "pretty-bytes": "^5.6.0", + "process": "^0.11.10", + "proxy-from-env": "1.0.0", + "request-progress": "^3.0.0", + "semver": "^7.7.1", + "supports-color": "^8.1.1", + "tmp": "~0.2.3", + "tree-kill": "1.2.2", + "untildify": "^4.0.0", + "yauzl": "^2.10.0" + }, + "bin": { + "cypress": "bin/cypress" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + } + }, + "node_modules/cypress/node_modules/cli-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", + "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "restore-cursor": "^3.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cypress/node_modules/cli-truncate": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz", + "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==", + "dev": true, + "license": "MIT", + "dependencies": { + "slice-ansi": "^3.0.0", + "string-width": "^4.2.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cypress/node_modules/commander": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-6.2.1.tgz", + "integrity": "sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/cypress/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/cypress/node_modules/execa": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz", + "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==", + "dev": true, + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.0", + "get-stream": "^5.0.0", + "human-signals": "^1.1.1", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.0", + "onetime": "^5.1.0", + "signal-exit": "^3.0.2", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/cypress/node_modules/get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cypress/node_modules/human-signals": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz", + "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8.12.0" + } + }, + "node_modules/cypress/node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cypress/node_modules/listr2": { + "version": "3.14.0", + "resolved": "https://registry.npmjs.org/listr2/-/listr2-3.14.0.tgz", + "integrity": "sha512-TyWI8G99GX9GjE54cJ+RrNMcIFBfwMPxc3XTFiAYGN4s10hWROGtOg7+O6u6LE3mNkyld7RSLE6nrKBvTfcs3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "cli-truncate": "^2.1.0", + "colorette": "^2.0.16", + "log-update": "^4.0.0", + "p-map": "^4.0.0", + "rfdc": "^1.3.0", + "rxjs": "^7.5.1", + "through": "^2.3.8", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "enquirer": ">= 2.3.0 < 3" + }, + "peerDependenciesMeta": { + "enquirer": { + "optional": true + } + } + }, + "node_modules/cypress/node_modules/listr2/node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/cypress/node_modules/log-update": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/log-update/-/log-update-4.0.0.tgz", + "integrity": "sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-escapes": "^4.3.0", + "cli-cursor": "^3.1.0", + "slice-ansi": "^4.0.0", + "wrap-ansi": "^6.2.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cypress/node_modules/log-update/node_modules/slice-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz", + "integrity": "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "astral-regex": "^2.0.0", + "is-fullwidth-code-point": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/slice-ansi?sponsor=1" + } + }, + "node_modules/cypress/node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cypress/node_modules/proxy-from-env": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.0.0.tgz", + "integrity": "sha512-F2JHgJQ1iqwnHDcQjVBsq3n/uoaFL+iPW/eAeL7kVxy/2RrWaN4WroKjjvbsoRtv0ftelNyC01bjRhn/bhcf4A==", + "dev": true, + "license": "MIT" + }, + "node_modules/cypress/node_modules/restore-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", + "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cypress/node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" } }, - "node_modules/css-system-font-keywords": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/css-system-font-keywords/-/css-system-font-keywords-1.0.0.tgz", - "integrity": "sha512-1umTtVd/fXS25ftfjB71eASCrYhilmEsvDEI6wG/QplnmlfmVM5HkZ/ZX46DT5K3eblFPgLUHt5BRCb0YXkSFA==", - "license": "MIT" + "node_modules/cypress/node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true, + "license": "ISC" }, - "node_modules/css-what": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", - "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "node_modules/cypress/node_modules/slice-ansi": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz", + "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==", "dev": true, - "license": "BSD-2-Clause", - "engines": { - "node": ">= 6" + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "astral-regex": "^2.0.0", + "is-fullwidth-code-point": "^3.0.0" }, - "funding": { - "url": "https://github.com/sponsors/fb55" + "engines": { + "node": ">=8" } }, - "node_modules/csscolorparser": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/csscolorparser/-/csscolorparser-1.0.3.tgz", - "integrity": "sha512-umPSgYwZkdFoUrH5hIq5kf0wPSXiro51nPw0j2K/c83KflkPSTBGMz6NJvMB+07VlL0y7VPo6QJcDjcgKTTm3w==", - "license": "MIT" - }, - "node_modules/cssesc": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", - "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "node_modules/cypress/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, "license": "MIT", - "bin": { - "cssesc": "bin/cssesc" + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" }, "engines": { - "node": ">=4" + "node": ">=8" } }, - "node_modules/custom-event": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz", - "integrity": "sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==", + "node_modules/cypress/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, - "license": "MIT" + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } }, "node_modules/cytoscape": { "version": "3.31.0", @@ -11479,6 +12121,13 @@ "node": ">=4.0" } }, + "node_modules/dayjs": { + "version": "1.11.13", + "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.13.tgz", + "integrity": "sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg==", + "dev": true, + "license": "MIT" + }, "node_modules/debounce": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz", @@ -12885,6 +13534,13 @@ "es5-ext": "~0.10.14" } }, + "node_modules/eventemitter2": { + "version": "6.4.7", + "resolved": "https://registry.npmjs.org/eventemitter2/-/eventemitter2-6.4.7.tgz", + "integrity": "sha512-tYUSVOGeQPKt/eC1ABfhHy5Xd96N3oIijJvN3O9+TsC28T5V9yX9oEfEK5faP0EFSNVOG97qtAS68GBrQB2hDg==", + "dev": true, + "license": "MIT" + }, "node_modules/eventemitter3": { "version": "4.0.7", "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", @@ -12958,6 +13614,29 @@ "dev": true, "license": "ISC" }, + "node_modules/executable": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/executable/-/executable-4.1.1.tgz", + "integrity": "sha512-8iA79xD3uAch729dUG8xaaBBFGaEa0wdD2VkYLFHwlqosEj/jT66AzcreRDSgV7ehnNLBW2WR5jIXwGKjVdTLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^2.2.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/executable/node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/exit": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", @@ -13235,6 +13914,43 @@ "node": ">= 0.4" } }, + "node_modules/extract-zip": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz", + "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "debug": "^4.1.1", + "get-stream": "^5.1.0", + "yauzl": "^2.10.0" + }, + "bin": { + "extract-zip": "cli.js" + }, + "engines": { + "node": ">= 10.17.0" + }, + "optionalDependencies": { + "@types/yauzl": "^2.9.1" + } + }, + "node_modules/extract-zip/node_modules/get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/extsprintf": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", @@ -13370,6 +14086,16 @@ "node": ">=0.8.0" } }, + "node_modules/fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "pend": "~1.2.0" + } + }, "node_modules/figures": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz", @@ -14090,6 +14816,23 @@ "node": ">=0.10.0" } }, + "node_modules/getos": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/getos/-/getos-3.2.1.tgz", + "integrity": "sha512-U56CfOK17OKgTVqozZjUKNdkfEv6jk5WISBJ8SHoagjE6L69zOwl3Z+O8myjY9MEW3i2HPWQBt/LTbCgcC973Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "async": "^3.2.0" + } + }, + "node_modules/getos/node_modules/async": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", + "dev": true, + "license": "MIT" + }, "node_modules/getpass": { "version": "0.1.7", "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", @@ -14399,6 +15142,32 @@ "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", "license": "BSD-2-Clause" }, + "node_modules/global-dirs": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz", + "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ini": "2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/global-dirs/node_modules/ini": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz", + "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, "node_modules/global-prefix": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-4.0.0.tgz", @@ -15007,6 +15776,33 @@ "node": ">=0.10.0" } }, + "node_modules/hasha": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/hasha/-/hasha-5.2.2.tgz", + "integrity": "sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-stream": "^2.0.0", + "type-fest": "^0.8.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/hasha/node_modules/type-fest": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz", + "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=8" + } + }, "node_modules/hasown": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", @@ -16065,6 +16861,23 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/is-installed-globally": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.4.0.tgz", + "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "global-dirs": "^3.0.0", + "is-path-inside": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/is-interactive": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz", @@ -17178,6 +17991,16 @@ "integrity": "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg==", "license": "MIT" }, + "node_modules/lazy-ass": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/lazy-ass/-/lazy-ass-1.6.0.tgz", + "integrity": "sha512-cc8oEVoctTvsFZ/Oje/kGnHbpWHYBe8IAJe4C0QNc3t8uM/0Y8+erSz/7Y1ALuXTEZTMvxXwO6YbX1ey3ujiZw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "> 0.8" + } + }, "node_modules/leaflet": { "version": "1.9.4", "resolved": "https://registry.npmjs.org/leaflet/-/leaflet-1.9.4.tgz", @@ -17505,6 +18328,13 @@ "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", "license": "MIT" }, + "node_modules/lodash.once": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz", + "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==", + "dev": true, + "license": "MIT" + }, "node_modules/log-symbols": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", @@ -21067,6 +21897,13 @@ "node": ">=0.10.0" } }, + "node_modules/ospath": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/ospath/-/ospath-1.2.2.tgz", + "integrity": "sha512-o6E5qJV5zkAbIDNhGSIlyOhScKXgQrSRMilfph0clDfM0nEnBOlKlH4sWDmG95BW/CvwNz0vmm7dJVtU2KlMiA==", + "dev": true, + "license": "MIT" + }, "node_modules/p-finally": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", @@ -21499,6 +22336,13 @@ "node": ">=0.10.0" } }, + "node_modules/pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==", + "dev": true, + "license": "MIT" + }, "node_modules/performance-now": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", @@ -22042,6 +22886,19 @@ "node": ">= 0.8.0" } }, + "node_modules/pretty-bytes": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz", + "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/primeicons": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/primeicons/-/primeicons-6.0.1.tgz", @@ -22116,6 +22973,16 @@ "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, + "node_modules/process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6.0" + } + }, "node_modules/process-nextick-args": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", @@ -23083,6 +23950,16 @@ "node": ">= 6" } }, + "node_modules/request-progress": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/request-progress/-/request-progress-3.0.0.tgz", + "integrity": "sha512-MnWzEHHaxHO2iWiQuHrUPBi/1WeBf5PkxQqNyNvLl9VAYSdXkP8tQ3pBSeCPD+yw0v0Aq1zosWLz0BdeXpWwZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "throttleit": "^1.0.0" + } + }, "node_modules/request/node_modules/form-data": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", @@ -25587,6 +26464,16 @@ "tslib": "^2" } }, + "node_modules/throttleit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/throttleit/-/throttleit-1.0.1.tgz", + "integrity": "sha512-vDZpf9Chs9mAdfY046mcPt8fg5QSZr37hEH4TXYBnDF+izxgrbRGUAAaBvIk/fJm9aOFCGFd1EsNg5AZCbnQCQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/through": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", @@ -25673,6 +26560,26 @@ "integrity": "sha512-ppJZNDuKGgxzkHihX8v9v9G5f+18gzaTfrukGrq6ueg0lmH4nqVnA2IPG0AEH3jKEk2GRJCUhDoqpoiw3PHLBA==", "license": "ISC" }, + "node_modules/tldts": { + "version": "6.1.86", + "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz", + "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "tldts-core": "^6.1.86" + }, + "bin": { + "tldts": "bin/cli.js" + } + }, + "node_modules/tldts-core": { + "version": "6.1.86", + "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz", + "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==", + "dev": true, + "license": "MIT" + }, "node_modules/tmp": { "version": "0.2.3", "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz", @@ -26609,6 +27516,16 @@ "dev": true, "license": "MIT" }, + "node_modules/untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/upath": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", @@ -27946,6 +28863,17 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, + "node_modules/yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-crc32": "~0.2.3", + "fd-slicer": "~1.1.0" + } + }, "node_modules/yn": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/yn/-/yn-2.0.0.tgz", diff --git a/package.json b/package.json index f27f421d..32b03157 100644 --- a/package.json +++ b/package.json @@ -106,6 +106,7 @@ "alignment-viewer": "^0.3.2", "bioseq": "^0.1.4", "clipboard": "^2.0.4", + "cypress": "^14.5.2", "d3-force-attract": "^0.1.1", "d3-sankey": "^0.12.3", "d3-symbol-extra": "^0.1.0", diff --git a/src/COVID_DummySession.microbetrace b/src/COVID_DummySession.microbetrace index e2065e00..1fb9ec6c 100644 --- a/src/COVID_DummySession.microbetrace +++ b/src/COVID_DummySession.microbetrace @@ -11214,11 +11214,11 @@ "tree-layout-circular": false, "tree-labels-align": false, "tree-labels-show": false, - "tree-leaf-label-show": false, + "tree-leaf-label-show": true, "tree-leaf-label-size": 12, "tree-leaf-node-radius-variable": "None", "tree-leaf-node-show": true, - "tree-leaf-node-size": 9, + "tree-leaf-node-size": 5, "tree-mode-square": true, "tree-mode-smooth": false, "tree-mode-straight": false, diff --git a/src/app/contactTraceCommonServices/common.service.ts b/src/app/contactTraceCommonServices/common.service.ts index 9838f219..adfe3713 100644 --- a/src/app/contactTraceCommonServices/common.service.ts +++ b/src/app/contactTraceCommonServices/common.service.ts @@ -1,5 +1,5 @@ import { Injectable, OnInit, Output, EventEmitter, Injector, Directive } from '@angular/core'; -import { BehaviorSubject, Observable } from 'rxjs'; +import { BehaviorSubject, Observable, firstValueFrom } from 'rxjs'; import * as d3 from 'd3'; import * as patristic from 'patristic'; import * as Papa from 'papaparse'; @@ -250,7 +250,7 @@ export class CommonService extends AppComponentBase implements OnInit { 'map-basemap-show': true, 'map-collapsing-on': true, 'map-counties-show': false, - 'map-countries-show': true, + 'map-countries-show': false, 'map-field-lat': 'None', 'map-field-lon': 'None', 'map-field-tract': 'None', @@ -343,7 +343,7 @@ export class CommonService extends AppComponentBase implements OnInit { 'tree-leaf-label-size': 12, 'tree-leaf-node-radius-variable': 'None', 'tree-leaf-node-show': true, - 'tree-leaf-node-size': 9, + 'tree-leaf-node-size': 5, 'tree-mode-square': true, 'tree-mode-smooth': false, 'tree-mode-straight': false, @@ -674,6 +674,22 @@ export class CommonService extends AppComponentBase implements OnInit { return typeof a == 'number'; }; + public updateNodePosition(nodeId: string, newPosition: { x: number; y: number }): void { + const nodeToUpdate = this.session.data.nodes.find(n => n._id === nodeId); + + if (nodeToUpdate) { + console.log(`[Cypress Debug] Found node ${nodeId}. Current X: ${nodeToUpdate.x}`); + + // Use the passed-in position directly + nodeToUpdate.x = newPosition.x; + nodeToUpdate.y = newPosition.y; + + console.log(`[Cypress Debug] Updated node ${nodeId}. New X: ${nodeToUpdate.x}`); + } else { + console.warn(`[Cypress Debug] Could not find node ${nodeId} to update position.`); + } + } + /** * Adds a new node to an array of nodes. * @param {Node} newNode - The new node to be added to the array. @@ -2744,15 +2760,15 @@ align(params): Promise { // }); } - getMapData(type): Promise { + async getMapData(type): Promise { - return new Promise(resolve => { + //return new Promise(resolve => { const parts = type.split("."); const name = parts[0], format = parts[1]; if (this.temp.mapData[name]) { - return resolve(this.temp.mapData[name]); + return this.temp.mapData[name]; } let path: string; @@ -2763,31 +2779,35 @@ align(params): Promise { if (format == "csv") { path = 'assets/common/data/zipcodes.csv'; - return this.http.get(path, { responseType: 'text' }).toPromise() - .then(response => { - this.temp.mapData[name] = Papa.parse(response, { header: true }).data; - return this.temp.mapData[name]; - }); + const response = await firstValueFrom(this.http.get(path, { responseType: 'text' })); + this.temp.mapData[name] = Papa.parse(response, { header: true }).data; + return this.temp.mapData[name]; + // return this.http.get(path, { responseType: 'text' }).toPromise() + // .then(response => { + // this.temp.mapData[name] = Papa.parse(response, { header: true }).data; + // return this.temp.mapData[name]; + // }); } break; case "countries": if (format == "json") { path = 'assets/common/data/countries.json'; - return this.http.get(path).toPromise() - .then(response => { - this.temp.mapData[name] = response; - return this.temp.mapData[name]; - }); + const response = await firstValueFrom(this.http.get(path)); + this.temp.mapData[name] = response; + return this.temp.mapData[name]; + // return this.http.get(path).toPromise() + // .then(response => { + // this.temp.mapData[name] = response; + // return this.temp.mapData[name]; + // }); } break; case "counties": if (format == "json") { path = 'assets/common/data/counties.json'; - return this.http.get(path).toPromise() - .then(response => { - this.temp.mapData[name] = response; - return this.temp.mapData[name]; - }); + const response = await firstValueFrom(this.http.get(path)); + this.temp.mapData[name] = response; + return this.temp.mapData[name]; } break; @@ -2796,23 +2816,29 @@ align(params): Promise { // let path = /*this.appRootUrl() +*/ 'assets/common/data/states.json'; path = 'assets/common/data/states.json'; - return this.http.get(path).toPromise() - .then(response => { - this.temp.mapData[name] = response; - return this.temp.mapData[name]; - }); + const response = await firstValueFrom(this.http.get(path)); + this.temp.mapData[name] = response; + return this.temp.mapData[name]; + // return this.http.get(path).toPromise() + // .then(response => { + // this.temp.mapData[name] = response; + // return this.temp.mapData[name]; + // }); } break; case "land": if (format == "json") { path = 'assets/common/data/land.json'; + const response = await firstValueFrom(this.http.get(path)); + this.temp.mapData[name] = response; + return this.temp.mapData[name]; - return this.http.get(path).toPromise() - .then(response => { - this.temp.mapData[name] = response; - return this.temp.mapData[name]; - }); + // return this.http.get(path).toPromise() + // .then(response => { + // this.temp.mapData[name] = response; + // return this.temp.mapData[name]; + // }); // $.get(path, response => { // resolve(this.temp.mapData[name]); @@ -2832,7 +2858,7 @@ align(params): Promise { // } // resolve(this.temp.mapData[name]); //}); - }); + //}); }; /** diff --git a/src/app/filesComponent/files-plugin.component.html b/src/app/filesComponent/files-plugin.component.html index 7148f733..90d7ded4 100644 --- a/src/app/filesComponent/files-plugin.component.html +++ b/src/app/filesComponent/files-plugin.component.html @@ -3,7 +3,7 @@
-
+

Please add data files to load...

@@ -18,7 +18,7 @@

Please add data files to load...

- +
@@ -129,7 +129,7 @@

Please add data files to load...

- +
Please add data files to load...
- +
-
-
- - -
-
- - -
+
+
+ +
-
-
- - -
-
- - -
+
+ + +
+
+
+
+ +
+
+ + +
+
@@ -303,38 +303,7 @@

Please add data files to load...

-
- - - +
\ No newline at end of file diff --git a/src/app/filesComponent/files-plugin.component.ts b/src/app/filesComponent/files-plugin.component.ts index 925a5d02..62550b0b 100644 --- a/src/app/filesComponent/files-plugin.component.ts +++ b/src/app/filesComponent/files-plugin.component.ts @@ -803,8 +803,7 @@ export class FilesComponent extends BaseComponentDirective implements OnInit { this.showMessage(`Parsing ${file.name} as Link List...`); let l = 0; - const sources = []; - const targets = []; + const seenTargetsBySource = new Map>(); /** * Processes and then adds link. updates value of l @@ -844,58 +843,30 @@ export class FilesComponent extends BaseComponentDirective implements OnInit { const src = '' + safeLink[file.field1]; const tgt = '' + safeLink[file.field2]; + const hasReverseEdge = seenTargetsBySource.get(tgt)?.has(src) ?? false; - sources.push(src); - targets.push(tgt); - - const srcIndex = targets.findIndex(t => t == src); - const tgtIndex = sources.findIndex(s => s == tgt); - - // console.log("safe link is: ",safeLink); - - // Link is the same -> bidirectional - if(srcIndex != -1 && tgtIndex != -1) { - - // Set distance if distance set (field 3) - l += this.commonService.addLink(Object.assign({ - source: '' + safeLink[file.field1], - target: '' + safeLink[file.field2], - origin: origin, - visible: true, - directed : file.field3 == 'None' ? true : false, - bidirectional: file.field3 == 'None' ? true : false, - distance: file.field3 == 'None' ? 0 : parseFloat(safeLink[file.field3]), - hasDistance : file.field3 == 'None' ? false : true, - distanceOrigin: file.field3 == 'None' ? '' : file.name - }, safeLink), check); - - } else { - - // console.log("distance is: ", file.field3 != 'distance' ? 0 : parseFloat(safeLink[file.field3])) - // TODO uncomment when testing adding new link - // console.log('adding 2: ', _.cloneDeep(Object.assign({ - // source: '' + safeLink[file.field1], - // target: '' + safeLink[file.field2], - // origin: origin, - // visible: true, - // directed : file.field3 != 'distance' ? true : false, - // bidirectional: file.field3 != 'distance' ? true : false, - // distance: file.field3 != 'distance' ? 0 : parseFloat(safeLink[file.field3]), - // hasDistance : file.field3 != 'distance' ? false : true, - // distanceOrigin: file.field3 != 'distance' ? '' : file.name - // }, safeLink))); - - l += this.commonService.addLink(Object.assign({ - source: '' + safeLink[file.field1], - target: '' + safeLink[file.field2], - origin: origin, - visible: true, - directed : file.field3 == 'None' ? true : false, - distance: file.field3 == 'None' ? 0 : parseFloat(safeLink[file.field3]), - hasDistance : file.field3 == 'None' ? false : true, - distanceOrigin: file.field3 == 'None' ? '' : file.name - }, safeLink), check); - } + if (!seenTargetsBySource.has(src)) { + seenTargetsBySource.set(src, new Set()); + } + seenTargetsBySource.get(src)?.add(tgt); + + const isDistanceFieldMissing = file.field3 == 'None'; + const linkBase = { + source: src, + target: tgt, + origin: origin, + visible: true, + directed: isDistanceFieldMissing ? true : false, + distance: isDistanceFieldMissing ? 0 : parseFloat(safeLink[file.field3]), + hasDistance: isDistanceFieldMissing ? false : true, + distanceOrigin: isDistanceFieldMissing ? '' : file.name + } as any; + + if (hasReverseEdge && isDistanceFieldMissing) { + linkBase.bidirectional = true; + } + + l += this.commonService.addLink(Object.assign(linkBase, safeLink), check); // console.log('matrixx1: ', JSON.stringify((window as any).context.commonService.temp.matrix)); @@ -2005,8 +1976,9 @@ export class FilesComponent extends BaseComponentDirective implements OnInit { if(this.commonService.debugMode) { console.log('changing link threshold'); } - this.SelectedDefaultDistanceThresholdVariable = parseFloat(e); - this.store.setLinkThreshold(parseFloat(e)); + const newValue = e.target?.value ?? e; + this.SelectedDefaultDistanceThresholdVariable = parseFloat(newValue); + this.store.setLinkThreshold(parseFloat(newValue)); } /** @@ -2014,33 +1986,32 @@ export class FilesComponent extends BaseComponentDirective implements OnInit { * Updates link-threshold variable to default values and updates clusters, nodes, links as well as visualizations and statitistics * @param {string} e such as 'snps' */ - onDistanceMetricChange = (e) => { + onDistanceMetricChange = (metric: string) => { if(this.commonService.debugMode) { - console.log('distance ch:', e); + console.log('distance ch:', metric); } - this.SelectedDefaultDistanceMetricVariable = e; - this.store.updatecurrentThresholdStepSize(e.toLowerCase()) - if (e.toLowerCase() === 'snps') { - if(this.commonService.debugMode) { - console.log("saw snps"); - } - $('#default-distance-threshold') - .attr('step', 1) - .val(16) - .trigger('change'); - - $("#ambiguities-row").slideUp(); - this.commonService.session.style.widgets['default-distance-metric'] = 'snps'; - this.store.setMetricChanged('snps'); - this.onLinkThresholdChange('16'); - } else { - $('#default-distance-threshold') - .attr('step', 0.001) - .val(0.015) - .trigger('change'); - $("#ambiguities-row").slideDown(); - this.commonService.session.style.widgets['default-distance-metric'] = 'tn93'; - this.store.setMetricChanged('tn93'); + + // 1. Update the component's state property for the dropdown + this.SelectedDefaultDistanceMetricVariable = metric; + + // 2. Update the session state and notify the store (maintains original functionality) + this.commonService.session.style.widgets['default-distance-metric'] = metric.toLowerCase(); + this.store.setMetricChanged(metric); + this.store.updatecurrentThresholdStepSize(metric.toLowerCase()); + + if (metric.toLowerCase() === 'snps') { + // 3. Update the step attribute and UI visibility + $('#default-distance-threshold').attr('step', 1); + $("#ambiguities-row").slideUp(); + + // 4. Update the threshold value and notify the store + this.SelectedDefaultDistanceThresholdVariable = 16; + this.onLinkThresholdChange('16'); + } else { // tn93 + $('#default-distance-threshold').attr('step', 0.001); + $("#ambiguities-row").slideDown(); + + this.SelectedDefaultDistanceThresholdVariable = 0.015; this.onLinkThresholdChange('0.015'); } } diff --git a/src/app/microbe-trace-next-plugin.component.ts b/src/app/microbe-trace-next-plugin.component.ts index 46d8fdce..c5bd340b 100644 --- a/src/app/microbe-trace-next-plugin.component.ts +++ b/src/app/microbe-trace-next-plugin.component.ts @@ -258,6 +258,9 @@ export class MicrobeTraceNextHomeComponent extends AppComponentBase implements A this.appSession = injector.get(AppSessionService); + // Add this line to expose the service for Cypress tests + (window as any).commonService = this.commonService; + this.activeTabIndex = 0; this.dataSetView = []; @@ -287,6 +290,7 @@ export class MicrobeTraceNextHomeComponent extends AppComponentBase implements A } this.getGlobalSettingsData(); + console.log('common serivceeeee: ', (window as any).commonService ); // Subscribe to export requests this.exportService.exportRequested$.subscribe((info) => { this.performExport(info.element, info.exportNodeTable, info.exportLinkTable); @@ -471,6 +475,8 @@ export class MicrobeTraceNextHomeComponent extends AppComponentBase implements A opacity: '1' }, 1000); + console.log('thresholldddddd', this.commonService.session.style.widgets['link-threshold']); + }, 3000); setTimeout(() => { $('#visualwrapper').fadeTo("slow", 1); @@ -3410,10 +3416,6 @@ export class MicrobeTraceNextHomeComponent extends AppComponentBase implements A this.showButtonGroup = false; this.showSorting = false; - // this.GlobalSettingsDialogSettings.setVisibility(false); - //this.GlobalSettingsLinkColorDialogSettings.setVisibility(false); - this.GlobalSettingsNodeColorDialogSettings.setVisibility(false); - break; } case "Phylogenetic Tree": { diff --git a/src/app/visualizationComponents/AggregateComponent/aggregate.component.ts b/src/app/visualizationComponents/AggregateComponent/aggregate.component.ts index c29a1455..a6cec342 100644 --- a/src/app/visualizationComponents/AggregateComponent/aggregate.component.ts +++ b/src/app/visualizationComponents/AggregateComponent/aggregate.component.ts @@ -106,6 +106,7 @@ export class AggregateComponent extends BaseComponentDirective implements OnInit this.container.on('resize', () => { this.updateViewHeight(); this.updateTableColWidth(); + this.cdref.detectChanges(); }) this.container.on('hide', () => { this.viewActive = false; diff --git a/src/app/visualizationComponents/BubbleComponent/bubble.component.ts b/src/app/visualizationComponents/BubbleComponent/bubble.component.ts index 4a02ec16..45c40c53 100644 --- a/src/app/visualizationComponents/BubbleComponent/bubble.component.ts +++ b/src/app/visualizationComponents/BubbleComponent/bubble.component.ts @@ -136,7 +136,6 @@ export class BubbleComponent extends BaseComponentDirective implements OnInit, M this.setSelectedNodes(this); setTimeout(() => { this.goldenLayoutComponentResize(); - this.cdref.detectChanges(); }, 5) }) @@ -904,7 +903,11 @@ export class BubbleComponent extends BaseComponentDirective implements OnInit, M goldenLayoutComponentResize() { this.viewHeight = this.container.height - 73; this.viewWidth = this.container.width - 42; - setTimeout(() => this.cy.fit(this.cy.nodes(), 30), 300); + this.cdref.detectChanges() + setTimeout(() => { + this.cy.fit(this.cy.nodes(), 30); + this.onLabelSizeChange() + }, 200); } setSelectedNodes(that) { diff --git a/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.html b/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.html index a92ac047..a651a29e 100644 --- a/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.html +++ b/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.html @@ -42,7 +42,7 @@ [value]="SelectedTableData.data" [columns]="SelectedTableData.tableColumns" [resizableColumns]="true" - [styleClass]="selectedSize" + [size]="selectedSize" [scrollable]="true" [scrollHeight]="scrollHeight" [tableStyle]="tableStyleCrosstab" @@ -98,7 +98,7 @@
- +
diff --git a/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.ts b/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.ts index a55a4391..c48c82cd 100644 --- a/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.ts +++ b/src/app/visualizationComponents/CrosstabComponent/crosstab-plugin.component.ts @@ -14,6 +14,7 @@ import { CommonService } from '../../contactTraceCommonServices/common.service'; import { GoogleTagManagerService } from 'angular-google-tag-manager'; import { Subject, takeUntil } from 'rxjs'; import { CommonStoreService } from '@app/contactTraceCommonServices/common-store.services'; +import { values } from 'lodash'; @Component({ selector: 'CrosstabComponent', @@ -53,13 +54,13 @@ export class CrosstabComponent extends BaseComponentDirective implements OnInit, fieldList: SelectItem[]; SelectedTableData: TableData; totalRow; - selectedSize = ''; + selectedSize: 'small' | 'large' | undefined = undefined; scrollHeight: string; tableStyleCrosstab; sizes = [ - { name: 'Small', class: 'p-datatable-sm' }, - { name: 'Normal', class: '' }, - { name: 'Large', class: 'p-datatable-lg' } + { name: 'Small', value: 'small' }, + { name: 'Normal', value: undefined }, + { name: 'Large', value: 'large' } ]; constructor(injector: Injector, @@ -94,7 +95,7 @@ export class CrosstabComponent extends BaseComponentDirective implements OnInit, this.updateTable(); // offsets: 70 table-wrapper padding-top, 10 table-wrapper padding-bottom - let pFooterHeight = this.selectedSize == 'p-datatable-sm' ? 41 : this.selectedSize == 'p-datatable-lg' ? 65 : 57; + let pFooterHeight = this.selectedSize == 'small' ? 41 : this.selectedSize == 'large' ? 65 : 57; this.scrollHeight = ($('crosstabcomponent').height() - 70 - 10 - pFooterHeight) + 'px'; let width = ($('crosstabcomponent').width() - 23) + 'px'; this.tableStyleCrosstab = { @@ -525,17 +526,18 @@ export class CrosstabComponent extends BaseComponentDirective implements OnInit, * Resizes the component as need based on how the goldenlayout dashboard is resized */ goldenLayoutComponentResize() { - let pFooterHeight = this.selectedSize == 'p-datatable-sm' ? 41 : this.selectedSize == 'p-datatable-lg' ? 65 : 57; + let pFooterHeight = this.selectedSize == 'small' ? 41 : this.selectedSize == 'large' ? 65 : 57; this.scrollHeight = ($('crosstabcomponent').height() - 70 - 10 - pFooterHeight) + 'px'; let width = ($('crosstabcomponent').width() - 23) + 'px'; this.tableStyleCrosstab = { 'max-width' : width, 'display': 'block' } + this.cdref.detectChanges(); } onTableSizeChange() { - let pFooterHeight = this.selectedSize == 'p-datatable-sm' ? 41 : this.selectedSize == 'p-datatable-lg' ? 65 : 57; + let pFooterHeight = this.selectedSize == 'small' ? 41 : this.selectedSize == 'large' ? 65 : 57; console.log('abc', pFooterHeight); this.scrollHeight = ($('crosstabcomponent').height() - 70 - 10 - pFooterHeight) + 'px'; } diff --git a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.html b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.html index faa99c07..db8e5701 100644 --- a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.html +++ b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.html @@ -10,51 +10,52 @@ [attr.y]="ganttChartService.yPadding" [attr.width]="ganttChartService.rectWidth" [attr.height]="ganttChartService.rectHeight" -stroke="#444444" [attr.fill]="'url(#' + gridID + ')'" stroke-width="1"/> +stroke="#444444" [attr.fill]="gridFill" stroke-width="1"/> - -{{x.value}} + +{{x.value}} {{y.value}} +*ngFor="let y of yAxis" class="y-axis-text" text-anchor="end" [ngStyle]="{'font-size': fontSize}" +[attr.y]="y.yPos" [attr.x]="150+ganttChartService.xPadding-15">{{y.value}} - - + - - - + + + [attr.opacity]="legendEntry.opacity ?? 0.9" + [attr.fill]="legendEntry.color" /> - + {{ legionEntry.name }} + [attr.x]="ganttChartService.xPadding + 150 + ganttChartService.legendWidth / 3 * 0.1 + ganttChartService.legendWidth / 3 * j + 50" + [attr.y]="ganttChartService.yPadding * 2 + 40 + ganttChartService.rectHeight + 10 + 40*i" class="small"> {{ legendEntry.name }} + [attr.opacity]="ganttEntry.opacity ?? 0.9" /> diff --git a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.scss b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.scss index 825007ff..7f965779 100644 --- a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.scss +++ b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.scss @@ -1,33 +1,27 @@ -.gantt-entry { - opacity: 0.8; - &:hover { - opacity: 1; - } -} -#component .tooltip { - visibility: hidden - } - - #component:hover .tooltip { - visibility: visible; - position: absolute; - } - - #component:hover:after .tooltip{ - position: relative; - left: 0; - top: 100%; - white-space: nowrap; - } - - -.tooltip text { - fill: #eeeeee; - font-size: 12px; - font-family: sans-serif; - } - - .tooltip rect { - fill: #222222; - stroke: #111111; +#component .tooltip { + visibility: hidden + } + + #component:hover .tooltip { + visibility: visible; + position: absolute; + } + + #component:hover:after .tooltip{ + position: relative; + left: 0; + top: 100%; + white-space: nowrap; + } + + +.tooltip text { + fill: #eeeeee; + font-size: 12px; + font-family: sans-serif; + } + + .tooltip rect { + fill: #222222; + stroke: #111111; } \ No newline at end of file diff --git a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.ts b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.ts index 8fa9a858..09439204 100644 --- a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.ts +++ b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.component.ts @@ -6,7 +6,6 @@ import { GanttChartService } from './gantt-chart.service'; selector: 'ngx-gantt-chart', templateUrl: './gantt-chart.component.html', styleUrls: ['./gantt-chart.component.scss'], - providers: [GanttChartService] }) export class GanttChartComponent implements OnInit, OnChanges { @@ -20,14 +19,17 @@ export class GanttChartComponent implements OnInit, OnChanges { yPadding = this.xPadding / 2; phaseTimelines; height: number; + min(n1: number, n2: number): number { return Math.min(n1, n2) } + fontSize = 14; - gridWidthX: number; - gridWidthY: number; + gridWidthX: number = 150; + gridWidthY: number = 20; gridPrecisionX: number; gridID: string; gridPath: string; + gridFill: string; xAxis: any; yAxis: any; @@ -93,9 +95,7 @@ export class GanttChartComponent implements OnInit, OnChanges { // console.log(this.gridPrecisionX); - this.gridWidthX = this.ganttChartService.transformX(this.gridPrecisionX); - this.gridWidthY = this.ganttChartService.rectHeight / this.ganttChartService.ganttPhases.length; - this.gridPath = 'M ' + this.gridWidthX + ' 0 L 0 0 0 ' + this.gridWidthY; + this.gridPath = 'M 0 0 H' + this.gridWidthX + ' V' + this.gridWidthY + ' H 0 Z' this.xAxis = []; this.yAxis = []; @@ -113,15 +113,7 @@ export class GanttChartComponent implements OnInit, OnChanges { date = this.addDays(date, this.gridPrecisionX); } - // console.log(this.xAxis); - let cnt = 0; - for (const phase of this.ganttChartService.ganttPhases) { - const yPos = this.gridWidthY * cnt + this.gridWidthY * 0.5 + this.ganttChartService.yPadding; - this.yAxis.push({yPos, value: phase }); - cnt++; - } - // console.log(this.yAxis); - // console.log(this.xAxis); + this.calculateLabelYPos(); } getWidth(gEntry): number { @@ -180,6 +172,7 @@ export class GanttChartComponent implements OnInit, OnChanges { this.phaseTimelines[phase].push({from: timeline.from, to: timeline.to, color: team.color, + opacity: team.opacity, info: timeline.info, toolTip: (timeline.info ? 'block' : 'none')}); } @@ -206,15 +199,18 @@ export class GanttChartComponent implements OnInit, OnChanges { this.cdref.detectChanges(); this.componentID = 1; this.setDimensions(); - this.setColors(); + this.gridID = 'grid' + this.componentID; + this.gridFill = `url(#${this.gridID})` + this.setDefaultGridWidthX(); this.ganttChartService.setValues({ componentID: this.componentID, width: this.width, xPadding: this.xPadding, yPadding: this.yPadding, - data: this.data + data: this.data, + gridWidthX: this.gridWidthX, + gridWidthY: this.gridWidthY }); - this.gridID = 'grid' + this.ganttChartService.componentID; this.height = this.ganttChartService.height; this.definePhaseTimelines(); this.computeGrid(); @@ -222,17 +218,55 @@ export class GanttChartComponent implements OnInit, OnChanges { ngOnChanges() { this.setDimensions(); - this.setColors(); this.ganttChartService.setValues({ componentID: this.componentID, width: this.width, xPadding: this.xPadding, yPadding: this.yPadding, - data: this.data + data: this.data, + gridWidthX: this.gridWidthX, + gridWidthY: this.gridWidthY }); this.height = this.ganttChartService.height; this.definePhaseTimelines(); this.computeGrid(); } + setDefaultGridWidthX() { + this.gridWidthX = this.width ? (Math.floor((this.width - this.xPadding - 150) / 8 / 10) - 1) * 10 : 120; + } + calculateLabelYPos() { + this.yAxis = []; + let cnt = 0; + + for (const phase of this.ganttChartService.ganttPhases) { + const yPos = this.gridWidthY * (cnt+.5) + this.ganttChartService.yPadding + 5 + this.yAxis.push({yPos, value: phase }); + cnt++; + } + } + + updateGridWidthY(gridWidthY) { + this.gridWidthY = gridWidthY; + this.calculateLabelYPos(); + this.ngOnChanges(); + } + + updateGridWidthX(gridWidthX) { + this.gridWidthX = gridWidthX; + this.ganttChartService.rectWidth = gridWidthX * 8; + this.width = gridWidthX * 8 + 210 + 10 + this.fontSize*2.5; + this.computeGrid(); + this.ngOnChanges(); + } + + showGrid(show: boolean) { + if (show) this.gridFill = `url(#${this.gridID})` + else this.gridFill = 'none'; + } + + updateFontSize(fontSize: number) { + this.fontSize = fontSize; + this.width = this.gridWidthX * 8 + 210 + 10 + this.fontSize*2.5; + } } diff --git a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.service.ts b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.service.ts index 88c533f7..6709a3ed 100644 --- a/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.service.ts +++ b/src/app/visualizationComponents/GanttComponent/gantt-chart/gantt-chart.service.ts @@ -11,7 +11,7 @@ export class GanttChartService { ganttTeams: Array; ganttPhases: Array; phaseTimelines; - legion; + legend; ganttMinDate; ganttMaxDate; ganttDateRange: number; @@ -19,12 +19,13 @@ export class GanttChartService { yPadding: number; componentID: number; data: any; - ganttOpacity = "0.9"; + gridWidthY: number; + gridWidthX: number; rectWidth: number; rectHeight: number; - legionWidth: number; - legionHeight: number; + legendWidth: number; + legendHeight: number; minX: number; maxX: number; @@ -38,33 +39,36 @@ export class GanttChartService { constructor() { } computeRectDimensions() { - this.rectWidth = this.width - this.xPadding * 2 - 150; - this.rectHeight = this.ganttPhases.length * 60; + this.rectWidth = this.gridWidthX * 8; + this.rectHeight = this.ganttPhases.length * this.gridWidthY; } - computeLegionDimensions() { + computeLegendDimensions() { const noOfLines = Math.ceil(this.data.length / 3); - this.legionWidth = this.width - this.xPadding * 2 - 150; - this.legionHeight = 40 + 40 * noOfLines; + if (noOfLines == 1) { + this.legendWidth = this.rectWidth * this.data.length / 3 + } else { + this.legendWidth = this.rectWidth; + } + this.legendHeight = 20 + 40 * noOfLines; } transformX(x: number) { return this.rectWidth * x / (this.maxX - this.minX); } - computeLegion() { + computeLegend() { const noOfLines = Math.ceil(this.data.length / 3); - this.legion = []; + this.legend = []; let cnt = 0; for (let line = 0; line < noOfLines; line++) { - const legionLine = []; + const legendLine = []; for (let i = 0; i < 3; i++) { - if (this.ganttTeams[cnt]) legionLine.push(this.ganttTeams[cnt]); + if (this.ganttTeams[cnt]) legendLine.push(this.ganttTeams[cnt]); cnt++; } - this.legion.push(legionLine); + this.legend.push(legendLine); } - // console.log(this.legion); } transformGanttDate(d) { @@ -92,13 +96,17 @@ export class GanttChartService { width: width, xPadding: xPadding, yPadding: yPadding, - data: data + data: data, + gridWidthX: gridWidthX, + gridWidthY: gridWidthY }) { this.componentID = componentID; this.width = width; this.xPadding = xPadding; this.yPadding = yPadding; this.data = data; + this.gridWidthY = gridWidthY + this.gridWidthX = gridWidthX const froms: any = []; const tos: any = []; const phases = new Set(); @@ -122,7 +130,7 @@ export class GanttChartService { this.ganttMinDate = minDate; this.ganttMaxDate = maxDate; const noOfLines = Math.ceil(this.data.length / 3); - this.height = this.ganttPhases.length * 60 + this.yPadding * 3 + 100 + 40 + 30 * noOfLines; + this.height = this.ganttPhases.length * this.gridWidthY + this.yPadding * 3 + 20 + 30 * noOfLines; const oneDay = 24 * 60 * 60 * 1000; this.ganttDateRange = Math.round(Math.abs( @@ -146,9 +154,8 @@ export class GanttChartService { this.ganttMaxDate = this.addDays(this.ganttMinDate, this.maxX); this.computeRectDimensions(); - this.computeLegionDimensions(); - this.computeLegion(); - // this.printAll(); + this.computeLegendDimensions(); + this.computeLegend(); } addDays(date, days: number) { diff --git a/src/app/visualizationComponents/GanttComponent/gantt-plugin.component.html b/src/app/visualizationComponents/GanttComponent/gantt-plugin.component.html index 64d9b936..c64e7408 100644 --- a/src/app/visualizationComponents/GanttComponent/gantt-plugin.component.html +++ b/src/app/visualizationComponents/GanttComponent/gantt-plugin.component.html @@ -11,15 +11,15 @@

-
- +
+
@@ -31,7 +31,7 @@
+ placeholder="Entry Name" [(ngModel)]="GanttEntryName" />
- + +
@@ -65,32 +66,55 @@
- - - - Name - Start - End - Color - - - - - {{ rowData.entryName }} - {{ rowData.startDate }} - {{ rowData.endDate }} - - - - delete_outline - - - - - - +
+ + + + Name + Start + End + Color + + + + + {{ rowData.entryName }} + {{ rowData.startDate }} + {{ rowData.endDate }} + + + + + + + delete_outline + + + + + + + +
+
Grid
+
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -104,7 +128,7 @@
+ placeholder="Image Filename" [(ngModel)]="SelectedGanttChartImageFilenameVariable" />
entry["name"] === entryName)["opacity"] + } else { + startingOpacity = this.currentOpacity; + } + + let removeTransparencyWrapper = setTimeout(() => { + $("#color-transparency-wrapper").fadeOut(); + }, 7000) + + $("#color-transparency-wrapper").css({ + top: e.clientY + 129, + left: e.clientX, + display: "block", + zIndex: 99999 + }); + + $("#color-transparency") + .off("change") + .val(startingOpacity) + .one("change", (f) => { + this.currentOpacity = Number(f.target['value']) + + if (entryName) { + const startingData = cloneDeep(this.ganttChartData); + for (let i=0; i entry['entryName'] == entryName) + entry["opacity"] = this.currentOpacity; + this.currentOpacity = 0.9; + this.ganttChartElement.ngOnChanges(); + } + + this.cdref.detectChanges(); + clearTimeout(removeTransparencyWrapper) + $("#color-transparency-wrapper").fadeOut(); + }); + } + + updateEntryOpacity(entryName: string, event: Event): void { + const opacity = (event.target as HTMLInputElement).value; + const startingData = cloneDeep(this.ganttChartData); + for (let i=0; ix._id); return idSet; diff --git a/src/app/visualizationComponents/HeatmapComponent/heatmap.component.html b/src/app/visualizationComponents/HeatmapComponent/heatmap.component.html index cd066145..1b6c3199 100644 --- a/src/app/visualizationComponents/HeatmapComponent/heatmap.component.html +++ b/src/app/visualizationComponents/HeatmapComponent/heatmap.component.html @@ -12,10 +12,9 @@ - Current Distance Metric: {{this.heatmapMetric}} + Current Distance Metric: {{this.heatmapMetric}}
-
-
+
@@ -26,14 +25,11 @@ [positionLeft]="HeatmapSettingsDialogSettings.left" [positionTop]="HeatmapSettingsDialogSettings.top" [(visible)]="HeatmapSettingsDialogSettings.isVisible" - [contentStyle]="{'overflow': 'visible'}" - [style]="{'width': '20vw'}" + [contentStyle]="{'overflow': 'visible', 'width': '450px'}" header="Heatmap Settings" appendTo="body" > - - - +
@@ -49,7 +45,7 @@
- +
@@ -71,20 +67,17 @@
- +
- +
-
- -
diff --git a/src/app/visualizationComponents/HeatmapComponent/heatmap.component.scss b/src/app/visualizationComponents/HeatmapComponent/heatmap.component.scss index 3c5f24c0..03053151 100644 --- a/src/app/visualizationComponents/HeatmapComponent/heatmap.component.scss +++ b/src/app/visualizationComponents/HeatmapComponent/heatmap.component.scss @@ -14,6 +14,10 @@ width: 99% !important; */ } +#heatmap { + padding: 60px 20px 10px 10px +} + .p-component p-dropdown { overflow: visible !important; } diff --git a/src/app/visualizationComponents/HeatmapComponent/heatmap.component.ts b/src/app/visualizationComponents/HeatmapComponent/heatmap.component.ts index a1565258..c9e2bbfd 100644 --- a/src/app/visualizationComponents/HeatmapComponent/heatmap.component.ts +++ b/src/app/visualizationComponents/HeatmapComponent/heatmap.component.ts @@ -103,6 +103,7 @@ export class HeatmapComponent extends BaseComponentDirective implements OnInit { 'yaxis.autorange': true } PlotlyModule.plotlyjs.relayout("heatmap", reCenter); + this.plot = PlotlyModule.plotlyjs.newPlot('heatmap', this.heatmapData, this.heatmapLayout, this.heatmapConfig); } ngOnInit(): void { @@ -137,9 +138,9 @@ export class HeatmapComponent extends BaseComponentDirective implements OnInit { //this.visuals.microbeTrace.GlobalSettingsLinkColorDialogSettings.setVisibility(false); - this.goldenLayoutComponentResize(); + this.goldenLayoutComponentResize(true); - this.container.on('resize', () => { this.goldenLayoutComponentResize() }) + this.container.on('resize', () => { setTimeout(() => this.goldenLayoutComponentResize(), 200) }) this.container.on('hide', () => { this.viewActive = false; this.cdref.detectChanges(); @@ -155,7 +156,7 @@ export class HeatmapComponent extends BaseComponentDirective implements OnInit { drawHeatmap(config: object): void { this.commonService.getDM().then(({dm, labels}) => { this.nodeIds = labels; - const xLabels = labels.map(d => 'N' + d); + const xLabels = labels.map(d => d); const yLabels = xLabels.slice(); if (this.invertX) { @@ -184,11 +185,14 @@ export class HeatmapComponent extends BaseComponentDirective implements OnInit { const width = parentElement.clientWidth; const height = parentElement.clientHeight; */ + let marginLeft = this.heatmapShowLabels ? 90 : 10 + let marginBottom = this.heatmapShowLabels ? 75 : 10 this.heatmapLayout = { xaxis: config, yaxis: config, - width: $('#heatmap').parent().width(), - height: $('#heatmap').parent().height(), + width: $('#heatmap').parent().width() - 35, + height: $('#heatmap').parent().height() - 90, + margin: { t: 0, l: marginLeft, b: marginBottom, r: 0 } } this.heatmapConfig = { displaylogo: false, @@ -201,13 +205,35 @@ export class HeatmapComponent extends BaseComponentDirective implements OnInit { }); } - goldenLayoutComponentResize(): void { - const height = $('heatmapcomponent').height(); - const width = $('heatmapcomponent').width(); + goldenLayoutComponentResize(initial=false): void { + const height = $('heatmapcomponent').height() - 72; + const width = $('heatmapcomponent').width() - 32; if (height) - $('#heatmap').height(height-19); + $('#heatmap').height(height); if (width) - $('#heatmap').width(width-1) + $('#heatmap').width(width) + + if ( !initial) { + const config = { + autotick: false, + showticklabels: this.heatmapShowLabels + }; + if (!config.showticklabels) { + config["ticks"] = ''; + } + + let marginLeft = this.heatmapShowLabels ? 90 : 10 + let marginBottom = this.heatmapShowLabels ? 75 : 10 + this.heatmapLayout = { + xaxis: config, + yaxis: config, + width: $('#heatmap').parent().width() - 35, + height: $('#heatmap').parent().height() - 90, + margin: { t: 0, l: marginLeft, b: marginBottom, r: 0 } + } + this.openCenter() + } + /* const heatmapElement = this.heatmapContainerRef.nativeElement; const parentElement = heatmapElement.parentElement; diff --git a/src/app/visualizationComponents/MapComponent/map-plugin.component.html b/src/app/visualizationComponents/MapComponent/map-plugin.component.html index 1a2d639c..7be8ec46 100644 --- a/src/app/visualizationComponents/MapComponent/map-plugin.component.html +++ b/src/app/visualizationComponents/MapComponent/map-plugin.component.html @@ -12,7 +12,7 @@
Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under ODbL.
-
+
@@ -20,7 +20,10 @@ - + + + + {{ nodesWithoutLoc.length }}
@@ -72,7 +75,7 @@

Please add data files to load...

--> - +
@@ -147,11 +150,11 @@

Please add data files to load...

(ngModelChange)="onDataChange($event)" appendTo="body">
-
+ - +
+ @@ -273,7 +276,7 @@

Please add data files to load...

Collapsing
-
@@ -336,25 +339,24 @@

Please add data files to load...

-
\ No newline at end of file +
+ + + All nodes contain location data. + The following nodes didn't contain location data and were omitted from Map View: +
    +
  1. Index: {{ node.index }}, ID: {{ node.ID }}
  2. +
+
+
\ No newline at end of file diff --git a/src/app/visualizationComponents/MapComponent/map-plugin.component.ts b/src/app/visualizationComponents/MapComponent/map-plugin.component.ts index 13d4ce03..fca584a5 100644 --- a/src/app/visualizationComponents/MapComponent/map-plugin.component.ts +++ b/src/app/visualizationComponents/MapComponent/map-plugin.component.ts @@ -7,7 +7,7 @@ import * as d3 from 'd3'; import * as domToImage from 'dom-to-image-more'; import * as L from 'leaflet'; // import * as moment from 'moment'; -import moment from 'moment'; +//import moment from 'moment'; import 'leaflet.markercluster'; import * as MarkerCluster from 'leaflet.markercluster'; @@ -17,12 +17,13 @@ import { tileLayer, latLng, marker, icon, polyline, circle, polygon, Map, MapOpt import { DialogSettings } from '../../helperClasses/dialogSettings'; import { MicobeTraceNextPluginEvents } from '../../helperClasses/interfaces'; import { MicrobeTraceNextVisuals } from '../../microbe-trace-next-plugin-visuals'; -import { ColorIterator } from '../../helperClasses/colorIterator'; +//import { ColorIterator } from '../../helperClasses/colorIterator'; import * as _ from 'lodash'; import { BaseComponentDirective } from '@app/base-component.directive'; import { ComponentContainer } from 'golden-layout'; import { GoogleTagManagerService } from 'angular-google-tag-manager'; import { CommonStoreService } from '@app/contactTraceCommonServices/common-store.services'; +import { ExportService, ExportOptions } from '@app/contactTraceCommonServices/export.service'; declare var google: any; @@ -64,6 +65,7 @@ class LongLatClass implements LongLatInterface { export class MapComponent extends BaseComponentDirective implements OnInit, MicobeTraceNextPluginEvents, OnDestroy { @Output() DisplayGlobalSettingsDialogEvent = new EventEmitter(); + @ViewChild('mapContainer') exportContainer: ElementRef; viewActive: boolean = true; svgStyle: {} = { @@ -87,17 +89,16 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico SelectedCounty: string = "None"; SelectedState: string = "None"; SelectedCountry: string = "None"; - SelectedResidenceAddress: string = "None"; - SelectedVenueAddress: string = "None"; - SelectedExposureAddress: string = "None"; + //SelectedResidenceAddress: string = "None"; + //SelectedVenueAddress: string = "None"; + //SelectedExposureAddress: string = "None"; geocoder: any = null; - address: any = "new york city"; + //address: any = "new york city"; - OriginalCenterLocation: any = null; markers: any[] = []; - gmapOptions: any; - overlays: any[]; + //gmapOptions: any; + //overlays: any[]; SelectedNetworkExportFilenameVariable: string = ""; @@ -174,11 +175,11 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico ]; SelectedNodeCollapsingTypeVariable: string = "On"; - GeospatialTypes: any = [ - { label: 'On', value: 'On' }, - { label: 'Off', value: 'Off' } - ]; - SelectedGeospatialTypeVariable: string = "Off"; + // GeospatialTypes: any = [ + // { label: 'On', value: 'On' }, + // { label: 'Off', value: 'Off' } + // ]; + //SelectedGeospatialTypeVariable: string = "Off"; SelectedNodeTransparencyVariable: any = 0.0; @@ -195,20 +196,27 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico //gmap: google.maps.Map; //gmapMarkers: gmapMarkerInterface[]; - clusterImages: any = - { - m1: "data:image/png;base64,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", - m2: "data:image/png;base64,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", - m3: "data:image/png;base64,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", - m4: "data:image/png;base64,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", - m5: 'data:image/png;base64,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' - }; + // clusterImages: any = + // { + // m1: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADUAAAA0CAYAAAAqunDVAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9kEGAgqEZIAg5UAAAs7SURBVGjevZpbjF1ndcd//31mxmOPx/bEcWKcQBOapKkTBTBY3KFKC6nacBHhgbZSURHwQOAFzhY8cBEXCcE5AokHUFUEqHmIkCo1KomQgkqlJqFABCgxIcVuSNI4xOPY4xmP537O/vOw197nm+PbmRtbGp05l/3tb31rff/1X//1ic2+2gbIAAENoIEN0gh2gdQBjF2+ln8Feda7v6kNTWH9d7cK6omU70eBUaShMCRDysKAeJoIA8EWUoHdRepiryAt0NTKRtdV6/JEU6VRIKQxYGcYAbaRynFt18+Ij2oD4cK/gxXgLLBUL1r/Am6qUT2DMqSd2DvCG5Ux6ZjVhDthVBGfqQ7N0kAnXnTy/TLSHE3NrzUsteZwaxXbkXYDWYRSFV6VR4w9B8wjdS46kbbB3oa0A3t7b0aJceVYBdJpmuoMapjW5B3YA2wHivr+0jsd7AWkeewhpB3AbuwJpJ3ASEyUCLkF7LPAGWAWaR4Q9k5gWwBNtUDVYs1gz5Fnl/WaBjRoGGkiJuz63nIVp2lqkbYPANcDY9gjMTGvAojV/1eT7WAvIU1jHyXPZml7HNgVIJPuyyXsKfLMG/NUqxgG9vWBgIFFYBq4CrgtjOnWAHAhxKshwqwarzfxIWASeDy8vhdpuA9MloHTlzJs6LL7SNqWAEHpHTiJtAv79WFwAXRqqLYbETozwBzSbO01exhpHHssvNEFijB6BftKpLdiP4/0ZKDqFckCDSM1gM76jJKgqXMJ2nXJs0navh771vhVN0JR4aVZ4Cns4wmI7Ad2R0gejZxk7CHg5cANATyKkBPwUuyrgEfCe/vieVM01dlo+BGbcwf2InArcF0fWBRhxDFgHPsWpFuBlwH767Asr0bkouPAs0hHgCexh4GbkK6OsZ0k6CNIJ7EhzxYvl7e0Rji/DumVtevtDDiH9BD2PqR/Cq+MJPunl2TTPZXCt7SI/TjSPRGSrw3jHVGwAjxMnp0bBNa1jsT75xEuID0NHMO+A+kdsZlTD2YRcivYy/G87UkuKhKEHAbOYt+D9CRwGJiIUP0lTZ3YGkbRC8WbsWeBBeBupOsiV1VgMoI0A/wceAz7RWA+Vn8MuBY4BBwOAzt1TpIy7P8hz75DqzgInCDPptZCldbO/VJmAa1YYSdAcQb4N+AX2Dcj3Y59YyDaCaSngIew/xt4EXg38MbgkBVtGgKep6nP/fFYehWKbd8JvDP2yALSvcBzwN3YdwE3rULS1TkKpIeB78Qi3IH99joHSt+iqf9dK5ndWOnR89xdwJuQPge8AfvfkbYl9Ob8e3rcrgKN55Fej70f6YPYbfLs2HoM2rhRPfCYQLob+GISQoOOXSHcOaT3Yf+IPFveSLGYRaVa1UfrvT6A/cUkF2nNC1sS3/uRXrU5RWLJ74zUpSmf54lLh9+7gPtWFX3rvUr07GDfRJ49s6ZoWUWTyrpmd6BYl1axFFRnhKYWL1q+lwMeAP5l0/ZnuSjDSJ8H3j/QorqOtJHgqSui7Sx4VSN+NBcP+AtgLtDsd6EluPZkuRifQGpvunhT8cWSZ642rBJ2SmJ7LU09Rdv7gmaBtCjabkT5oEh+LwbleU0w8iGk+4H3ROH3NPAk0nHsJ5AObrJBVRjfS1N/H14YA/40GP9MlDq7or57IArLHZEmikrKypJNvox0VfL+LE2tYN8GvAbpvUh/ib0bOLjpXurVYn8XBn0B+CrSR4G/xl6K8r+LtIJ9FXanlhYgy4DhpADrhqtHksdU4XhNAr9PA3/LVl1V/moVtyA1on4qkG5BOlfzy9KQsWD9dRrJEsmKpJAbCzQrmULbY9gN7IoOnUX6MyS21LByr09FNaB4/ngSRQ6t0elcsosM6MTYLrAfqYhYXwJOYU/0LQhbFIqTfcg6dEH0S+aSXRaFyoHPJQMPA+NRR7HFl4PVuw/2L+bZMGq1cqoLFHHbyLPJJFQzYFsoO1tskgvgGqCo66+mTq9Sfav9t8pT5Y2rPVfCpsJTO+K7MzGIgYPY98aCeEs8VE7yCNK28E6GNE3bo8niK8SdBn1GdJEUkxWtYgiYSdw5Hq9HYxAj3QgciyJRW+AhIf02VKrRWOgG8FjMp1r8DOlUbIkKSMjCtZ2YnCORnUkk5RFaxQT20VoKhhuBfdjf3kLk+wj2ochJDpX3Z8DeJJcZexZpuNbxpeUs4LCbDLkdez7ESsV3NwBP1J+VEvP7ge8CS7WkvHmeOkJTP0b6m6SqPkGePQdcnRg+RZ4V4anq3uWMpozdrS0vY7iDgsyWe+4A0umAcqKfdAMwjf1Aotpuxl7qIjVpFW8DroxxM+BHtIpdwN4k0R6nVQzXObQ0dLGC9KUELo29DXuyhvQyRK8F7kMaTZDmH4C7gJ9seG/1WM3XsX+DdFdo7CDNYT+ayHOK10mk8Yg2BdPoVEbNJ8BgYAdwLJSdyoMvI88ew/51osldF3rEX8Xn6QTXhnTlPvky0qeAD9d9KrsB/CwmvQe7iDnNAPPJniP0waKsfMs6aTHJUUN1bEMjDN5Jq7gV+Gek2bqFI70a+Efgduz/SJiAB/BO2g76LPA17I/VPLPkfb+jqXuxb6vTj9TAfgoYr9lPOdYieUaW1CrTSQIWcAXwDNLZeF8gvTwU1O8ndGUZOBQaxfuw7wwg0UWTc69XBfAr4AD2d5E+Gcy/6vvOAN+kVRxE2lXDOEySZyeiV+Y6JeXZXI9BtGv+NBEKarU5T0et9YokTIz9IPBW4L1JKsgCQO5B+gX2u4EPIe3H3rOqrwUnsY+FbngE+w7gPUhLCTAsYH8rmnKvTRTeDtKD2DtrrbBco7OVLK2+8nwEe2/y8Kptcwj7mrrDUYbqfyIdxv5QGFOpswJOAc8C/xpJc88qUcaeQroFeB1wfTDvIlmcWeyvxvvDtdfL18eRTgB7k0hYieIW8iwxqidQXoE9WjMMWKSpKdq+vY9cNrD/K3pNH49WD8l9C8CXaOrUBcSa0Qi1A30KlLGfBb4R4X8oWEW1GC+QZ4/S9kv6+OkZ8mzxfJberIntVBzgqGjHKG3vwn4oEm21VwrgzdjbkT6NfR9wDhiNjXsyjg6cf+XZIvbvE4K8Hfsk9veArwA3Ih2KxO945iR59iit4soEXIS9lBp0fulRKUb2mb7NvDM42I+RFmqDy1C5GftNwMNIecjIc8D/09TyJajQb8PbLwAt8uwzIfLciXRtX/dkGunntL0vTs4QYd4Fpvp1S11CzxtD2hPN6opkzkTj7TDS1dFMqx7cCMZxLDp/o/0r2Df+eFStp6JreD3SRNL2rMjzszR1hFaxN0qetIA9RZ6t9CtOl+vOj2PvSg52GHspypA/AV5ZS2eVdl4dBGnqgQFaQm/BHoujP6TiSRj0SDTL99V95F6z7xR5tnQhPTK7jPI5G/skTaajSPuA57AfRJoKbypJvNOrUsX5e4q6RkvPWJTP6QDPkWc/iDDenzTGq/1cGtQjDus4HFKCwRVUp77KUHQg3ExocC+N5tso9k/Js+MDjD0B3B57Ywk4CrwQOWlPvX96DTlHI3vpUh2RbCAqk2cL2KeCd6ULsQP7QPz/BE3dDzyCdPyiXkpD0J7G/j/sn9DUD4FnIp1cHTJdet6pJLCXMWhw/bvXsmkAu5C2rzos1YPYJWAOe3HgvlKraIRkMFrXRf2Ht8pW7DnyzIPo64M9uToKl2fd2AdTwQVV8y7HASoYGVhlKr25E3scezhZKNVdeXsSaXZQgzbW8y0nNRakcriO+b7sPoBh1eGs9BTaEtJ83XVZY0dx7b3HsoldeXAu9tqL0f7pJAx70Gs5PLQc2sjJAIPyEMg6WqR/AP8TaUdhTpMSAAAAAElFTkSuQmCC", + // m2: "data:image/png;base64,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", + // m3: "data:image/png;base64,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", + // m4: "data:image/png;base64,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", + // m5: 'data:image/png;base64,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' + // }; + + // getImageValues() { + // return(Object.values(this.clusterImages)) + // } - locationsFound: any[] = []; + //locationsFound: any[] = []; private lmap: Map; private mapTooltip: string = '#mapTooltip' + nodesWithoutLoc: {index: number, ID: string}[] = []; + showPopupMessage: boolean = false; + public leafletMarkers: Layer[] = []; public leafletInitialOptions: MapOptions; public leafletMarkerClusterOptions: MarkerClusterGroupOptions; @@ -221,19 +229,19 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico private visuals: MicrobeTraceNextVisuals; - private colorIterator: ColorIterator = new ColorIterator(); + //private colorIterator: ColorIterator = new ColorIterator(); - private marker: { triangle: string, square: string, circle: string } = { - triangle: '', - square: '', - circle: '', - }; + // private marker: { triangle: string, square: string, circle: string } = { + // triangle: '', + // square: '', + // circle: '', + // }; - public dateFilterRangeValues: number[] = [0, 100]; - public dateFilterRangeMax: number = 100; - public dateFilterRangeDates: Date[] = [new Date(), new Date()]; - public dateFilterRangeMinDate: Date; - public geospatialNodes: MarkerWithData[] = []; + // public dateFilterRangeValues: number[] = [0, 100]; + // public dateFilterRangeMax: number = 100; + // public dateFilterRangeDates: Date[] = [new Date(), new Date()]; + // public dateFilterRangeMinDate: Date; + //public geospatialNodes: MarkerWithData[] = []; constructor(injector: Injector, private renderer: Renderer2, @@ -244,6 +252,7 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico @Inject(BaseComponentDirective.GoldenLayoutContainerInjectionToken) private container: ComponentContainer, elRef: ElementRef, private cdref: ChangeDetectorRef, + private exportService: ExportService, private gtmService: GoogleTagManagerService) { super(elRef.nativeElement); @@ -341,7 +350,10 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico } }); - this.container.on('resize', () => { this.lmap.invalidateSize() }) + this.container.on('resize', () => { + this.lmap.invalidateSize(); + this.centerMap(); + }) this.container.on('hide', () => { this.viewActive = false; this.cdref.detectChanges(); @@ -350,6 +362,11 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.viewActive = true; this.cdref.detectChanges(); }) + + // Subscribe to style file applied event + this.store.styleFileApplied$.pipe(takeUntil(this.destroy$)).subscribe(() => { + this.applyStyleFileSettings(); + }); } ngAfterViewInit() { @@ -434,12 +451,12 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico if (foundVenueAddressColName) this.SelectedVenueAddress = foundVenueAddressColName; }*/ - onDateFilterChange(e: any) { - this.dateFilterRangeDates[0] = moment(this.dateFilterRangeMinDate).add(this.dateFilterRangeValues[0], 'days').toDate(); - this.dateFilterRangeDates[1] = moment(this.dateFilterRangeMinDate).add(this.dateFilterRangeValues[1], 'days').toDate(); + // onDateFilterChange(e: any) { + // this.dateFilterRangeDates[0] = moment(this.dateFilterRangeMinDate).add(this.dateFilterRangeValues[0], 'days').toDate(); + // this.dateFilterRangeDates[1] = moment(this.dateFilterRangeMinDate).add(this.dateFilterRangeValues[1], 'days').toDate(); - this.onDataChange(undefined); - } + // this.onDataChange(undefined); + // } /* Not sure about this function setDateRangeFilterValues() { @@ -505,16 +522,16 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.commonService.session.style.widgets['map-field-county'] = this.SelectedCounty; this.commonService.session.style.widgets['map-field-state'] = this.SelectedState; this.commonService.session.style.widgets['map-field-country'] = this.SelectedCountry; - this.commonService.session.style.widgets['map-field-residence-address'] = this.SelectedResidenceAddress; - this.commonService.session.style.widgets['map-field-venue-address'] = this.SelectedVenueAddress; - this.commonService.session.style.widgets['map-field-exposure-address'] = this.SelectedExposureAddress; + //this.commonService.session.style.widgets['map-field-residence-address'] = this.SelectedResidenceAddress; + //this.commonService.session.style.widgets['map-field-venue-address'] = this.SelectedVenueAddress; + //this.commonService.session.style.widgets['map-field-exposure-address'] = this.SelectedExposureAddress; this.clearAllMarkers(); this.layers.removeLinks(); this.nodes = this.commonService.getVisibleNodes(); - let cnt: any = 0; - let dataFound: boolean = false; + //let cnt: any = 0; + //let dataFound: boolean = false; let that = this; // XXX check if reroll is need for drawNodes() @@ -528,7 +545,7 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico } that.drawLinks(); that.resetStack(); - // that.visuals.gisMap.lmap.flyToBounds(that.layers.nodes().getBounds()); + that.centerMap() }, false); } @@ -577,6 +594,8 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico if (e == "Show") { this.commonService.session.style.widgets['map-countries-show'] = true; + this.onSatelliteChange('Hide', true); + this.onBasemapChange('Hide', true); if (this.layers.countries.getLayers().length > 0) { this.layers.countries.addTo(this.lmap); this.resetStack(); @@ -724,16 +743,16 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico * @param e */ onGeospatialTypeChange(e) { - if (this.SelectedGeospatialTypeVariable == "On") { - this.commonService.session.style.widgets['map-geospatial-type-on'] = true; - this.drawNodes(); - this.drawLinks(); - } - else { + // if (this.SelectedGeospatialTypeVariable == "On") { + // this.commonService.session.style.widgets['map-geospatial-type-on'] = true; + // this.drawNodes(); + // this.drawLinks(); + // } + // else { this.commonService.session.style.widgets['map-geospatial-type-on'] = false; this.drawNodes(); this.drawLinks(); - } + //} } /** @@ -781,13 +800,12 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.visuals.gisMap.ShowGEOMapExportPane = false; this.isExporting = true; - if (this.commonService.session.style.widgets['node-color-variable'] != 'None') { - this.visuals.microbeTrace.generateNodeColorTable("#node-color-table-bottom-map", false); - } - - if (this.commonService.session.style.widgets['link-color-variable'] != 'None') { - this.visuals.microbeTrace.generateNodeLinkTable("#link-color-table-bottom-map", false); - } + /* + Currently not able to export map view as an SVG, with a lot of work may be possible with limitations (I was able to use similar idea from 2D) + 1. updated preferCanvas to false initially, so it renders an SVG; 2. selected that element [document.querySelector('.mapStyle svg').outerHTML;] + 3. made modifications and passed it to a modified this.exportService.requestSVGExport; 4. that was able to export but still needed to add xmlns="http://www.w3.org/2000/svg" to svg tag + The resulting svg was still incomplete; it didn't have collapsed nodes and only allowed the offline map setting (not sure if its possible to use basemap or satellite) + */ if (!this.isExportClosed) { setTimeout(() => this.exportVisualization(undefined), 300); @@ -802,40 +820,19 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico } exportWork() { + this.lmap.removeControl(this.lmap.zoomControl) setTimeout(() => { - var format = this.visuals.gisMap.SelectedNetworkExportFileTypeListVariable; - const element = document.querySelector('MapComponent').parentElement; - - domToImage.toBlob(element) - .then((blob) => { - // Sometimes libraries don't play nice with each other. - // Sometimes dom-to-image does not recognize the leaflet element - // so we jiggle it and try again. Typically works the second time, but we try 10 times - if (blob === null) { - if (this.visuals.gisMap.exportTryCount > 10) { - //return toast about export failed - } - this.visuals.gisMap.exportTryCount += 1; - - this.visuals.gisMap.lmap.flyToBounds(this.visuals.gisMap.lmap.getBounds()); - - this.visuals.gisMap.exportWork(); - } - else { - saveAs(blob, this.visuals.gisMap.SelectedNetworkExportFilenameVariable + '.' + format); - this.visuals.gisMap.isExporting = false; - this.visuals.microbeTrace.clearTable("#node-color-table-bottom-map"); - this.visuals.microbeTrace.clearTable("#link-color-table-bottom-map"); - - this.visuals.gisMap.exportTryCount = 0; - - this.visuals.microbeTrace.GlobalSettingsDialogSettings.restoreStateAfterExport(); - this.visuals.microbeTrace.GlobalSettingsLinkColorDialogSettings.restoreStateAfterExport(); - this.visuals.microbeTrace.GlobalSettingsNodeColorDialogSettings.restoreStateAfterExport(); - this.visuals.gisMap.NodeMapSettingsExportDialogSettings.restoreStateAfterExport(); - } - }); + const exportOptions: ExportOptions = { + filename: this.SelectedNetworkExportFilenameVariable, + filetype: this.SelectedNetworkExportFileTypeListVariable, + scale: this.SelectedNetworkExportScaleVariable, + quality: this.SelectedNetworkExportQualityVariable, + } + this.exportService.setExportOptions(exportOptions); + let elementsToExport: HTMLDivElement[] = [this.exportContainer.nativeElement] + this.exportService.requestExport(elementsToExport, true, true) }, 1000); + new Promise(resolve => setTimeout(resolve, 2000)).then(() => this.lmap.addControl(this.lmap.zoomControl)) } displayColorOptions() { @@ -1031,108 +1028,118 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico } }); } - if (callback) callback(); - } - - getResidenceMarker(nodeColor: string, iconCode: string, location: LocationDetail, data: any): MarkerWithData { - const iconSettings = { - mapIconUrl: iconCode, - mapIconColor: nodeColor, - }; - - const divIcon = L.divIcon({ - className: "leaflet-data-marker", - html: L.Util.template(iconSettings.mapIconUrl, iconSettings), - iconSize: [15, 15] - }); - - const locationDetail: LocationDetail = { - Name: location.Name, - FullAddress: location.FullAddress, - Date: location.Date ? new Date(location.Date) : undefined, - Latitude: location.Latitude, - Longitude: location.Longitude - } - data._jlat = location.Latitude; - data._jlon = location.Longitude; - let marker: MarkerWithData = L.marker([location.Latitude, location.Longitude], { icon: divIcon }); - marker.data = data; - marker.locationDetail = locationDetail; - - return marker; - } - - getVenueMarker(nodeColor: string, iconCode: string, location: VenueLocationDetail, data: any): MarkerWithData | undefined { - const iconSettings = { - mapIconUrl: iconCode, - mapIconColor: nodeColor, - }; - - const divIcon = L.divIcon({ - className: "leaflet-data-marker", - html: L.Util.template(iconSettings.mapIconUrl, iconSettings), - iconSize: [15, 15] - }); - - const locationDetail: LocationDetail = { - Name: location.Name, - FullAddress: location.FullAddress, - Date: location.DateOfContact ? new Date(location.DateOfContact) : undefined, - Latitude: location.Latitude, - Longitude: location.Longitude - } - - if (locationDetail.Latitude != undefined && locationDetail.Longitude != undefined) { - let marker: MarkerWithData = L.marker([location.Latitude, location.Longitude], { icon: divIcon }); - marker.data = data; - marker.locationDetail = locationDetail; - - return marker; - } - - return undefined - } - - getExposureMarkers(nodeColor: string, iconCode: string, exposureProp: any, data: any): MarkerWithData[] { - const iconSettings = { - mapIconUrl: iconCode, - mapIconColor: nodeColor, - }; - - const divIcon = L.divIcon({ - className: "leaflet-data-marker", - html: L.Util.template(iconSettings.mapIconUrl, iconSettings), - iconSize: [15, 15] - }); - - let markers: MarkerWithData[] = []; - - let locationDetails: LocationDetail[] = []; - - Object.keys(exposureProp).forEach(prop => { - const locationDetail: LocationDetail = { - Name: exposureProp[prop].Name, - FullAddress: exposureProp[prop].FullAddress, - Date: exposureProp[prop].ExposedDate ? new Date(exposureProp[prop].ExposedDate) : undefined, - Latitude: exposureProp[prop].Latitude, - Longitude: exposureProp[prop].Longitude - }; - - locationDetails.push(locationDetail); - - if (locationDetail.Latitude != undefined && locationDetail.Longitude != undefined) { - let marker: MarkerWithData = L.marker([locationDetail.Latitude, locationDetail.Longitude], { icon: divIcon }); - marker.data = data; - marker.locationDetail = locationDetail; - - markers.push(marker); + this.nodesWithoutLoc = []; + let nodeLocSet: boolean = false; + this.nodes.forEach(n => { + if (!n._lat || !n._lon){ + this.nodesWithoutLoc.push({index: n.index, ID: n._id}) } + if ( !nodeLocSet && n._lat && n._lon) nodeLocSet = true; }) - return markers; + if (callback) callback(); } + // getResidenceMarker(nodeColor: string, iconCode: string, location: LocationDetail, data: any): MarkerWithData { + // const iconSettings = { + // mapIconUrl: iconCode, + // mapIconColor: nodeColor, + // }; + + // const divIcon = L.divIcon({ + // className: "leaflet-data-marker", + // html: L.Util.template(iconSettings.mapIconUrl, iconSettings), + // iconSize: [15, 15] + // }); + + // const locationDetail: LocationDetail = { + // Name: location.Name, + // FullAddress: location.FullAddress, + // Date: location.Date ? new Date(location.Date) : undefined, + // Latitude: location.Latitude, + // Longitude: location.Longitude + // } + // data._jlat = location.Latitude; + // data._jlon = location.Longitude; + + // let marker: MarkerWithData = L.marker([location.Latitude, location.Longitude], { icon: divIcon }); + // marker.data = data; + // marker.locationDetail = locationDetail; + + // return marker; + // } + + // getVenueMarker(nodeColor: string, iconCode: string, location: VenueLocationDetail, data: any): MarkerWithData | undefined { + // const iconSettings = { + // mapIconUrl: iconCode, + // mapIconColor: nodeColor, + // }; + + // const divIcon = L.divIcon({ + // className: "leaflet-data-marker", + // html: L.Util.template(iconSettings.mapIconUrl, iconSettings), + // iconSize: [15, 15] + // }); + + // const locationDetail: LocationDetail = { + // Name: location.Name, + // FullAddress: location.FullAddress, + // Date: location.DateOfContact ? new Date(location.DateOfContact) : undefined, + // Latitude: location.Latitude, + // Longitude: location.Longitude + // } + + // if (locationDetail.Latitude != undefined && locationDetail.Longitude != undefined) { + // let marker: MarkerWithData = L.marker([location.Latitude, location.Longitude], { icon: divIcon }); + // marker.data = data; + // marker.locationDetail = locationDetail; + + // return marker; + // } + + // return undefined + // } + + // getExposureMarkers(nodeColor: string, iconCode: string, exposureProp: any, data: any): MarkerWithData[] { + // const iconSettings = { + // mapIconUrl: iconCode, + // mapIconColor: nodeColor, + // }; + + // const divIcon = L.divIcon({ + // className: "leaflet-data-marker", + // html: L.Util.template(iconSettings.mapIconUrl, iconSettings), + // iconSize: [15, 15] + // }); + + // let markers: MarkerWithData[] = []; + + // let locationDetails: LocationDetail[] = []; + + // Object.keys(exposureProp).forEach(prop => { + // const locationDetail: LocationDetail = { + // Name: exposureProp[prop].Name, + // FullAddress: exposureProp[prop].FullAddress, + // Date: exposureProp[prop].ExposedDate ? new Date(exposureProp[prop].ExposedDate) : undefined, + // Latitude: exposureProp[prop].Latitude, + // Longitude: exposureProp[prop].Longitude + // }; + + // locationDetails.push(locationDetail); + + // if (locationDetail.Latitude != undefined && locationDetail.Longitude != undefined) { + // let marker: MarkerWithData = L.marker([locationDetail.Latitude, locationDetail.Longitude], { icon: divIcon }); + // marker.data = data; + // marker.locationDetail = locationDetail; + + // markers.push(marker); + // } + // }) + + // return markers; + // } + /*getGeospatialNodes(): MarkerWithData[] { let returnMarkerWithData: MarkerWithData[] = []; @@ -1208,13 +1215,13 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico if (!this.commonService.session.style.widgets['map-node-show']) return; - if (this.SelectedGeospatialTypeVariable == 'On') { - //this.drawLeafletMapNodesGeospatial(); - console.error('implement drawLeafletMapNodesGeospatial') - } - else { + // if (this.SelectedGeospatialTypeVariable == 'On') { + // //this.drawLeafletMapNodesGeospatial(); + // console.error('implement drawLeafletMapNodesGeospatial') + // } + // else { this.drawLeafletMapNodesList(); - } + //} } /*drawLeafletMapNodesGeospatial() { @@ -1262,7 +1269,7 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico if (!d._jlat || !d._jlon || d.visible === false) continue; let circleMarker: CircleWithData = L.circleMarker(L.latLng(d._jlat, d._jlon), { - weight: 1, + weight: d.selected ? 3 : 1, color: d.selected ? selectedColor : '#000000', opacity: opacity, fillColor: colorVariable == 'None' ? fillcolor : this.commonService.temp.style.nodeColorMap(d[colorVariable]), @@ -1360,7 +1367,7 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico }); this.layers.links = featureGroup(features); - this.lmap.addLayer(this.layers.links); + if (this.lmap != undefined) this.lmap.addLayer(this.layers.links); if (this.commonService.session.style.widgets['map-node-show']) { if (this.commonService.session.style.widgets['map-collapsing-on']) { @@ -1582,12 +1589,13 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico openExport() { this.ShowGEOMapExportPane = true; - this.visuals.microbeTrace.GlobalSettingsDialogSettings.setStateBeforeExport(); - this.visuals.microbeTrace.GlobalSettingsLinkColorDialogSettings.setStateBeforeExport(); - this.visuals.microbeTrace.GlobalSettingsNodeColorDialogSettings.setStateBeforeExport(); this.visuals.gisMap.NodeMapSettingsExportDialogSettings.setStateBeforeExport(); } + showPopup() { + this.showPopupMessage = true; + } + openCenter() { this.centerMap(); } @@ -1641,19 +1649,13 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.SelectedBasemapTypeVariable = this.commonService.session.style.widgets['map-basemap-show'] ? 'Show' : 'Hide'; - if (this.SelectedBasemapTypeVariable === 'Show') { - this.onBasemapChange(this.SelectedBasemapTypeVariable, true); - } - - //Components|Online|Satellite - this.SelectedSatelliteTypeVariable = this.commonService.session.style.widgets['map-satellite-show'] ? 'Show' : 'Hide'; - if (this.SelectedSatelliteTypeVariable === 'Show') { - this.onSatelliteChange(this.SelectedSatelliteTypeVariable, true); - } - - if(this.SelectedBasemapTypeVariable === 'Hide' && this.SelectedSatelliteTypeVariable === 'Hide') { - this.SelectedBasemapTypeVariable = 'Show'; - this.onBasemapChange(this.SelectedBasemapTypeVariable, true); + //Component for basemap + if (this.commonService.session.style.widgets['map-basemap-show']) { + this.onBasemapChange('Show'); + } else if (this.commonService.session.style.widgets['map-satellite-show']) { + this.onSatelliteChange('Show'); + } else { + this.onCountriesShowHidChange('Show'); } //Components|Network|Nodes @@ -1664,10 +1666,6 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.SelectedLinksTypeVariable = this.commonService.session.style.widgets['map-link-show'] ? 'Show' : 'Hide'; this.onMapLinksShowHideChange(this.SelectedLinksTypeVariable); - //Components|Offline|Countries - this.SelectedCountriesTypeVariable = this.commonService.session.style.widgets['map-countries-show'] ? 'Show' : 'Hide'; - this.onCountriesShowHidChange(this.SelectedCountriesTypeVariable); - //Components|Offline|States this.SelectedStatesTypeVariable = this.commonService.session.style.widgets['map-states-show'] ? 'Show' : 'Hide'; this.onStatesShowHideChange(this.SelectedStatesTypeVariable); @@ -1677,8 +1675,8 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.onCountiesShowHideChange(this.SelectedCountiesTypeVariable); //Data|Geospatial - this.SelectedGeospatialTypeVariable = this.commonService.session.style.widgets['map-geospatial-type-on'] ? 'On' : 'Off'; - this.onGeospatialTypeChange(undefined); + //this.SelectedGeospatialTypeVariable = this.commonService.session.style.widgets['map-geospatial-type-on'] ? 'On' : 'Off'; + //this.onGeospatialTypeChange(undefined); //Data|Latitude this.SelectedLatitude = this.commonService.session.style.widgets['map-field-lat']; @@ -1702,13 +1700,13 @@ export class MapComponent extends BaseComponentDirective implements OnInit, Mico this.SelectedCountry = this.commonService.session.style.widgets['map-field-country']; //Data|Country - this.SelectedResidenceAddress = this.commonService.session.style.widgets['map-field-residence-address']; + //this.SelectedResidenceAddress = this.commonService.session.style.widgets['map-field-residence-address']; //Data|Country - this.SelectedVenueAddress = this.commonService.session.style.widgets['map-field-venue-address']; + //this.SelectedVenueAddress = this.commonService.session.style.widgets['map-field-venue-address']; //Data|Country - this.SelectedExposureAddress = this.commonService.session.style.widgets['map-field-exposure-address']; + //this.SelectedExposureAddress = this.commonService.session.style.widgets['map-field-exposure-address']; this.onDataChange(undefined); diff --git a/src/app/visualizationComponents/PhylogeneticComponent/phylogenetic-plugin.component.html b/src/app/visualizationComponents/PhylogeneticComponent/phylogenetic-plugin.component.html index fd99b7a7..67c8a06a 100644 --- a/src/app/visualizationComponents/PhylogeneticComponent/phylogenetic-plugin.component.html +++ b/src/app/visualizationComponents/PhylogeneticComponent/phylogenetic-plugin.component.html @@ -1,5 +1,5 @@ 
-
+
@@ -22,7 +22,7 @@ [positionLeft]="PhylogeneticTreeExportDialogSettings.left" [positionTop]="PhylogeneticTreeExportDialogSettings.top" [(visible)]="PhylogeneticTreeExportDialogSettings.isVisible" - [contentStyle]="{'overflow': 'visible'}" + [contentStyle]="{'overflow': 'visible', 'width': '450px'}" header="Phylogenetic Tree Settings" appendTo="body" > @@ -62,9 +62,9 @@
- +
- +
@@ -81,15 +81,15 @@
-
+
-
+
- +
Show Leaf Tooltips
@@ -97,7 +97,7 @@
-
+
@@ -107,19 +107,33 @@
+
+
Show Leaf Nodes
+
+ +
+
-
+
-
+
-
+
+
+
+
+
+
+
+
+
@@ -131,7 +145,7 @@ - +
@@ -139,9 +153,9 @@
-
@@ -153,13 +167,13 @@
-
-
- +
+
+
@@ -170,42 +184,45 @@
-
@@ -242,11 +242,11 @@

Please add data files to load...

@@ -313,8 +313,11 @@

Please add data files to load...

Groups
- -
+ + +
@@ -369,8 +372,10 @@

Please add data files to load...

Group Color Table
- -
+ +
diff --git a/src/app/visualizationComponents/TwoDComponent/twoD-plugin.component.ts b/src/app/visualizationComponents/TwoDComponent/twoD-plugin.component.ts index 98a91be6..c90dba85 100644 --- a/src/app/visualizationComponents/TwoDComponent/twoD-plugin.component.ts +++ b/src/app/visualizationComponents/TwoDComponent/twoD-plugin.component.ts @@ -21,6 +21,7 @@ import { Subject, Subscription, takeUntil } from 'rxjs'; import * as d3f from 'd3-force'; import { CommonStoreService } from '@app/contactTraceCommonServices/common-store.services'; import { ExportService, ExportOptions } from '@app/contactTraceCommonServices/export.service'; +import { NgZone } from '@angular/core'; @Component({ @@ -249,7 +250,8 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic private clipboard: Clipboard, private gtmService: GoogleTagManagerService, private store: CommonStoreService, - private exportService: ExportService + private exportService: ExportService, + private zone: NgZone ) { super(elRef.nativeElement); @@ -258,8 +260,7 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic this.widgets = this.commonService.session.style.widgets; - - this.container.on('resize', () => { this.fit()}) + this.container.on('resize', () => { setTimeout(() => this.fit(), 200)}) this.container.on('hide', () => { this.viewActive = false; this.cdref.detectChanges(); @@ -347,9 +348,9 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic } ngAfterViewInit(): void { - console.log('--- TwoD ngAfterViewInit called'); - } + + } mapDataToCytoscapeElements(data: any, timelineTick=false): cytoscape.ElementsDefinition { @@ -664,42 +665,43 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic }); this.cy.on('mouseover', 'node', (evt) => { - const node = evt.target; - this.showNodeTooltip(node.data(), evt.originalEvent); - - // Set cursor to grab - $('html,body').css('cursor', 'grab'); - - if (this.widgets['node-highlight']) { - // Highlight connected edges - node.connectedEdges().addClass('highlighted'); - } - + // Run UI updates inside Angular's zone + this.zone.run(() => { + const node = evt.target; + this.showNodeTooltip(node.data(), evt.originalEvent); + $('html,body').css('cursor', 'grab'); + + if (this.widgets['node-highlight']) { + node.connectedEdges().addClass('highlighted'); + } + }); }); this.cy.on('mouseout', 'node', (evt) => { - - const node = evt.target; - - this.hideTooltip(); - - $('html,body').css('cursor', 'default'); - - if (this.widgets['node-highlight']) { - // Remove highlight from connected edges - node.connectedEdges().removeClass('highlighted'); - } - + // Run UI updates inside Angular's zone + this.zone.run(() => { + const node = evt.target; + this.hideTooltip(); + $('html,body').css('cursor', 'default'); + + if (this.widgets['node-highlight']) { + node.connectedEdges().removeClass('highlighted'); + } + }); }); // Edge events this.cy.on('mouseover', 'edge', (evt) => { - const edge = evt.target; - this.showLinkTooltip(edge.data(), evt.originalEvent); + this.zone.run(() => { + const edge = evt.target; + this.showLinkTooltip(edge.data(), evt.originalEvent); + }); }); this.cy.on('mouseout', 'edge', () => { - this.hideTooltip(); + this.zone.run(() => { + this.hideTooltip(); + }); }); this.cy.on('dragfree', 'node', (evt) => { @@ -992,13 +994,19 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic * Updates the saved postion of a node when it is dragged by the user * @param node */ - updateNodePos(node) { - let globalNode = this.commonService.getVisibleNodes().find(x => x._id == node.data('id')) // need to update so it works with grouped nodes/polygons - globalNode['x'] = node.position().x; - globalNode['y'] = node.position().y; + // updateNodePos(node) { + // let globalNode = this.commonService.getVisibleNodes().find(x => x._id == node.data('id')) // need to update so it works with grouped nodes/polygons + // globalNode['x'] = node.position().x; + // globalNode['y'] = node.position().y; - } + // } + updateNodePos(node: cytoscape.NodeSingular): void { + const nodeId = node.id(); + // This is for REAL user events. It reads the now-updated position from Cytoscape. + const newPosition = node.position(); + this.commonService.updateNodePosition(nodeId, newPosition); + } /** Initializes the view. * * Defines the structure of the svg of twoD network and adds functionalities such as click, zoom, forces, etc... @@ -1130,32 +1138,29 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic // }); - // TODO move this to a subscribed event than use document jquery $(document).on("node-selected", function () { - const mtSelectedNodes = that.commonService.getVisibleNodes().filter(n => n.selected); - const mtSelectedNodeIds = mtSelectedNodes.map(n => n._id || n.id); - - // Deselect all nodes first in cytoscape - that.cy.elements().unselect(); - - // Select the nodes that are marked as selected in the common service - if (mtSelectedNodeIds.length > 0) { - const selector = mtSelectedNodeIds.map(id => `#${id}`).join(', '); - that.cy.nodes(selector).select(); - } - + if (!that.cy) return; + + const mtSelectedNodes = that.commonService.getVisibleNodes().filter(n => n.selected); + const mtSelectedNodeIds = mtSelectedNodes.map(n => n._id || n.id); + + // Clear cytoscape selection + that.cy.elements().unselect(); + + // Apply multi-selection if (mtSelectedNodeIds.length > 0) { - that.selectedNodeId = mtSelectedNodeIds[mtSelectedNodeIds.length - 1]; - } else { - that.selectedNodeId = undefined; - } - - if (that.debugMode) { - console.log('node-selected in 2d: ', that.selectedNodeId); - console.log('node-selected in data: ', that.data.nodes.find(node => node.id == that.selectedNodeId)); + const selector = mtSelectedNodeIds.map(id => `#${id}`).join(', '); + that.cy.nodes(selector).select(); + that.selectedNodeId = mtSelectedNodeIds[mtSelectedNodeIds.length - 1]; // keep last-selected for UI logic only + } else { + that.selectedNodeId = undefined; } - }); - + + if (that.debugMode) { + console.log('node-selected in 2d ids: ', mtSelectedNodeIds); + } + }); + if (this.commonService.session.files.length > 1) $('#link-color-variable').val('origin').change(); if (this.widgets['background-color']) $('#cy').css('background-color', this.widgets['background-color']); @@ -3008,6 +3013,167 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic userPanningEnabled: true }); + if ((window as any).Cypress) { +              (window as any).cytoscapeInstance = this.cy; +              +              // Create a dedicated namespace for all test functions +              (window as any).Cypress.test = { +                // Interaction helpers +            dragNodeDelta: (nodeId: string, dx: number, dy: number) => { + return this.zone.run(() => { + const node = this.cy.getElementById(nodeId); + if (!node || node.empty()) { + console.warn('[Cypress.dragNodeDelta] node not found', nodeId); + return null; + } + + if (node.locked && node.locked()) { + node.unlock(); + } + + const current = node.position(); + const newPos = { + x: current.x + dx, + y: current.y + dy + }; + + node.position(newPos); + + // ✅ keep app model in sync, like a real dragfree event + this.updateNodePos(node); + + return newPos; // so the test can assert directly + }); + }, + tooltip: (action: 'show' | 'hide', nodeId: string) => { +                    this.zone.run(() => { +                        const node = this.cy.getElementById(nodeId); +                        if (node) { +                            if (action === 'show') { +                                const mockEvent = { clientX: 100, clientY: 100 }; +                                this.showNodeTooltip(node.data(), mockEvent); +                            } else { +                                this.hideTooltip(); +                            } +                        } +                    }); +                }, +                linkTooltip: (action: 'show' | 'hide', edgeId: string) => { +                    this.zone.run(() => { +                        const edge = this.cy.getElementById(edgeId); +                        if (edge) { +                            if (action === 'show') { +                                const mockEvent = { clientX: 300, clientY: 300 }; +                                this.showLinkTooltip(edge.data(), mockEvent); +                            } else { +                                this.hideTooltip(); +                            } +                        } +                    }); +                }, +    +                // New settings helpers +                setNodeSize: (size: number) => { +                    this.zone.run(() => { +                        this.SelectedNodeRadiusSizeVariable = size; +                        this.onNodeRadiusChange(size); +                    }); +                }, +                setLinkWidth: (width: number) => { +                    this.zone.run(() => { +                        this.SelectedLinkWidthVariable = width; +                        this.onLinkWidthChange(width); +                    }); +                }, +                togglePolygons: (show: boolean) => { +                    this.zone.run(() => this.polygonsToggle(show)); +                }, +                setNodeLabel: (variable: string) => { +                    this.zone.run(() => { +                        this.SelectedNodeLabelVariable = variable; +                        this.onNodeLabelVaribleChange(variable); +                    }); +                }, +                setNodeBorderWidth: (width: number) => { +                    this.zone.run(() => { +                        this.nodeBorderWidth = width; +                        this.onNodeBorderWidthChange(width); +                    }); +                }, +                toggleLinkArrows: (show: boolean) => { +                    this.zone.run(() => { +                        const value = show ? 'Show' : 'Hide'; +                        this.SelectedLinkArrowTypeVariable = value; +                        this.onLinkDirectedUndirectedChange(value); +                    }); +                }, +                toggleGridlines: (show: boolean) => { +                    this.zone.run(() => { +                        const value = show ? 'Show' : 'Hide'; +                        this.SelectedNetworkGridLineTypeVariable = value; +                        this.onNetworkGridlinesShowHideChange(value); +                    }); +                }, +                setNodeLabelSizeAndOrientation: (size: number, orientation: string) => { +                    this.zone.run(() => { +                        this.SelectedNodeLabelSizeVariable = size; +                        this.setNodeLabelSize(size); +                        this.SelectedNodeLabelOrientationVariable = orientation as any; +                        this.onNodeLabelOrientationChange(orientation); +                    }); +                }, +                setNodeSizeByVariable: (variable: string) => { +                    this.zone.run(() => { +                        this.SelectedNodeRadiusVariable = variable; +                        this.onNodeRadiusVariableChange(variable); +                    }); +                }, +                setLinkOpacity: (opacity: number) => { +                    this.zone.run(() => { +                        this.SelectedLinkTransparencyVariable = opacity; +                        this.onLinkOpacityChange(opacity); +                    }); +                }, +                toggleGroupLabels: (show: boolean) => { +                    this.zone.run(() => { +                        this.widgets['polygons-label-show'] = show; +                        this.onPolygonLabelShowChange(show); +                    }); +                }, +                setLinkWidthByVariable: (variable: string) => { +                    this.zone.run(() => { +                        this.SelectedLinkWidthByVariable = variable; +                        this.onLinkWidthVariableChange(variable); +                    }); +                }, +                setLinkLength: (length: number) => { +                    this.zone.run(() => { +                        this.SelectedLinkLengthVariable = length; +                        this.onLinkLengthChange(length); +                    }); +                }, +                toggleNeighborHighlighting: (highlight: boolean) => { +                    this.zone.run(() => { +                        const value = highlight ? 'Highlighted' : 'Normal'; +                        this.SelectedNetworkNeighborTypeVariable = value; +                        this.onDontHighlightNeighborsHighlightNeighborsChange(value); +                    }); +                }, +                setGroupByVariable: (variable: string) => { +                    this.zone.run(() => { +                        this.centerPolygons(variable); +                    }); +                }, +                setGroupLabelSizeAndOrientation: (size: number, orientation: string) => { +                    this.zone.run(() => { +                        this.SelectedPolygonLabelSizeVariable = size; +                        this.onPolygonLabelSizeChange(size); +                        this.SelectedPolygonLabelOrientationVariable = orientation as any; +                        this.onPolygonLabelOrientationChange(orientation); +                    }); +                } +              }; + } // Attach events this.attachCytoscapeEvents(); @@ -3372,8 +3538,6 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic this.widgets['link-width-max'] = e; this.updateMinMaxLink(); this.scaleLinkWidth(); - - } /** @@ -3399,60 +3563,77 @@ export class TwoDComponent extends BaseComponentDirective implements OnInit, Mic this.updateLayout(); } - /** -     * Applies arrow styling to edges based on current widget settings and edge data. -     * Arrows are shown only for links that have distance and its within the threshold -     */ - private updateArrowStyles() { - if (!this.cy) return; - - this.cy.style() - .selector('edge') - .style({ - 'target-arrow-shape': (ele) => { - const data = ele.data(); - console.log('data: ', data, 'has distance', data.hasDistance, 'origin', data.origin) - if (this.widgets['link-directed'] && (!data.hasDistance || (data.origin[0] !== data.distanceOrigin ))) { - return 'triangle'; - } - return 'none'; - }, - 'source-arrow-shape': (ele) => { - const data = ele.data(); - if (this.widgets['link-directed'] && (!data.hasDistance || (data.origin[0] !== data.distanceOrigin ))) { - return 'triangle'; - } - return 'none'; - }, - 'curve-style': this.widgets['link-directed'] ? 'unbundled-bezier' : 'straight' - }) - .update(); - } + /** + * Applies arrow styling to edges based on: + * - Global arrow toggle (widgets['link-directed']) + * - Per-edge directionality (edge.data().directed) + * - Optional bidirectional toggle + per-edge flag (widgets['link-bidirectional'] + edge.data().bidirectional) + */ +private updateArrowStyles(): void { + if (!this.cy) return; + + const isTruthy = (v: any): boolean => { + if (v === true) return true; + if (v === false || v === null || v === undefined) return false; + if (typeof v === 'number') return v !== 0; + if (typeof v === 'string') { + const s = v.trim().toLowerCase(); + return s === 'true' || s === '1' || s === 'yes' || s === 'y'; + } + return false; + }; + + const shouldShowDirected = (data: any): boolean => { + if (!this.widgets['link-directed']) return false; + return isTruthy(data?.directed); + }; + + const shouldShowSource = (data: any): boolean => { + if (!shouldShowDirected(data)) return false; + if (!this.widgets['link-bidirectional']) return false; + return isTruthy(data?.bidirectional); + }; + + this.cy.style() + .selector('edge') + .style({ + 'target-arrow-shape': (ele) => { + const data = ele.data(); + return shouldShowDirected(data) ? 'triangle' : 'none'; + }, + 'source-arrow-shape': (ele) => { + const data = ele.data(); + return shouldShowSource(data) ? 'triangle' : 'none'; + }, + 'target-arrow-color': 'data(lineColor)', + 'source-arrow-color': 'data(lineColor)', + 'curve-style': this.widgets['link-directed'] ? 'unbundled-bezier' : 'straight' + }) + .update(); + } /** * Updates link-directed widget. When directed, links have an arrow added; when undirected, links have no arrow */ - onLinkDirectedUndirectedChange(e) { + onLinkDirectedUndirectedChange(e: string) { if (e === "Show") { - $('#link-bidirectional-row').slideDown().css('display', 'flex'); - this.widgets['link-directed'] = true; + $('#link-bidirectional-row').slideDown().css('display', 'flex'); + this.widgets['link-directed'] = true; } else { - this.widgets['link-directed'] = false; - $("#link-bidirectional-row").slideUp(); + this.widgets['link-directed'] = false; + $("#link-bidirectional-row").slideUp(); } - + this.updateArrowStyles(); - } + } - onLinkBidirectionalChange(e) { - // Update the widget state + onLinkBidirectionalChange(e: string) { this.widgets['link-bidirectional'] = (e === "Show"); - this.updateArrowStyles(); - } + } /** * Updates node-highlight widget. When true and a node is mouseoved current node, all it of links, and neighbor nodes will be highlighted @@ -3664,17 +3845,17 @@ scaleLinkWidth() { dataValue = 0; } if (this.isNumber(dataValue)) { - const scaledWidth = this.linearScale(dataValue, min, max, minWidth, maxWidth, reciprocal); - edge.data('scaledWidth', scaledWidth); + const width = this.linearScale(dataValue, min, max, minWidth, maxWidth, reciprocal); + edge.data('width', width); } else { // Handle non-numeric values if necessary - edge.data('scaledWidth', minWidth); + edge.data('width', minWidth); } }); // Update Cytoscape stylesheet to use the scaledWidth data this.cy.style().selector('edge').style({ - 'width': 'data(scaledWidth)' + 'width': 'data(width)' }).update(); } /** @@ -4109,10 +4290,14 @@ private async _partialUpdate() { this.SelectedLinkLengthVariable = this.widgets['link-length']; this.onLinkLengthChange(this.SelectedLinkLengthVariable); - //Links|Arrows + //Links|Arrows this.SelectedLinkArrowTypeVariable = this.widgets['link-directed'] ? "Show" : "Hide"; this.onLinkDirectedUndirectedChange(this.SelectedLinkArrowTypeVariable); + //Links|Bidirectional + this.SelectedLinkBidirectionalTypeVariable = this.widgets['link-bidirectional'] ? "Show" : "Hide"; + this.onLinkBidirectionalChange(this.SelectedLinkBidirectionalTypeVariable); + //Network|Neighbors this.SelectedNetworkNeighborTypeVariable = this.widgets['node-highlight'] ? "Highlighted" : "Normal"; diff --git a/src/app/visualizationComponents/WaterfallComponent/waterfall.component.html b/src/app/visualizationComponents/WaterfallComponent/waterfall.component.html index 6d595f4d..6d485a76 100644 --- a/src/app/visualizationComponents/WaterfallComponent/waterfall.component.html +++ b/src/app/visualizationComponents/WaterfallComponent/waterfall.component.html @@ -12,7 +12,7 @@ [(selection)]="selectedClusterRow" [scrollable]="true" [scrollHeight]="scrollHeight" - [tableStyle]="{'border': '3px #e9ecef solid'}"> + [tableStyle]="{'border': '3px #e9ecef solid', 'overflow-x': 'visible'}"> Cluster @@ -44,7 +44,7 @@ [(selection)]="selectedNodeRow" [scrollable]="true" [scrollHeight]="scrollHeight" - [tableStyle]="{'border': '3px #e9ecef solid'}"> + [tableStyle]="{'border': '3px #e9ecef solid', 'overflow-x': 'visible'}"> Nodes @@ -76,7 +76,7 @@ [(selection)]="selectedLinkRow" [scrollable]="true" [scrollHeight]="scrollHeight" - [tableStyle]="{'border': '3px #e9ecef solid'}"> + [tableStyle]="{'border': '3px #e9ecef solid', 'overflow-x': 'visible'}"> Links diff --git a/src/app/visualizationComponents/WaterfallComponent/waterfall.component.scss b/src/app/visualizationComponents/WaterfallComponent/waterfall.component.scss index 962e1911..8adfb7a8 100644 --- a/src/app/visualizationComponents/WaterfallComponent/waterfall.component.scss +++ b/src/app/visualizationComponents/WaterfallComponent/waterfall.component.scss @@ -4,18 +4,25 @@ z-index: 1 !important; } +tr td:first-child, tr th:first-child { + padding-right: 0 !important; +} + +tr td:nth-child(2), tr th:nth-child(2) { + padding-left: 0 !important; +} + .waterfall-wrapper { padding: 40px 20px 10px 20px; } .rowExpansionContent { background-color: #E3F2FD; - padding: 0px 0px 16px 16px; + padding: 0px 12px 16px 16px; + overflow: auto; } .rowExpansionContent div { - overflow: hidden; white-space: nowrap; - text-overflow: ellipsis; display: block; } \ No newline at end of file diff --git a/src/app/visualizationComponents/WaterfallComponent/waterfall.component.ts b/src/app/visualizationComponents/WaterfallComponent/waterfall.component.ts index 3f867643..316c1aba 100644 --- a/src/app/visualizationComponents/WaterfallComponent/waterfall.component.ts +++ b/src/app/visualizationComponents/WaterfallComponent/waterfall.component.ts @@ -99,12 +99,15 @@ export class WaterfallComponent extends BaseComponentDirective implements OnInit } goldenLayoutComponentResize() { + this.clusterTableWidth = this.nodeTableWidth = this.linkTableWidth = 0; + this.cdref.detectChanges(); this.clusterTableWidth = (this.clusterTable as any)._totalTableWidth().reduce((total, current ) => total += current, 0) - 28; this.nodeTableWidth = (this.nodeTable as any)._totalTableWidth().reduce((total, current ) => total += current, 0) - 28; this.linkTableWidth = (this.linkTable as any)._totalTableWidth().reduce((total, current ) => total += current, 0) - 28; let height = this.container.height - 50; this.scrollHeight = `${height}px` + this.cdref.detectChanges(); } onClusterRowSelect(e) { @@ -125,7 +128,8 @@ export class WaterfallComponent extends BaseComponentDirective implements OnInit this.expandedClusterRowData = []; Object.keys(cluster).filter(k => !(this.metaDataToSkip.includes(k) || k.charAt(0) == '_' || typeof cluster[k] == 'object')).forEach(k => { let prop = this.commonService.titleize(k) - this.expandedClusterRowData.push({'key': prop, 'value': cluster[k]}); + let value = k == 'mean_genetic_distance' || k == 'links_per_node' ? cluster[k].toFixed(3) : cluster[k] + this.expandedClusterRowData.push({'key': prop, 'value': value}); }) this.selectedNodeRow = null; diff --git a/src/assets/common/data/zipcodes.csv b/src/assets/common/data/zipcodes.csv index 5fe2ef40..caa1d6da 100644 --- a/src/assets/common/data/zipcodes.csv +++ b/src/assets/common/data/zipcodes.csv @@ -361,6 +361,7 @@ zipcode,_lat,_lon 01430,42.654906,-71.920942 01431,42.446396,-71.459405 01432,42.446396,-71.459405 +01434,42.53206,-71.61374 01436,42.601427,-72.083838 01438,42.551681,-72.029434 01440,42.582529,-72.025884 @@ -1103,6 +1104,7 @@ zipcode,_lat,_lon 03281,43.084176,-71.762578 03282,43.967542,-71.840883 03284,43.493812,-72.047018 +03285,43.947877,-71.635785 03287,43.44853,-71.915826 03289,43.496372,-71.519728 03290,43.124825,-71.125879 @@ -1156,11 +1158,13 @@ zipcode,_lat,_lon 03583,44.695648,-71.387387 03584,44.476575,-71.561225 03585,44.245004,-71.888882 +03586,44.21841,-71.80024 03587,44.695648,-71.387387 03588,44.56532,-71.218672 03589,44.695648,-71.387387 03590,44.695648,-71.387387 03592,44.695648,-71.387387 +03593,44.301396,-71.299834 03595,44.26895,-71.547061 03597,44.695648,-71.387387 03598,44.363681,-71.610189 @@ -1220,6 +1224,7 @@ zipcode,_lat,_lon 03820,43.297309,-70.992042 03821,43.326734,-71.028427 03822,43.326734,-71.028427 +03823,43.174607,-70.941453 03824,43.165772,-70.962843 03825,43.29779,-71.097423 03826,42.893629,-71.14269 @@ -1253,6 +1258,7 @@ zipcode,_lat,_lon 03858,42.937092,-71.006898 03859,42.861915,-71.04002 03860,43.784643,-71.10263 +03861,43.119202,-71.007082 03862,43.00027,-70.913947 03864,43.667352,-71.153338 03865,42.937838,-70.926206 @@ -1897,6 +1903,7 @@ zipcode,_lat,_lon 05405,44.442117,-73.082525 05406,44.442117,-73.082525 05407,44.442117,-73.082525 +05408,44.505238,-73.272419 05439,44.49518,-73.165092 05440,44.93606,-73.289065 05441,44.836967,-72.92169 @@ -2121,6 +2128,7 @@ zipcode,_lat,_lon 06039,41.951917,-73.38138 06040,41.776048,-72.523748 06041,41.794681,-72.564832 +06042,41.802645,-72.521039 06043,41.768648,-72.439278 06045,41.791776,-72.718832 06049,41.791776,-72.718832 @@ -2269,6 +2277,7 @@ zipcode,_lat,_lon 06335,41.523377,-72.021165 06336,41.579548,-72.196273 06337,41.559873,-71.889199 +06338,41.464584,-71.972828 06339,41.492843,-71.965554 06340,41.355405,-72.038268 06349,41.39973,-72.090357 @@ -2343,6 +2352,7 @@ zipcode,_lat,_lon 06457,41.550139,-72.655357 06459,41.556463,-72.658179 06460,41.343773,-72.951273 +06461,41.239865,-73.075394 06467,41.565697,-72.903746 06468,41.341845,-73.236918 06469,41.508904,-72.440086 @@ -2479,6 +2489,8 @@ zipcode,_lat,_lon 06816,41.308873,-73.363661 06817,41.308873,-73.363661 06820,41.075846,-73.480765 +06824,41.173039,-73.280818 +06825,41.196583,-73.243254 06829,41.25553,-73.427915 06830,41.042746,-73.62617 06831,41.079983,-73.654472 @@ -2508,6 +2520,7 @@ zipcode,_lat,_lon 06883,41.222945,-73.376263 06888,41.308873,-73.363661 06889,41.141005,-73.34689 +06890,41.148565,-73.28778 06896,41.271095,-73.38634 06897,41.209695,-73.439165 06901,41.054082,-73.536216 @@ -3632,8 +3645,10 @@ zipcode,_lat,_lon 10048,40.71254,-74.013289 10055,40.780751,-73.977182 10060,40.780751,-73.977182 +10065,40.764689,-73.963264 10069,40.777952,-73.988381 10072,40.780751,-73.977182 +10075,40.773413,-73.956291 10079,40.780751,-73.977182 10080,40.780751,-73.977182 10081,40.780751,-73.977182 @@ -6844,6 +6859,7 @@ zipcode,_lat,_lon 17012,40.136687,-77.242805 17013,40.168495,-77.228817 17014,40.478716,-77.345514 +17015,40.183404,-77.232115 17016,40.275536,-76.405309 17017,40.894363,-76.596151 17018,40.361876,-76.895539 @@ -6951,6 +6967,7 @@ zipcode,_lat,_lon 17140,40.30864,-76.846449 17177,40.298988,-76.847194 17201,39.908055,-77.666445 +17202,39.923181,-77.690468 17210,40.171667,-77.661354 17211,39.755155,-78.406388 17212,39.943762,-78.122265 @@ -7067,6 +7084,7 @@ zipcode,_lat,_lon 17405,40.008647,-76.597187 17406,40.004593,-76.594727 17407,39.897907,-76.662569 +17408,39.93282,-76.799214 17415,39.972985,-76.687826 17501,40.129894,-76.361053 17502,40.088469,-76.462434 @@ -7419,6 +7437,7 @@ zipcode,_lat,_lon 18255,40.911443,-75.779007 18256,40.944777,-76.145197 18301,41.089642,-75.199705 +18302,41.096574,-75.111116 18320,41.071213,-75.236436 18321,41.079679,-75.319542 18322,41.054711,-75.331879 @@ -7636,6 +7655,7 @@ zipcode,_lat,_lon 18853,41.668617,-76.265169 18854,41.77197,-76.521266 18901,40.334863,-75.118737 +18902,40.353296,-75.097808 18910,40.328645,-75.10278 18911,40.328645,-75.10278 18912,40.309942,-75.074252 @@ -7748,6 +7768,7 @@ zipcode,_lat,_lon 19057,40.143309,-74.846373 19058,40.328645,-75.10278 19059,40.328645,-75.10278 +19060,39.850699,-75.491965 19061,39.85091,-75.418228 19063,39.918804,-75.399118 19064,39.931858,-75.341583 @@ -8883,6 +8904,7 @@ zipcode,_lat,_lon 21403,39.007361,-76.584637 21404,38.974203,-76.594942 21405,38.992124,-76.506883 +21409,39.018435,-76.442533 21411,38.974203,-76.594942 21412,38.974203,-76.594942 21501,39.580691,-78.690593 @@ -9120,6 +9142,7 @@ zipcode,_lat,_lon 22003,38.835762,-77.212794 22009,38.831813,-77.288755 22015,38.785864,-77.286156 +22025,38.591896,-77.349497 22026,38.584734,-77.349935 22027,38.895078,-77.221453 22030,38.853231,-77.305097 @@ -9307,10 +9330,12 @@ zipcode,_lat,_lon 22546,37.948572,-77.437767 22547,38.271077,-77.17261 22548,37.837583,-76.694775 +22551,38.187032,-77.700356 22552,38.009438,-77.225139 22553,38.182869,-77.69932 22554,38.438958,-77.4354 22555,38.417273,-77.460814 +22556,38.488667,-77.515136 22558,38.121793,-76.79025 22560,37.916613,-76.947547 22565,38.137216,-77.518865 @@ -9731,6 +9756,7 @@ zipcode,_lat,_lon 23450,36.844004,-76.12036 23451,36.856348,-76.053568 23452,36.846147,-76.097355 +23453,36.78349,-76.071207 23454,36.828586,-76.070772 23455,36.888865,-76.146757 23456,36.746599,-76.039092 @@ -10633,6 +10659,9 @@ zipcode,_lat,_lon 25396,38.296818,-81.554655 25401,39.444061,-77.951924 25402,39.461663,-78.011472 +25403,39.47485,-78.01164 +25404,39.489919,-77.896363 +25405,39.408919,-77.962368 25410,39.315914,-77.877223 25411,39.552557,-78.18773 25413,39.377876,-78.064925 @@ -11328,6 +11357,7 @@ zipcode,_lat,_lon 27263,35.935894,-79.93955 27264,36.080707,-80.0244 27265,36.029892,-79.991542 +27268,35.971402,-79.994698 27278,36.077432,-79.085469 27281,35.186814,-79.561566 27282,35.996926,-79.926902 @@ -11437,9 +11467,11 @@ zipcode,_lat,_lon 27520,35.633257,-78.435416 27521,35.425247,-78.656553 27522,36.108089,-78.671974 +27523,35.773618,-78.956926 27524,35.4282,-78.339839 27525,36.068066,-78.399881 27526,35.758691,-78.646886 +27527,35.653948,-78.381715 27529,35.714139,-78.66304 27530,35.368277,-78.092871 27531,35.463121,-77.995728 @@ -11448,6 +11480,7 @@ zipcode,_lat,_lon 27534,35.385571,-78.03207 27536,36.38698,-78.396213 27537,0,0 +27539,35.676533,-78.813447 27540,35.607666,-78.829724 27541,36.314975,-79.06404 27542,35.571141,-78.287178 @@ -11474,6 +11507,7 @@ zipcode,_lat,_lon 27571,35.906468,-78.45482 27572,36.205828,-78.878578 27573,36.39165,-78.950937 +27574,36.475265,-78.842101 27576,35.563572,-78.244459 27577,35.536543,-78.336001 27581,36.209675,-78.72704 @@ -11565,6 +11599,7 @@ zipcode,_lat,_lon 27812,35.757803,-77.39351 27813,35.616471,-77.935161 27814,35.500693,-76.977521 +27815,35.924689,-77.693027 27816,36.09786,-78.03876 27817,35.460458,-77.063047 27818,36.491011,-77.031055 @@ -11903,6 +11938,7 @@ zipcode,_lat,_lon 28309,35.039726,-78.842868 28310,35.050612,-78.80384 28311,35.156447,-78.912281 +28312,34.947752,-78.738133 28314,35.05425,-79.011328 28315,35.203802,-79.517795 28318,35.066726,-78.590479 @@ -12260,6 +12296,7 @@ zipcode,_lat,_lon 28756,35.336371,-82.158975 28757,35.641473,-82.315637 28758,35.371065,-82.49375 +28759,35.38135,-82.588899 28760,35.381677,-82.481257 28761,35.669058,-81.906612 28762,35.616257,-82.148319 @@ -12573,6 +12610,7 @@ zipcode,_lat,_lon 29483,33.040201,-80.431751 29484,33.00234,-80.226694 29485,32.999726,-80.329328 +29486,33.103211,-80.166653 29487,32.659087,-80.167357 29488,32.925196,-80.703213 29492,32.96678,-79.852835 @@ -12738,6 +12776,7 @@ zipcode,_lat,_lon 29703,34.992612,-81.178712 29704,34.859604,-80.938257 29706,34.693285,-81.168022 +29707,34.987552,-80.858188 29708,35.050243,-80.990828 29709,34.755564,-80.129515 29710,35.035952,-81.165152 @@ -12815,6 +12854,8 @@ zipcode,_lat,_lon 29904,32.390605,-80.661027 29905,32.340119,-80.689041 29906,32.382327,-80.760332 +29907,32.474692,-80.599222 +29909,32.336992,-80.848074 29910,32.34969,-80.899506 29911,32.885698,-81.206373 29912,32.488929,-80.989142 @@ -13134,6 +13175,7 @@ zipcode,_lat,_lon 30360,33.931069,-84.277772 30361,33.844371,-84.47405 30362,33.891251,-84.07456 +30363,33.791478,-84.398892 30364,33.844371,-84.47405 30366,33.891251,-84.07456 30368,33.844371,-84.47405 @@ -13237,6 +13279,7 @@ zipcode,_lat,_lon 30533,34.541371,-84.024387 30534,34.453661,-84.155043 30535,34.631639,-83.569657 +30536,34.652002,-84.359442 30537,34.97,-83.357507 30538,34.53512,-83.258748 30539,34.658482,-84.493207 @@ -13632,6 +13675,7 @@ zipcode,_lat,_lon 31558,30.844019,-81.630984 31560,31.512923,-82.010258 31561,31.198914,-81.332211 +31562,30.47534,-82.103897 31563,31.731163,-82.194912 31564,31.018954,-82.416543 31565,31.069415,-81.633658 @@ -13693,7 +13737,9 @@ zipcode,_lat,_lon 31716,31.358861,-84.100301 31717,30.888734,-84.617836 31718,30.901863,-84.570049 +31719,32.090308,-84.310747 31720,30.856633,-83.526479 +31721,31.52526,-84.301465 31722,31.080682,-83.649138 31723,31.346088,-84.901178 31724,31.557533,-84.854212 @@ -13757,6 +13803,7 @@ zipcode,_lat,_lon 31785,31.689973,-84.32748 31786,31.760361,-84.614914 31787,31.772073,-84.222541 +31788,31.111533,-83.683892 31789,31.481811,-83.727288 31790,31.652867,-83.578336 31791,31.603336,-83.850054 @@ -13821,6 +13868,7 @@ zipcode,_lat,_lon 32013,30.041449,-83.123055 32024,30.105451,-82.68778 32025,30.160115,-82.639606 +32026,30.059065,-82.190472 32030,30.105553,-81.768964 32033,29.813208,-81.468724 32034,30.60778,-81.682889 @@ -13854,6 +13902,7 @@ zipcode,_lat,_lon 32073,30.119884,-81.791546 32079,29.984882,-81.802221 32080,0,0 +32081,30.119606,-81.426613 32082,30.102212,-81.382302 32083,30.054956,-82.213361 32084,29.849505,-81.332552 @@ -13912,6 +13961,7 @@ zipcode,_lat,_lon 32159,28.923468,-81.894367 32160,29.768321,-81.990729 32162,0,0 +32163,28.836798,-81.959093 32164,29.486141,-81.204491 32168,28.951931,-81.033705 32169,29.131714,-81.133519 @@ -14251,6 +14301,7 @@ zipcode,_lat,_lon 32720,29.07198,-81.403355 32721,28.997288,-81.299521 32722,29.022729,-81.172169 +32723,29.034536,-81.304522 32724,29.056227,-81.096461 32725,28.900274,-81.245074 32726,28.710129,-81.683696 @@ -14690,6 +14741,7 @@ zipcode,_lat,_lon 33446,26.454017,-80.181862 33447,26.645895,-80.430269 33448,26.645895,-80.430269 +33449,26.592718,-80.233877 33454,26.645895,-80.430269 33455,27.050934,-80.158594 33458,26.645895,-80.430269 @@ -14706,6 +14758,8 @@ zipcode,_lat,_lon 33469,26.645895,-80.430269 33470,26.649816,-80.294771 33471,26.886471,-81.195575 +33472,26.539753,-80.18903 +33473,26.503291,-80.192245 33474,26.645895,-80.430269 33475,27.110182,-80.454196 33476,26.623067,-80.17864 @@ -14744,8 +14798,10 @@ zipcode,_lat,_lon 33539,28.21305,-82.16568 33540,28.240942,-82.156491 33541,28.240543,-82.446251 +33542,28.23578,-82.177617 33543,28.20592,-82.306326 33544,28.271989,-82.284738 +33545,28.268312,-82.291154 33547,27.893718,-82.205331 33548,27.871964,-82.438841 33549,28.060825,-82.391666 @@ -14753,6 +14809,7 @@ zipcode,_lat,_lon 33556,28.128688,-82.584113 33558,0,0 33559,0,0 +33563,28.017072,-82.125766 33564,28.029627,-82.134741 33565,28.082724,-82.156607 33566,28.008056,-82.341905 @@ -14765,6 +14822,8 @@ zipcode,_lat,_lon 33573,27.704046,-82.35742 33574,28.334752,-82.269323 33576,28.331729,-82.300982 +33578,27.861107,-82.35506 +33579,27.798165,-82.280665 33583,27.871964,-82.438841 33584,27.999687,-82.287957 33585,28.735643,-82.061556 @@ -14774,6 +14833,7 @@ zipcode,_lat,_lon 33593,28.324796,-82.481766 33594,27.937779,-82.347371 33595,27.871964,-82.438841 +33596,27.8872,-82.225852 33597,28.647306,-82.108078 33598,27.73383,-82.297468 33601,27.996097,-82.582035 @@ -14908,6 +14968,7 @@ zipcode,_lat,_lon 33809,28.176194,-81.959132 33810,28.147923,-82.037153 33811,27.986538,-82.013855 +33812,27.97104,-81.894289 33813,27.963896,-81.917604 33815,28.049648,-82.006855 33820,28.002553,-81.61864 @@ -15013,10 +15074,15 @@ zipcode,_lat,_lon 33957,26.458308,-82.100065 33960,27.120281,-81.390945 33965,26.552895,-81.94861 +33966,26.581491,-81.834968 +33967,26.471507,-81.81224 33970,26.564718,-81.620778 33971,26.589408,-81.670757 33972,26.641661,-81.913575 +33973,26.600661,-81.730435 +33974,26.558935,-81.601239 33975,26.763312,-81.438833 +33976,26.591277,-81.68613 33980,26.986122,-82.055747 33981,26.93457,-82.232398 33982,26.959685,-81.819036 @@ -15159,6 +15225,7 @@ zipcode,_lat,_lon 34287,27.189487,-82.334882 34288,0,0 34289,0,0 +34291,27.11647,-82.215206 34292,27.090034,-82.370028 34293,27.060576,-82.352038 34295,27.085985,-82.438918 @@ -15222,6 +15289,8 @@ zipcode,_lat,_lon 34613,28.604951,-82.531987 34614,28.627958,-82.536465 34636,28.65503,-82.267706 +34637,28.307793,-82.464927 +34638,28.271944,-82.527429 34639,28.250774,-82.46263 34652,28.239369,-82.736882 34653,28.242508,-82.695536 @@ -15254,6 +15323,8 @@ zipcode,_lat,_lon 34711,28.584025,-81.779423 34712,28.811078,-81.653642 34713,28.811078,-81.653642 +34714,28.399468,-81.812869 +34715,28.631041,-81.726074 34729,28.811078,-81.653642 34731,28.863361,-81.905624 34734,28.538407,-81.520774 @@ -15923,6 +15994,7 @@ zipcode,_lat,_lon 36376,31.252306,-85.264387 36401,31.489241,-87.052004 36420,31.304166,-86.386398 +36421,31.328718,-86.508335 36425,31.56779,-87.250028 36426,31.129427,-87.096126 36427,31.091784,-87.26404 @@ -16646,6 +16718,7 @@ zipcode,_lat,_lon 37931,35.976167,-84.125653 37932,35.933487,-84.148074 37933,35.990142,-83.96218 +37934,35.87618,-84.180016 37938,36.116665,-83.935206 37939,35.990142,-83.96218 37940,35.990142,-83.96218 @@ -17513,6 +17586,37 @@ zipcode,_lat,_lon 39772,33.321036,-89.271149 39773,33.621135,-88.609136 39776,33.804808,-89.060746 +39813,31.423156,-84.684305 +39815,30.738835,-84.490657 +39817,30.943547,-84.601954 +39819,30.785401,-84.645153 +39823,31.333568,-84.947033 +39824,31.528358,-84.864795 +39825,30.930767,-84.740763 +39826,31.818496,-84.321144 +39827,30.947615,-84.210378 +39828,30.79859,-84.226723 +39832,31.19106,-85.027892 +39834,30.894291,-84.431155 +39836,31.666007,-84.868633 +39837,31.152104,-84.677706 +39840,31.7813,-84.764124 +39841,31.292866,-84.685044 +39842,31.754312,-84.435527 +39845,30.95145,-84.892724 +39846,31.568957,-84.746001 +39851,31.619831,-84.992583 +39854,31.869218,-85.052557 +39859,30.987638,-84.812759 +39861,31.13535,-84.987248 +39862,31.459371,-84.517381 +39866,31.56093,-84.603184 +39867,31.842843,-84.93075 +39870,31.322028,-84.414137 +39877,31.915159,-84.511576 +39885,31.721896,-84.343026 +39886,31.732531,-84.617228 +39897,30.911205,-84.329813 39901,33.891251,-84.07456 40003,38.274456,-85.090374 40004,37.822585,-85.466944 @@ -20018,6 +20122,7 @@ zipcode,_lat,_lon 46034,40.154903,-86.038337 46035,40.211041,-86.64787 46036,40.27843,-85.719657 +46037,39.962809,-85.943916 46038,39.967406,-85.964894 46039,40.373825,-86.309246 46040,39.894912,-85.792762 @@ -20037,6 +20142,7 @@ zipcode,_lat,_lon 46058,40.359433,-86.628659 46060,40.073328,-85.999521 46061,40.072462,-86.052285 +46062,40.061285,-86.055943 46063,40.271524,-85.72808 46064,40.107304,-85.757678 46065,40.360973,-86.603449 @@ -21014,6 +21120,7 @@ zipcode,_lat,_lon 48028,42.597245,-82.596757 48030,42.496485,-83.098474 48032,43.12226,-82.599804 +48033,42.459322,-83.293205 48034,42.478495,-83.279164 48035,42.551185,-82.91672 48036,42.593834,-82.913321 @@ -21127,6 +21234,7 @@ zipcode,_lat,_lon 48165,42.498145,-83.608727 48166,41.921912,-83.330583 48167,42.41729,-83.432434 +48168,42.405262,-83.540498 48169,42.467503,-83.946982 48170,42.366737,-83.489679 48173,42.112182,-83.272588 @@ -21148,6 +21256,7 @@ zipcode,_lat,_lon 48190,42.124398,-83.594567 48191,42.129589,-83.569965 48192,42.19499,-83.206572 +48193,42.174019,-83.21085 48195,42.257801,-83.285939 48197,42.202139,-83.620494 48198,42.309687,-83.772991 @@ -21394,6 +21503,7 @@ zipcode,_lat,_lon 48635,44.377795,-84.072974 48636,44.622852,-84.14818 48637,43.389643,-84.309397 +48638,43.418925,-84.018242 48640,43.626132,-84.33803 48641,43.538252,-84.387753 48642,43.68698,-84.280136 @@ -21521,6 +21631,7 @@ zipcode,_lat,_lon 48852,43.350251,-85.051692 48853,43.099153,-84.68977 48854,42.574335,-84.460273 +48855,42.681274,-83.8972 48856,43.197902,-84.730738 48857,42.844288,-84.136097 48858,43.636855,-84.807511 @@ -21621,6 +21732,7 @@ zipcode,_lat,_lon 49034,42.226193,-85.363194 49035,42.595121,-85.308555 49036,41.905358,-85.058716 +49037,42.334561,-85.249172 49038,42.147551,-86.365588 49039,42.224757,-86.372276 49040,41.977796,-85.351074 @@ -21885,9 +21997,11 @@ zipcode,_lat,_lon 49515,43.031413,-85.550267 49516,43.031413,-85.550267 49518,43.031413,-85.550267 +49519,42.895765,-85.71951 49523,43.031413,-85.550267 49525,43.013527,-85.602729 49530,43.031413,-85.550267 +49534,42.964438,-85.787181 49544,43.007274,-85.725535 49546,42.930146,-85.53904 49548,42.864793,-85.615175 @@ -22177,6 +22291,7 @@ zipcode,_lat,_lon 50020,41.390677,-94.813882 50021,41.756321,-93.601467 50022,41.381871,-94.960765 +50023,41.726631,-93.630839 50025,41.704535,-94.918652 50026,41.827251,-94.449511 50027,41.46974,-92.487177 @@ -22387,6 +22502,7 @@ zipcode,_lat,_lon 50321,41.546945,-93.659668 50322,41.630449,-93.753628 50323,41.62938,-93.771676 +50324,41.604709,-93.712724 50325,41.607588,-93.744905 50327,0,0 50328,41.672687,-93.572173 @@ -23478,6 +23594,7 @@ zipcode,_lat,_lon 53545,42.710981,-89.112201 53546,42.663574,-88.947859 53547,42.729359,-89.030111 +53548,42.689322,-89.131287 53549,42.993502,-88.759793 53550,42.564434,-89.507906 53551,43.080902,-88.913251 @@ -23833,6 +23950,7 @@ zipcode,_lat,_lon 54479,44.805167,-90.141112 54480,45.19405,-90.302783 54481,44.551808,-89.531871 +54482,44.550416,-89.509449 54484,44.809072,-90.030674 54485,45.396466,-89.217933 54486,44.75984,-89.039052 @@ -24247,6 +24365,7 @@ zipcode,_lat,_lon 55127,45.080265,-93.08752 55128,44.991316,-92.948738 55129,44.898516,-92.92301 +55130,44.973302,-93.08241 55133,45.005902,-93.105869 55144,45.005902,-93.105869 55145,45.005902,-93.105869 @@ -26532,6 +26651,7 @@ zipcode,_lat,_lon 60121,42.04133,-88.3126 60122,42.067101,-88.304994 60123,42.036325,-88.371044 +60124,42.020169,-88.400686 60125,41.839679,-88.088716 60126,41.88353,-87.946413 60128,41.839679,-88.088716 @@ -26571,6 +26691,7 @@ zipcode,_lat,_lon 60164,41.92138,-87.892412 60165,41.90743,-87.878011 60168,41.811929,-87.68732 +60169,42.05087,-88.116615 60170,42.025776,-88.425931 60171,41.923168,-87.83931 60172,41.839679,-88.088716 @@ -26614,6 +26735,8 @@ zipcode,_lat,_lon 60399,0,0 60401,41.356872,-87.626723 60402,41.811929,-87.68732 +60403,41.568188,-88.118873 +60404,41.513454,-88.224146 60406,41.811929,-87.68732 60407,41.238676,-88.278834 60408,41.285878,-88.017171 @@ -26624,6 +26747,7 @@ zipcode,_lat,_lon 60415,41.811929,-87.68732 60416,41.284033,-88.374819 60417,41.426684,-87.621223 +60418,41.645598,-87.740078 60419,41.811929,-87.68732 60420,41.059551,-88.417086 60421,41.44288,-88.090588 @@ -26632,6 +26756,7 @@ zipcode,_lat,_lon 60424,41.1775,-88.338018 60425,41.811929,-87.68732 60426,41.811929,-87.68732 +60428,41.59981,-87.690617 60429,41.811929,-87.68732 60430,41.811929,-87.68732 60431,41.471206,-87.93909 @@ -26686,9 +26811,14 @@ zipcode,_lat,_lon 60480,41.811929,-87.68732 60481,41.35934,-88.084716 60482,41.811929,-87.68732 +60484,41.443025,-87.710477 +60487,41.563837,-87.830349 60490,41.679041,-88.140332 +60491,41.602698,-87.962605 60499,41.811929,-87.68732 60501,41.811929,-87.68732 +60502,41.787522,-88.260017 +60503,41.70767,-88.257742 60504,41.768399,-88.136616 60505,41.765478,-88.405446 60506,41.79083,-88.416837 @@ -26747,6 +26877,8 @@ zipcode,_lat,_lon 60568,41.935616,-88.43238 60570,41.839679,-88.088716 60572,41.839679,-88.088716 +60585,41.657058,-88.225243 +60586,41.571556,-88.238218 60597,41.839679,-88.088716 60598,41.839679,-88.088716 60599,41.839679,-88.088716 @@ -26789,6 +26921,7 @@ zipcode,_lat,_lon 60639,41.811929,-87.68732 60640,41.811929,-87.68732 60641,41.811929,-87.68732 +60642,41.902042,-87.658544 60643,41.811929,-87.68732 60644,41.811929,-87.68732 60645,42.00808,-87.721458 @@ -26888,6 +27021,7 @@ zipcode,_lat,_lon 60955,40.758445,-87.852046 60956,40.966993,-87.716074 60957,40.660905,-88.197834 +60958,41.065203,-87.591599 60959,40.720981,-88.186732 60960,40.422456,-87.858213 60961,41.099001,-88.198405 @@ -27258,6 +27392,7 @@ zipcode,_lat,_lon 61701,40.462041,-88.850396 61702,40.519236,-88.864303 61704,40.491715,-88.982373 +61705,40.523132,-89.07201 61709,40.461431,-88.953015 61710,40.477735,-88.954174 61720,40.568549,-88.722113 @@ -27811,6 +27946,8 @@ zipcode,_lat,_lon 62707,39.785116,-89.632205 62708,39.806089,-89.586356 62709,39.749457,-89.606017 +62711,39.766136,-89.732756 +62712,39.748065,-89.581282 62713,39.749457,-89.606017 62715,39.749457,-89.606017 62716,39.848201,-89.536369 @@ -28190,6 +28327,7 @@ zipcode,_lat,_lon 63365,38.716287,-90.875127 63366,38.823944,-90.742745 63367,38.791341,-90.74284 +63368,38.751545,-90.728422 63369,38.94773,-90.8106 63370,39.077584,-91.231719 63373,38.92592,-90.38632 @@ -28197,6 +28335,7 @@ zipcode,_lat,_lon 63377,39.076463,-90.996268 63378,38.770187,-91.188586 63379,39.016299,-90.940268 +63380,38.813115,-91.12213 63381,39.022137,-90.996785 63382,39.251403,-91.530807 63383,38.808454,-91.2166 @@ -29211,6 +29350,7 @@ zipcode,_lat,_lon 65814,37.25807,-93.343673 65817,37.25807,-93.343673 65890,37.25807,-93.343673 +65897,37.199857,-93.280538 65898,37.180349,-93.295137 65899,37.181498,-93.259586 66002,39.535948,-95.225098 @@ -29951,6 +30091,7 @@ zipcode,_lat,_lon 67840,37.237186,-99.82422 67841,37.624913,-100.27543 67842,37.587839,-99.799449 +67843,37.730253,-99.93724 67844,37.279983,-100.211034 67846,38.000771,-100.664407 67849,38.121492,-99.709532 @@ -30164,6 +30305,7 @@ zipcode,_lat,_lon 68376,40.167245,-95.945731 68377,40.232006,-97.028942 68378,40.345196,-96.000386 +68379,40.529115,-95.869802 68380,40.195573,-96.379188 68381,40.262266,-96.689998 68382,40.653589,-96.086904 @@ -31523,6 +31665,7 @@ zipcode,_lat,_lon 72016,34.968975,-92.626882 72017,34.785525,-91.573785 72018,34.597345,-92.622857 +72019,34.633802,-92.699001 72020,35.380014,-91.525309 72021,34.883421,-91.194574 72022,34.612417,-92.493519 @@ -31753,6 +31896,7 @@ zipcode,_lat,_lon 72402,35.80881,-90.652887 72403,35.830541,-90.703915 72404,35.779183,-90.766012 +72405,35.90269,-90.650204 72410,35.952057,-91.030074 72411,35.810496,-90.641731 72412,36.128069,-90.691421 @@ -31937,6 +32081,7 @@ zipcode,_lat,_lon 72704,36.087732,-94.309322 72711,36.397805,-94.043837 72712,36.347107,-94.223419 +72713,36.297956,-94.282784 72714,36.426659,-94.330765 72715,36.442323,-94.427298 72716,36.299507,-93.956801 @@ -32088,6 +32233,7 @@ zipcode,_lat,_lon 73022,35.525192,-97.992347 73023,35.031247,-97.881959 73024,35.378409,-98.781794 +73025,35.729682,-97.569841 73026,35.23429,-97.291356 73027,35.950214,-97.291688 73028,35.977031,-97.628098 @@ -32448,6 +32594,7 @@ zipcode,_lat,_lon 73949,36.507508,-101.780668 73950,36.866365,-100.877878 73951,36.971874,-101.073973 +73960,36.491667,-101.792613 74001,36.490056,-96.061608 74002,36.561588,-96.162409 74003,36.759485,-95.970182 @@ -32465,6 +32612,7 @@ zipcode,_lat,_lon 74016,36.495713,-95.435688 74017,36.348616,-95.604344 74018,36.343579,-95.605964 +74019,36.284767,-95.603193 74020,36.263766,-96.443319 74021,36.370042,-95.857143 74022,36.800524,-95.922953 @@ -32870,8 +33018,10 @@ zipcode,_lat,_lon 75029,33.20743,-97.116282 75030,32.91747,-96.534737 75032,32.886,-96.409502 +75033,33.184818,-96.844308 75034,33.152222,-96.796437 75035,33.157083,-96.772929 +75036,33.133351,-96.914663 75037,32.767268,-96.777626 75038,32.767268,-96.777626 75039,32.73178,-96.82273 @@ -32903,6 +33053,7 @@ zipcode,_lat,_lon 75069,33.141438,-96.588295 75070,33.230381,-96.627018 75071,0,0 +75072,33.187899,-96.699951 75074,33.109044,-96.578819 75075,33.162417,-96.71546 75076,33.817503,-96.676191 @@ -32966,6 +33117,7 @@ zipcode,_lat,_lon 75153,32.165005,-96.338746 75154,32.484383,-96.795429 75155,32.300757,-96.735335 +75156,32.277923,-96.105287 75157,32.455407,-96.439495 75158,32.463618,-96.384263 75159,32.620763,-96.573555 @@ -33289,6 +33441,7 @@ zipcode,_lat,_lon 75713,32.411237,-95.289903 75750,32.27795,-95.067302 75751,32.188097,-95.882391 +75752,32.251937,-95.799861 75754,32.423029,-95.712867 75755,32.571552,-95.057746 75756,32.232783,-95.575732 @@ -33321,6 +33474,7 @@ zipcode,_lat,_lon 75799,32.411237,-95.289903 75801,31.848542,-95.685179 75802,31.926836,-95.579561 +75803,31.881777,-95.679494 75831,31.412142,-95.990369 75832,31.794191,-95.661964 75833,31.363103,-95.899965 @@ -33388,6 +33542,7 @@ zipcode,_lat,_lon 75962,31.699494,-94.607432 75963,31.604573,-94.664127 75964,31.673736,-94.693206 +75965,31.728994,-94.626523 75966,30.838608,-93.767911 75968,31.24817,-93.973106 75969,31.440245,-94.869754 @@ -33460,6 +33615,7 @@ zipcode,_lat,_lon 76078,33.092103,-97.480329 76082,32.80864,-97.693195 76084,32.455147,-97.141191 +76085,32.861116,-97.692165 76086,32.780766,-97.806778 76087,32.753927,-97.786026 76088,32.847803,-97.860618 @@ -33538,6 +33694,8 @@ zipcode,_lat,_lon 76206,33.169379,-97.150558 76207,33.238378,-97.203975 76208,33.160393,-97.095421 +76209,33.2315,-97.109986 +76210,33.149467,-97.096016 76225,33.355828,-97.708353 76226,33.215066,-97.164644 76227,33.278066,-97.01748 @@ -34137,6 +34295,7 @@ zipcode,_lat,_lon 77402,29.83399,-95.434241 77404,28.798156,-95.651058 77406,29.50401,-95.919107 +77407,29.679616,-95.704357 77410,29.83399,-95.434241 77411,29.83399,-95.434241 77412,29.60466,-96.524899 @@ -34215,6 +34374,7 @@ zipcode,_lat,_lon 77494,29.83399,-95.434241 77496,29.525461,-95.756462 77497,29.525461,-95.756462 +77498,29.640973,-95.655782 77501,29.83399,-95.434241 77502,29.678179,-95.202911 77503,29.65955,-95.169129 @@ -34235,6 +34395,7 @@ zipcode,_lat,_lon 77520,29.83399,-95.434241 77521,29.83399,-95.434241 77522,29.83399,-95.434241 +77523,29.766302,-94.865759 77530,29.83399,-95.434241 77531,29.031236,-95.3908 77532,29.83399,-95.434241 @@ -34725,6 +34886,8 @@ zipcode,_lat,_lon 78538,26.332751,-97.96224 78539,26.328674,-98.139672 78540,26.319405,-98.190922 +78541,26.452135,-98.276811 +78542,26.432513,-98.089884 78543,26.297428,-97.98837 78545,26.562044,-99.133528 78547,26.339353,-98.737359 @@ -34750,6 +34913,7 @@ zipcode,_lat,_lon 78570,26.209065,-98.075583 78572,26.229639,-98.192732 78573,26.409709,-98.224206 +78574,26.31117,-98.372914 78575,26.006779,-97.547392 78576,26.193734,-98.101526 78577,26.186698,-98.127765 @@ -34803,6 +34967,7 @@ zipcode,_lat,_lon 78630,30.656817,-97.602552 78631,30.247879,-99.268227 78632,29.447211,-97.494649 +78633,30.738187,-97.754527 78634,30.551885,-97.554189 78635,30.225386,-98.542031 78636,30.21577,-98.405866 @@ -35384,6 +35549,7 @@ zipcode,_lat,_lon 79925,31.773452,-106.37709 79926,31.694842,-106.299987 79927,31.660671,-106.176474 +79928,31.678635,-106.115148 79929,31.694842,-106.299987 79930,31.809457,-106.464242 79931,31.694842,-106.299987 @@ -35459,6 +35625,7 @@ zipcode,_lat,_lon 80020,40.046064,-105.097151 80021,39.885388,-105.11389 80022,39.869835,-104.771527 +80023,39.975844,-105.009381 80024,39.844501,-104.918783 80025,39.93242,-105.287967 80026,40.026334,-105.104899 @@ -35486,9 +35653,12 @@ zipcode,_lat,_lon 80105,39.659461,-103.948538 80106,39.208967,-104.505121 80107,39.382844,-104.495911 +80108,39.444376,-104.853179 +80109,39.372344,-104.912085 80110,39.648958,-104.973852 80111,39.666811,-104.864703 80112,39.581238,-104.862194 +80113,39.644445,-104.965111 80116,39.30403,-104.756722 80117,39.370254,-104.421214 80118,39.213354,-104.950189 @@ -35501,6 +35671,8 @@ zipcode,_lat,_lon 80126,39.54372,-104.969143 80127,39.544307,-105.153074 80128,39.591827,-105.083196 +80129,39.546879,-105.011599 +80130,39.528342,-104.923869 80131,39.347863,-104.994708 80132,39.086393,-104.807666 80133,39.112138,-104.900328 @@ -35561,6 +35733,7 @@ zipcode,_lat,_lon 80243,39.738752,-104.408349 80244,39.738752,-104.408349 80246,39.708637,-104.931234 +80247,39.697809,-104.878897 80248,39.738752,-104.408349 80249,39.83776,-104.697674 80250,39.738752,-104.408349 @@ -35597,6 +35770,7 @@ zipcode,_lat,_lon 80302,40.063935,-105.390027 80303,40.067772,-105.27484 80304,40.114114,-105.369797 +80305,39.976873,-105.248683 80306,40.102219,-105.384694 80307,40.087835,-105.373507 80308,40.027672,-105.3868 @@ -35714,6 +35888,8 @@ zipcode,_lat,_lon 80551,40.464092,-104.885116 80553,40.628112,-105.569245 80601,39.942984,-104.786597 +80602,39.966162,-104.908888 +80603,39.951146,-104.660237 80610,40.675794,-104.607073 80611,40.443596,-104.240542 80612,40.597204,-104.869798 @@ -35818,6 +35994,7 @@ zipcode,_lat,_lon 80864,38.738943,-104.193088 80866,39.03635,-105.15597 80901,38.861469,-104.857828 +80902,38.683656,-104.82224 80903,38.828893,-104.809929 80904,38.861981,-104.874531 80905,38.844319,-104.801472 @@ -35838,8 +36015,11 @@ zipcode,_lat,_lon 80920,38.965298,-104.755956 80921,39.055054,-104.89122 80922,38.904817,-104.70124 +80923,38.926735,-104.714341 +80924,38.967295,-104.721983 80925,38.737774,-104.645854 80926,38.644087,-104.880825 +80927,38.9283,-104.658773 80928,38.645078,-104.395746 80929,38.846355,-104.624727 80930,38.824202,-104.493259 @@ -35850,6 +36030,8 @@ zipcode,_lat,_lon 80935,38.82469,-104.562027 80936,38.82469,-104.562027 80937,38.82469,-104.562027 +80938,38.906503,-104.656877 +80939,38.872785,-104.675754 80940,38.82469,-104.562027 80941,38.82469,-104.562027 80942,38.82469,-104.562027 @@ -35860,6 +36042,7 @@ zipcode,_lat,_lon 80947,38.82469,-104.562027 80949,38.82469,-104.562027 80950,38.82469,-104.562027 +80951,38.878533,-104.657577 80960,38.82469,-104.562027 80962,38.82469,-104.562027 80970,38.82469,-104.562027 @@ -36002,6 +36185,7 @@ zipcode,_lat,_lon 81290,38.358421,-105.106881 81301,37.318364,-107.880367 81302,37.357249,-107.935945 +81303,37.124375,-107.854835 81320,37.718233,-108.791671 81321,37.373594,-108.662826 81323,37.469333,-108.35245 @@ -36018,6 +36202,7 @@ zipcode,_lat,_lon 81335,37.508114,-108.744007 81401,38.443069,-108.050689 81402,38.485093,-107.885975 +81403,38.314564,-107.92836 81410,38.805013,-107.983125 81411,38.34867,-108.937369 81413,38.881646,-107.795704 @@ -36048,6 +36233,7 @@ zipcode,_lat,_lon 81504,39.123554,-108.589414 81505,39.14657,-108.626481 81506,39.089167,-108.566523 +81507,39.009885,-108.651873 81520,39.08246,-108.404055 81521,39.149614,-108.685164 81522,38.678448,-108.971863 @@ -36393,6 +36579,7 @@ zipcode,_lat,_lon 83404,43.433036,-111.660433 83405,43.323306,-111.782152 83406,43.444641,-111.963375 +83414,43.861439,-110.935725 83415,43.323306,-111.782152 83420,44.015259,-111.42527 83421,44.001141,-111.535095 @@ -36498,6 +36685,7 @@ zipcode,_lat,_lon 83643,44.625475,-116.449286 83644,43.577401,-116.590338 83645,44.38304,-116.651974 +83646,43.649585,-116.431758 83647,43.156195,-115.720455 83648,43.009282,-115.588317 83650,42.838437,-116.032163 @@ -36627,9 +36815,11 @@ zipcode,_lat,_lon 84002,40.320728,-110.435974 84003,40.395796,-111.803101 84004,40.459133,-111.773164 +84005,40.322736,-111.999426 84006,40.592045,-112.0786 84007,40.312539,-110.229816 84008,40.443106,-109.505593 +84009,40.553454,-112.018129 84010,40.874038,-111.870994 84011,40.963547,-112.115984 84013,40.183311,-111.919871 @@ -36663,6 +36853,7 @@ zipcode,_lat,_lon 84042,40.340251,-111.719923 84043,40.318139,-111.921078 84044,40.699401,-112.088875 +84045,40.292383,-111.928756 84046,40.990039,-109.704889 84047,40.608972,-111.885868 84049,40.489378,-111.485127 @@ -36696,6 +36887,7 @@ zipcode,_lat,_lon 84078,40.368246,-109.556103 84079,40.160179,-109.547839 84080,40.086909,-112.455046 +84081,40.602762,-112.038247 84082,40.410548,-111.394222 84083,40.7329,-113.991849 84084,40.606125,-111.978898 @@ -36710,6 +36902,7 @@ zipcode,_lat,_lon 84093,40.595025,-111.824566 84094,40.569893,-111.858617 84095,40.554098,-111.953891 +84096,40.487037,-112.099983 84097,40.297153,-111.670519 84098,40.702896,-111.548098 84101,40.756095,-111.900719 @@ -36740,6 +36933,7 @@ zipcode,_lat,_lon 84126,40.668068,-111.908297 84127,40.668068,-111.908297 84128,40.697645,-112.037673 +84129,40.653577,-111.962063 84130,40.668068,-111.908297 84131,40.668068,-111.908297 84132,40.772743,-111.838541 @@ -37013,6 +37207,7 @@ zipcode,_lat,_lon 85039,33.276539,-112.18717 85040,33.367267,-112.066878 85041,33.379728,-112.112254 +85042,33.355545,-112.052242 85043,33.276539,-112.18717 85044,33.338743,-111.97277 85045,33.302168,-112.122581 @@ -37045,11 +37240,37 @@ zipcode,_lat,_lon 85079,33.276539,-112.18717 85080,33.276539,-112.18717 85082,33.276539,-112.18717 +85083,33.745359,-112.174635 85085,33.276539,-112.18717 85086,33.276539,-112.18717 85087,33.276539,-112.18717 85098,33.276539,-112.18717 85099,33.276539,-112.18717 +85118,33.356986,-111.363091 +85119,33.386823,-111.508244 +85120,33.386881,-111.561667 +85121,33.137154,-111.914311 +85122,32.916724,-111.747972 +85123,32.713078,-111.678371 +85128,32.962838,-111.509785 +85131,32.653843,-111.577149 +85132,32.926956,-111.214093 +85135,32.99495,-110.779898 +85137,33.136397,-111.022592 +85138,33.017663,-111.991284 +85139,32.923874,-112.206708 +85140,33.248065,-111.489238 +85141,32.641808,-111.434533 +85142,33.192391,-111.66594 +85143,33.156022,-111.519755 +85145,32.541314,-111.391056 +85147,33.097774,-111.724833 +85172,32.904833,-111.955451 +85173,33.268271,-111.136483 +85191,32.984984,-111.446934 +85192,32.962942,-110.678531 +85193,32.813284,-111.840448 +85194,32.901117,-111.628048 85201,33.440695,-111.856967 85202,33.393484,-111.804513 85203,33.448876,-111.824363 @@ -37058,6 +37279,7 @@ zipcode,_lat,_lon 85206,33.390148,-111.717968 85207,33.443017,-111.743444 85208,33.395932,-111.663655 +85209,33.378291,-111.634444 85210,33.387296,-111.840095 85211,33.466313,-111.837345 85212,33.342476,-111.635307 @@ -37126,12 +37348,16 @@ zipcode,_lat,_lon 85283,33.373723,-111.876915 85284,33.343546,-111.914127 85285,33.276539,-112.18717 +85286,33.272273,-111.833863 85287,33.428511,-111.934865 85289,33.276539,-112.18717 85290,33.276539,-112.18717 85291,33.013502,-111.42979 85292,33.070467,-110.789035 +85295,33.305025,-111.737246 85296,33.314508,-111.748791 +85297,33.280504,-111.733395 +85298,33.239818,-111.728198 85299,33.276539,-112.18717 85301,33.276539,-112.18717 85302,33.276539,-112.18717 @@ -37207,9 +37433,14 @@ zipcode,_lat,_lon 85380,33.276539,-112.18717 85381,33.276539,-112.18717 85382,33.276539,-112.18717 +85383,33.798406,-112.305179 85385,33.276539,-112.18717 85387,33.276539,-112.18717 +85388,33.602425,-112.432075 85390,33.276539,-112.18717 +85392,33.47657,-112.309428 +85395,33.485001,-112.405856 +85396,33.53652,-112.702463 85501,33.476884,-110.868076 85502,33.421919,-110.81268 85530,33.038678,-109.785973 @@ -37283,6 +37514,7 @@ zipcode,_lat,_lon 85653,32.442979,-111.159344 85654,31.970131,-111.890713 85655,31.880077,-109.754263 +85658,32.515939,-111.152622 85662,31.531998,-110.909305 85670,31.880077,-109.754263 85671,31.880077,-109.754263 @@ -37337,6 +37569,9 @@ zipcode,_lat,_lon 85751,32.161972,-110.714678 85752,31.970131,-111.890713 85754,31.970131,-111.890713 +85755,32.468351,-110.981507 +85756,32.07033,-110.906256 +85757,32.128356,-111.122305 85775,31.970131,-111.890713 85777,32.071764,-110.859106 85901,34.570811,-110.032025 @@ -37369,6 +37604,7 @@ zipcode,_lat,_lon 86002,35.630842,-112.052427 86003,35.630842,-112.052427 86004,35.610905,-111.324353 +86005,35.087726,-111.619198 86011,35.630842,-112.052427 86015,35.630842,-112.052427 86016,35.630842,-112.052427 @@ -37409,6 +37645,7 @@ zipcode,_lat,_lon 86312,34.668291,-112.307777 86313,34.706724,-112.39773 86314,34.627778,-112.262805 +86315,34.674028,-112.289062 86320,34.970209,-112.263974 86321,34.583624,-113.164742 86322,34.569687,-111.809798 @@ -37439,6 +37676,7 @@ zipcode,_lat,_lon 86404,34.557533,-114.330704 86405,35.605301,-113.642712 86406,34.756714,-114.11897 +86409,35.461006,-114.01806 86411,35.605301,-113.642712 86412,35.397172,-113.843241 86413,35.30024,-114.221531 @@ -37568,6 +37806,8 @@ zipcode,_lat,_lon 87124,35.282859,-106.712495 87125,35.044339,-106.672872 87131,35.044339,-106.672872 +87144,35.330173,-106.710088 +87151,35.007689,-106.860341 87153,35.044339,-106.672872 87154,35.044339,-106.672872 87158,35.044339,-106.672872 @@ -37633,6 +37873,8 @@ zipcode,_lat,_lon 87504,35.893597,-106.007499 87505,35.656638,-105.946155 87506,35.606283,-106.075722 +87507,35.621812,-106.108636 +87508,35.52063,-105.945842 87509,35.521181,-105.981847 87510,36.219921,-106.262778 87511,36.064687,-106.077688 @@ -37665,6 +37907,7 @@ zipcode,_lat,_lon 87543,36.148617,-105.664751 87544,35.849514,-106.288482 87545,35.863858,-106.295255 +87547,35.81098,-106.207689 87548,36.189247,-106.217575 87549,36.331253,-106.002778 87551,36.728938,-106.515714 @@ -37755,6 +37998,7 @@ zipcode,_lat,_lon 88004,32.41815,-106.820075 88005,32.167296,-106.897176 88006,32.305193,-106.786259 +88007,32.389107,-106.975113 88008,31.87054,-106.626892 88009,32.055007,-108.62913 88011,32.324407,-106.668287 @@ -37799,6 +38043,7 @@ zipcode,_lat,_lon 88063,31.880055,-106.599975 88065,32.619444,-108.37041 88072,32.11871,-106.648973 +88081,32.219357,-106.293671 88101,34.497241,-103.294978 88102,34.628472,-103.391269 88103,34.401452,-103.326445 @@ -37987,6 +38232,7 @@ zipcode,_lat,_lon 88901,36.322484,-114.819717 88905,35.927901,-114.972061 89001,37.472491,-115.143709 +89002,35.998452,-114.961812 89003,36.819857,-116.609372 89004,36.088098,-115.608969 89005,36.020563,-114.82952 @@ -38018,12 +38264,14 @@ zipcode,_lat,_lon 89031,36.277966,-115.143685 89032,36.217968,-115.170919 89033,36.284511,-115.134488 +89034,36.809235,-114.149779 89036,35.927901,-114.972061 89039,35.252249,-114.871384 89040,36.570259,-114.473191 89041,36.655797,-116.004795 89042,37.759736,-114.972405 89043,37.759736,-114.972405 +89044,35.939868,-115.056288 89045,37.583805,-116.598559 89046,35.332725,-114.892999 89047,37.722454,-117.796454 @@ -38031,12 +38279,15 @@ zipcode,_lat,_lon 89049,38.262575,-116.624808 89052,35.987798,-115.116652 89053,35.927901,-114.972061 +89054,35.920973,-115.190516 89060,0,0 89061,0,0 89070,35.927901,-114.972061 89074,0,0 89077,0,0 +89081,36.258477,-115.107492 89084,0,0 +89085,36.309602,-115.198175 89086,0,0 89101,36.17372,-115.10647 89102,36.281327,-115.390646 @@ -38091,14 +38342,21 @@ zipcode,_lat,_lon 89154,35.927901,-114.972061 89155,35.927901,-114.972061 89156,36.20343,-115.036376 +89158,36.104781,-115.176621 89159,35.927901,-114.972061 89160,35.927901,-114.972061 +89161,36.03739,-115.508236 89163,35.927901,-114.972061 89164,35.927901,-114.972061 +89166,36.337311,-115.468547 +89169,36.124089,-115.141811 89170,35.927901,-114.972061 89173,35.927901,-114.972061 89177,35.927901,-114.972061 +89178,35.987826,-115.295353 +89179,35.891606,-115.327935 89180,35.927901,-114.972061 +89183,35.996194,-115.157976 89185,35.927901,-114.972061 89191,35.927901,-114.972061 89193,35.927901,-114.972061 @@ -38146,9 +38404,11 @@ zipcode,_lat,_lon 89434,39.591728,-119.716747 89435,40.541218,-119.586934 89436,39.651879,-119.659053 +89437,39.501156,-119.468805 89438,41.263287,-118.174506 89439,39.516486,-119.983252 89440,39.332488,-119.613509 +89441,39.68139,-119.687547 89442,39.639846,-119.302787 89444,38.844747,-119.35228 89445,41.213481,-117.706799 @@ -38159,6 +38419,7 @@ zipcode,_lat,_lon 89450,39.256357,-119.946371 89451,39.253908,-119.935619 89452,39.259103,-119.956585 +89460,38.902253,-119.792493 89494,0,0 89496,39.537979,-118.343592 89501,39.65558,-119.704614 @@ -38168,13 +38429,16 @@ zipcode,_lat,_lon 89505,39.52241,-119.835275 89506,39.695488,-119.811146 89507,39.54231,-119.816374 +89508,39.78062,-119.913755 89509,39.413458,-119.857022 89510,39.906211,-119.604367 89511,39.360265,-119.8057 89512,39.545363,-119.879069 89513,39.631922,-119.293722 89515,40.541218,-119.586934 +89519,39.478968,-119.857134 89520,40.541218,-119.586934 +89521,39.371633,-119.675912 89523,39.549297,-119.639031 89533,39.543941,-119.906109 89557,40.541218,-119.586934 @@ -38462,6 +38726,7 @@ zipcode,_lat,_lon 90747,33.867138,-118.253825 90748,33.786594,-118.298662 90749,33.786594,-118.298662 +90755,33.803166,-118.167132 90801,33.804309,-118.200957 90802,33.756024,-118.201101 90803,33.759885,-118.13016 @@ -38495,6 +38760,7 @@ zipcode,_lat,_lon 91003,33.786594,-118.298662 91006,33.786594,-118.298662 91007,33.786594,-118.298662 +91008,34.153159,-117.968818 91009,33.786594,-118.298662 91010,33.786594,-118.298662 91011,33.786594,-118.298662 @@ -38811,6 +39077,8 @@ zipcode,_lat,_lon 92007,33.023042,-117.274469 92008,33.016928,-116.846046 92009,33.082192,-117.267169 +92010,33.165392,-117.281425 +92011,33.106764,-117.296327 92013,33.016928,-116.846046 92014,32.974074,-117.224167 92018,33.016928,-116.846046 @@ -38857,6 +39125,7 @@ zipcode,_lat,_lon 92075,33.007075,-117.256769 92078,33.016928,-116.846046 92079,33.016928,-116.846046 +92081,33.164549,-117.24055 92082,33.016928,-116.846046 92083,33.016928,-116.846046 92084,33.016928,-116.846046 @@ -39047,6 +39316,7 @@ zipcode,_lat,_lon 92340,34.839964,-115.967051 92341,34.241137,-116.938548 92342,34.496921,-116.378323 +92344,34.39177,-117.406568 92345,34.839964,-115.967051 92346,34.156543,-117.14027 92347,35.012622,-116.191575 @@ -39080,6 +39350,7 @@ zipcode,_lat,_lon 92392,34.491985,-114.754916 92393,34.839964,-115.967051 92394,34.527103,-115.172471 +92395,34.504828,-117.298985 92397,34.839964,-115.967051 92398,34.926948,-116.709279 92399,34.06226,-116.971138 @@ -39173,6 +39444,7 @@ zipcode,_lat,_lon 92614,33.685319,-117.827913 92615,33.640302,-117.769442 92616,33.640302,-117.769442 +92617,33.641973,-117.841046 92618,33.641579,-117.73269 92619,33.66985,-117.765939 92620,33.691619,-117.765186 @@ -39327,6 +39599,7 @@ zipcode,_lat,_lon 93033,34.154141,-119.131326 93034,34.032383,-119.1343 93035,34.221157,-119.202365 +93036,34.248141,-119.153454 93040,34.435224,-118.785517 93041,34.148893,-119.15458 93042,34.113389,-119.112432 @@ -39447,6 +39720,7 @@ zipcode,_lat,_lon 93311,35.294405,-118.905173 93312,35.240577,-118.917413 93313,35.27581,-119.013543 +93314,35.393866,-119.244846 93380,35.294405,-118.905173 93381,35.294405,-118.905173 93382,35.294405,-118.905173 @@ -39581,6 +39855,7 @@ zipcode,_lat,_lon 93615,36.515805,-119.236871 93616,36.6524,-119.592015 93618,36.509532,-119.395365 +93619,36.914176,-119.593979 93620,37.073301,-120.623363 93621,36.723654,-119.051698 93622,36.772741,-120.213442 @@ -39595,6 +39870,7 @@ zipcode,_lat,_lon 93633,36.734051,-118.958777 93634,37.167262,-119.243637 93635,37.103768,-120.847479 +93636,36.984877,-119.877519 93637,36.928286,-120.182423 93638,37.023383,-119.977376 93639,37.160622,-119.945035 @@ -39647,12 +39923,15 @@ zipcode,_lat,_lon 93720,36.850729,-119.802227 93721,36.729049,-119.771526 93722,36.793291,-119.931132 +93723,36.789756,-119.952559 93724,36.746375,-119.639658 93725,36.620698,-119.730824 93726,36.726349,-119.759875 93727,36.763149,-119.673272 93728,36.756348,-119.817429 93729,36.746375,-119.639658 +93730,36.906027,-119.751141 +93737,36.753614,-119.645581 93740,36.746375,-119.639658 93741,36.746375,-119.639658 93744,36.746375,-119.639658 @@ -39826,6 +40105,7 @@ zipcode,_lat,_lon 94155,37.784827,-122.727802 94156,37.784827,-122.727802 94157,37.784827,-122.727802 +94158,37.772534,-122.388384 94159,37.784827,-122.727802 94160,37.784827,-122.727802 94161,37.784827,-122.727802 @@ -39928,6 +40208,7 @@ zipcode,_lat,_lon 94501,37.770563,-122.264779 94502,37.735088,-122.243067 94503,0,0 +94505,37.871268,-121.596984 94506,37.832075,-121.916718 94507,37.936723,-122.067431 94508,38.57145,-122.450215 @@ -39955,6 +40236,7 @@ zipcode,_lat,_lon 94530,37.918024,-122.30248 94531,37.920852,-121.723919 94533,38.278428,-122.020276 +94534,38.241946,-122.118272 94535,38.271218,-121.94123 94536,37.565285,-121.982721 94537,37.680181,-121.921498 @@ -40001,6 +40283,7 @@ zipcode,_lat,_lon 94579,37.688518,-122.147425 94580,37.68123,-122.133825 94581,38.509569,-122.3539 +94582,37.765347,-121.915432 94583,37.768556,-121.975531 94585,38.195385,-121.994935 94586,37.585883,-121.883018 @@ -40441,6 +40724,7 @@ zipcode,_lat,_lon 95464,39.276878,-122.868266 95465,38.406676,-123.020406 95466,39.056598,-123.525375 +95467,38.812954,-122.548099 95468,38.919145,-123.540572 95469,39.360935,-123.106751 95470,39.302446,-123.462532 @@ -40626,6 +40910,7 @@ zipcode,_lat,_lon 95743,38.377411,-121.444429 95746,38.756614,-121.183436 95747,38.779875,-121.335559 +95757,38.331652,-121.436979 95758,38.347205,-121.428681 95759,38.377411,-121.444429 95762,38.686847,-121.044846 @@ -40634,6 +40919,7 @@ zipcode,_lat,_lon 95776,38.695895,-121.709713 95798,38.619545,-121.961532 95799,38.619545,-121.961532 +95811,38.593792,-121.482158 95812,38.377411,-121.444429 95813,38.377411,-121.444429 95814,38.579055,-121.480905 @@ -41066,6 +41352,7 @@ zipcode,_lat,_lon 96970,11.140496,166.410291 97001,45.263301,-121.088513 97002,45.224241,-122.8198 +97003,45.503723,-122.864778 97004,45.247636,-122.468991 97005,45.496289,-122.800146 97006,45.52013,-122.860376 @@ -41129,6 +41416,8 @@ zipcode,_lat,_lon 97077,45.548616,-123.114725 97078,45.451976,-122.789257 97080,45.481252,-122.38675 +97086,45.445315,-122.527925 +97089,45.426416,-122.442992 97101,45.121454,-123.191368 97102,45.810934,-123.962989 97103,46.142206,-123.795996 @@ -41205,6 +41494,7 @@ zipcode,_lat,_lon 97233,45.515121,-122.496052 97236,45.484594,-122.504175 97238,45.580557,-122.374776 +97239,45.489938,-122.690453 97240,45.580557,-122.374776 97242,45.580557,-122.374776 97251,45.580557,-122.374776 @@ -41247,7 +41537,9 @@ zipcode,_lat,_lon 97312,44.936357,-123.038116 97313,44.984941,-122.998756 97314,44.965541,-123.006606 +97317,44.902416,-122.906292 97321,44.594489,-122.581676 +97322,44.627553,-123.017613 97324,44.377113,-123.588271 97325,44.799503,-122.900739 97326,44.638187,-123.538238 @@ -41370,6 +41662,7 @@ zipcode,_lat,_lon 97467,43.449523,-123.745579 97469,43.267918,-123.42545 97470,43.053573,-123.360805 +97471,43.21907,-123.487894 97472,43.863845,-122.99879 97473,43.671853,-123.825751 97476,42.800135,-124.433374 @@ -41445,6 +41738,7 @@ zipcode,_lat,_lon 97641,43.157855,-120.724397 97701,44.082037,-121.227125 97702,43.998448,-121.260298 +97703,44.176389,-121.382887 97707,43.843071,-121.576423 97708,44.001834,-120.94952 97709,44.001834,-120.94952 @@ -41575,6 +41869,7 @@ zipcode,_lat,_lon 98027,47.497419,-122.010699 98028,47.754219,-122.124643 98029,47.565587,-122.025754 +98030,47.367214,-122.198051 98031,47.379972,-122.16538 98032,47.432251,-121.803388 98033,47.673263,-122.187029 @@ -41613,8 +41908,10 @@ zipcode,_lat,_lon 98073,47.432251,-121.803388 98074,0,0 98075,0,0 +98077,47.752379,-122.060283 98082,47.432251,-121.803388 98083,47.432251,-121.803388 +98087,47.860067,-122.267267 98092,47.288362,-122.097976 98093,47.311041,-122.113791 98101,47.432251,-121.803388 @@ -41690,6 +41987,7 @@ zipcode,_lat,_lon 98226,48.768396,-122.486483 98227,48.814753,-121.988548 98228,48.814753,-121.988548 +98229,48.705945,-122.398326 98230,48.935767,-122.366448 98231,48.814753,-121.988548 98232,48.565955,-122.448358 @@ -41822,6 +42120,7 @@ zipcode,_lat,_lon 98387,47.058452,-122.41648 98388,47.132671,-122.331781 98390,47.176966,-122.15982 +98391,47.177103,-122.166173 98392,47.732624,-122.564557 98393,47.626717,-122.649953 98394,47.311117,-122.772503 @@ -42254,6 +42553,7 @@ zipcode,_lat,_lon 99350,46.148328,-119.559674 99352,46.282031,-119.491659 99353,46.315267,-119.371393 +99354,46.328769,-119.299255 99356,45.851428,-120.354257 99357,46.897589,-119.686316 99359,46.512828,-118.10237 @@ -42289,6 +42589,7 @@ zipcode,_lat,_lon 99522,61.108864,-149.440311 99523,61.108864,-149.440311 99524,61.108864,-149.440311 +99530,61.184682,-149.983704 99540,61.108864,-149.440311 99546,54.24018,-176.787412 99547,54.24018,-176.787412 @@ -42351,6 +42652,7 @@ zipcode,_lat,_lon 99620,62.117231,-163.237636 99621,60.314735,-163.118947 99622,60.314735,-163.118947 +99623,61.439281,-149.922743 99624,58.268704,-155.797078 99625,58.268704,-156.648418 99626,60.314735,-163.118947 diff --git a/src/environments/version.prod.ts b/src/environments/version.prod.ts index 920b2f40..23ee9c63 100644 --- a/src/environments/version.prod.ts +++ b/src/environments/version.prod.ts @@ -1,3 +1,3 @@ export const version = '2.0.0'; -export const buildDate = '2026-01-13T14:47:02.910Z'; -export const commitHash = '44fd41e'; \ No newline at end of file +export const buildDate = '2026-01-13T16:13:36.276Z'; +export const commitHash = '024bc7c'; \ No newline at end of file diff --git a/src/styles.scss b/src/styles.scss index b3429665..997e153c 100644 --- a/src/styles.scss +++ b/src/styles.scss @@ -548,6 +548,15 @@ body .ui-tabview.ui-tabview-top .ui-tabview-nav li.ui-state-active, body .ui-tab position: absolute; } +.tool-btn-container { + opacity: 1; + z-index: 2; + height: 50px; + top: 15px; + left: 15px; + position: absolute; +} + // .nodes path { // cursor: -webkit-grab; // cursor: grab; diff --git a/tsconfig.json b/tsconfig.json index 051dbe89..76ede5a1 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -22,7 +22,8 @@ "es6", "es2019", "es7", - "dom" + "dom", + "dom.iterable" ], "paths": { "@shared/*": [